@open-everywhere/provider-teams 0.0.0-stage → 0.1.1

package/dist/agent/channels/teams-engagement.d.ts

@@ -0,0 +1,174 @@
+import type { TeamsConversationScope, TeamsMessageActivity } from "eve/channels/teams";
+import { type EngagementRow, type Partition } from "@open-everywhere/core/agent/adapter-api.js";
+/** The RSC permission Microsoft requires before it delivers NON-MENTION messages in this scope, or
+ *  `undefined` for a scope the seam does not anchor (a 1:1 chat, which needs no grant — a personal
+ *  message is delivered to its own bot unconditionally). */
+export declare function teamsSeamGrant(scope: TeamsConversationScope): string | undefined;
+/** The named platform reason the seam is UNSUPPORTED without the tenant's RSC grant. One sentence,
+ *  naming the grant, so a log line or a doc row can carry it verbatim. */
+export declare function teamsSeamUnsupportedReason(scope: TeamsConversationScope): string;
+/**
+ * Is this activity MACHINE-AUTHORED — the agent itself, a Bot-Framework bot role, or any `28:`
+ * application id?
+ *
+ * 🔴 ONE PREDICATE, TWO CALLERS, AND THAT IS THE POINT. `teams-front.ts` computes this to decide
+ * whether an activity may wake anything, and the native gate below needs the SAME answer: a
+ * machine-authored CHANNEL activity is still FORWARDED to the native path (only the DM branch and
+ * the single-window branch drop one), so an engaged conversation would otherwise admit a bot's own
+ * post and self-trigger. A weaker second copy here — `from.role === "bot"` alone, say — would miss
+ * exactly the id-shaped cases the front catches.
+ */
+export declare function teamsMachineAuthored(a: TeamsMessageActivity): boolean;
+/**
+ * The engagement-registry anchor for one conversation, or `undefined` for a 1:1 chat.
+ *
+ * 🔴 IT IS THE ONE PREDICATE THE MAPPER AND THE FRONT SHARE. `bindTeams` publishes exactly this as
+ * `engagementKey`, so `stand_down`'s mark and this seam's read address the same row. Two spellings
+ * of "which conversations are anchored" is how a stop comes to mark a row no gate reads.
+ */
+export declare function teamsEngagementAnchor(scope: TeamsConversationScope, conversationId: string | undefined): string | undefined;
+/** Record that a NON-MENTION message arrived in this scope — positive proof the RSC grant is
+ *  consented, because Microsoft would not have delivered it otherwise. ONE-DIRECTIONAL: silence
+ *  here is not evidence of an absent grant (see the module header). */
+export declare function noteTeamsSeamDelivery(scope: TeamsConversationScope): void;
+/** Has a non-mention message ever arrived in this scope in this process? */
+export declare function teamsSeamDeliveryProven(scope: TeamsConversationScope): boolean;
+/**
+ * Declare the seam UNSUPPORTED-so-far for this scope, ONCE. Called when an @mention arms the seam
+ * and no non-mention message has yet proved the grant present. It logs and returns whether it
+ * logged, so a test can drive the once-ness; it never throws and never suppresses a wake.
+ */
+export declare function noteTeamsSeamArmed(scope: TeamsConversationScope): boolean;
+/** Test seam: clear both per-process flags. */
+export declare function resetTeamsSeamSupport(): void;
+/**
+ * What the seam says about one inbound activity. Four outcomes, and each names what the CALLER owes:
+ *
+ *  • `unanchored` — a 1:1 chat (or an activity with no conversation id). The seam has nothing to say
+ *    and the caller keeps today's path exactly.
+ *  • `engage` — an @mention. The caller marks the conversation engaged ({@link markTeamsEngaged});
+ *    the mention itself is answered by the caller's normal path, never by the seam. It carries the
+ *    row's `org` so the caller can DEDUPE the mark: a mark re-invites, which clears a `stopped`
+ *    flag, and a redelivered mention must never clear a stand-down nobody asked to lift.
+ *  • `deliver` — a plain message in an engaged conversation. The caller wakes a turn.
+ *  • `hold` — a plain message the seam does not admit. `stopped` says WHY, and it is the one field a
+ *    caller must branch on: `stopped: true` means the agent was asked to stand down here, so the
+ *    message must be SUPPRESSED outright — including on an ambient leg that never reads this
+ *    registry. `stopped: false` means the conversation simply is not engaged, which is not a
+ *    suppression: the caller keeps today's path.
+ */
+export type TeamsEngagementVerdict = {
+    readonly kind: "unanchored";
+    readonly reason: string;
+} | {
+    readonly kind: "engage";
+    readonly anchor: string;
+    readonly org: string;
+} | {
+    readonly kind: "deliver";
+    readonly anchor: string;
+    readonly reason: string;
+} | {
+    readonly kind: "hold";
+    readonly anchor: string;
+    readonly reason: string;
+    readonly stopped: boolean;
+};
+/** Injectable seams so the whole verdict is unit-tested without a store. */
+export interface TeamsEngagementDeps {
+    readonly getEngagement?: (p: Partition, anchor: string) => Promise<EngagementRow | null>;
+    readonly markEngaged?: (p: Partition, anchor: string, atIso: string) => Promise<void>;
+    readonly now?: () => string;
+}
+/**
+ * Resolve the seam for one verified message activity — READ-ONLY. The mark is a separate call
+ * ({@link markTeamsEngaged}) so that exactly one caller writes the row: two writers is how a mention
+ * comes to engage a conversation twice per activity, once on each path.
+ *
+ * ORDERING. A mention is settled before any read: it is always answered by the caller's own path, so
+ * its verdict costs no store round-trip. Only a plain message pays for a read, and it pays for
+ * exactly one — the ROW, not a boolean, because the row carries both facts the decision needs (is
+ * this engaged, and was the agent asked to stand down here) and two reads could disagree.
+ *
+ * The DECISION ITSELF IS CORE'S. `shouldDeliverReply` owns the disqualifier order and the reasons;
+ * this function only translates Teams facts into its input. Nothing here re-states the policy.
+ *
+ * FAIL-CLOSED on a store error: `getThreadEngagement` reads a failure as `null`, so an unreadable
+ * registry holds rather than delivers — the agent does not barge into a conversation it cannot prove
+ * it was invited to.
+ */
+export declare function resolveTeamsEngagement(a: TeamsMessageActivity, machineAuthored: boolean, deps?: TeamsEngagementDeps): Promise<TeamsEngagementVerdict>;
+/**
+ * Mark one conversation ENGAGED on an @mention, and declare the RSC dependency once.
+ *
+ * `participating: true` is the re-invitation: it promotes the row and CLEARS a previous stand-down,
+ * which is what "an @mention brings the agent back" means on every surface that wires this seam.
+ * Best-effort throughout — `markThreadEngaged` swallows a store failure, because engagement
+ * bookkeeping must never fail a turn.
+ *
+ * 🔴 THE PROMOTION CARRIES THE ACTIVITY ID, SO REPLAYING ONE THE ROW STILL HOLDS LIFTS NOTHING
+ * (OPE-1527). The
+ * Bot Framework redelivers an activity whenever it does not get a prompt 200, and a redelivered
+ * @mention is a REPLAYED invitation: it used to clear a `stopped` flag nobody asked to lift. The
+ * front's dedupe caught the ordinary case and could not catch this one, because it expires — its
+ * store TTL is ten minutes and a stand-down has no expiry at all, so a redelivery on a fresh process
+ * an hour later re-marked a stood-down conversation as engaged. `engagedBy` closes that durably: the
+ * store records the promoting id and refuses to clear `stopped` when a promotion repeats it. A
+ * SECOND, GENUINE @mention carries a different activity id and still brings the agent back, which is
+ * the behaviour this must not break.
+ *
+ * BE EXACT ABOUT THE REACH. The store keeps a BOUNDED LIST of recent promoters (OPE-1562), so what
+ * cannot be replayed is every promotion the list still holds — see `EngagementRow.recentPromoters`.
+ * Mention A, mention B, a stand-down, then a redelivery of A leaves the stop SET: a superseded
+ * mention is guarded like the latest one. What remains open is the BOUND — a replay of a mention
+ * that `PROMOTER_LIST_MAX` distinct later promotions have pushed off the list clears again.
+ */
+export declare function markTeamsEngaged(a: TeamsMessageActivity, deps?: TeamsEngagementDeps): Promise<string | null>;
+/**
+ * Has a stand-down landed on this partition's ROOM row?
+ *
+ * 🔴 FAIL-CLOSED, and the direction is the opposite of core's `isThreadStopped` on purpose. That
+ * predicate fails OPEN because it decides whether to SILENCE an answer the model has already
+ * written, where "unknown" must mean deliver. This one is a WAKE GATE: it decides whether to barge
+ * into a room nobody invited the agent into, where "unknown" must mean stay out. It is the same
+ * posture the group-chat branch of `teams-front.ts` takes two screens above, in its own words — an
+ * unreadable registry cannot prove the agent is still welcome.
+ *
+ * The cost is real and worth stating: while the operational store is unreadable, EVERY room on this
+ * surface holds its ambient wakes, including rooms nobody ever stood down. An @mention is
+ * unaffected — the addressed arm never reads this — so a person can still reach the agent through
+ * the affordance the stop copy itself points them at. That is the right trade for a gate whose
+ * failure mode in the other direction is an agent that keeps talking in a room that asked it to
+ * stop, and cannot be re-silenced because the same outage fails the write.
+ *
+ * It reads the store DIRECTLY rather than through `getThreadEngagement`, because that wrapper
+ * swallows an error to `null` and a null is indistinguishable from "no row" — which is exactly the
+ * distinction this answer turns on.
+ */
+export declare function teamsRoomWatchStopped(partition: Partition): Promise<boolean>;
+/** Store the ROOM-grain wake row for an ambient (undirected) Leg A wake — the row a later stop
+ *  marks. Best-effort: `markThreadEngaged` swallows a store failure, and a lost watch row costs a
+ *  stop that could not land, never a turn. */
+export declare function markTeamsRoomWatched(partition: Partition, atIso: string): Promise<void>;
+/**
+ * Lift a ROOM-grain stand-down on an @mention — the way back in, and the reason the room stop is not
+ * a trap. Without it a room stop would outlive every invitation: Leg E's mention mark promotes the
+ * CONVERSATION row, which says nothing about the room, so the room would stay silent with no verb
+ * able to reach it.
+ *
+ * `engagedBy` carries the mention's activity id for the same reason the conversation mark does — a
+ * redelivered mention must not lift a stand-down twice over.
+ */
+export declare function clearTeamsRoomStop(partition: Partition, atIso: string, engagedBy: string): Promise<void>;
+/**
+ * The NATIVE path's one-line admission (channels/teams.ts's mention gate): may this plain,
+ * non-mention message run a turn?
+ *
+ * It exists because the native channel is where a Teams turn is actually minted — the front holds no
+ * continuation-token primitive it could wake an existing native session with, so admitting the
+ * activity through the mention gate IS the wake. The front owns the SUPPRESSION half above it (a
+ * stood-down conversation is never forwarded at all) and the MARK, so this call only ever answers
+ * the delivery question, and it never writes.
+ */
+export declare function teamsEngagedAdmits(a: TeamsMessageActivity, deps?: TeamsEngagementDeps): Promise<boolean>;
+//# sourceMappingURL=teams-engagement.d.ts.map

package/dist/agent/channels/teams-engagement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"teams-engagement.d.ts","sourceRoot":"","sources":["../../../agent/channels/teams-engagement.ts"],"names":[],"mappings":"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"}

package/dist/agent/channels/teams-engagement.js

@@ -0,0 +1,336 @@
+// THE TEAMS AMBIENT ENGAGEMENT SEAM (chat-surface contract §2.5) — the Teams wiring over core's
+// pure engagement policy (`packages/core/agent/channels/engagement.ts`). It gives Teams the middle
+// posture Slack and Discord already have: an @mention marks the conversation ENGAGED, a later PLAIN
+// message in that conversation wakes the agent, and `stand_down` stores the stop.
+//
+// THE ANCHOR is `conversation.id`, and it names a different container per scope — which is exactly
+// what the seam wants:
+//   • a TEAM CHANNEL activity carries `<channelId>;messageid=<root>`, so the anchor is the REPLY
+//     CHAIN, not the channel. Engagement is per reply chain, matching Slack's per-thread grain.
+//   • a GROUP CHAT activity carries the CHAT id, so the anchor is the chat.
+//   • a 1:1 (personal) chat carries NO anchor at all. That omission is the honest half, and it is
+//     Discord's DM precedent (discord-identity.ts): a 1:1 is answered unconditionally, so no gate
+//     anywhere reads a mark on it and writing one would suppress nothing. `stand_down` refuses on a
+//     1:1 for the same reason, in its own words.
+//
+// 🔴 THE PLATFORM CONSTRAINT, AND WHY IT IS NOT A DEFECT. Microsoft delivers a NON-MENTION message
+// to a bot only where the tenant has consented to the matching resource-specific-consent (RSC)
+// grant: `ChannelMessage.Read.Group` for a team channel, `ChatMessage.Read.Chat` for a chat (both
+// are in `teams-app/manifest.json`). Without it, only @mention activities ever arrive, so the seam
+// is armed but nothing can exercise it — the surface answers once per mention, exactly as before.
+// There is NO API that reports whether a tenant granted an RSC permission, so this module states
+// the dependency out loud instead of guessing, and logs the named reason ONCE per scope while no
+// proof has arrived. Never a silent gap (contract §3), and never a refusal either — a declaration.
+//
+// 🔴 BE EXACT ABOUT WHAT THE PROOF COVERS, because the sentence here used to overstate it
+// (OPE-1527). The probe sits on the seam's own read, which the front reaches for a HUMAN-authored
+// activity with a RESOLVABLE partition and nothing else: a machine-authored activity skips the seam,
+// and an activity whose identity will not resolve returns `unanchored` above the probe. So the proof
+// is one-directional. A scope that HAS printed the proof is granted — Microsoft delivered a
+// non-mention message, and nothing else could have. A scope that has NOT printed it says only that
+// no such message has been SEEN in this process; the grant may be present and the traffic may simply
+// have been mentions, bot posts, or activities this deployment could not anchor. A serverless
+// invocation is a fresh process, so a granted tenant keeps printing "delivery UNPROVEN" per cold
+// start. That is the honest reading of a signal no API can give us, not a defect to design around.
+import { buildTeamsAuth, teamsMembershipType, teamsMode } from "./teams-identity.js";
+import { getOperationalStore, getThreadEngagement, markThreadEngaged, resolvePartition, roomEngagementAddress, shouldDeliverReply, } from "@open-everywhere/core/agent/adapter-api.js";
+/** The RSC permission Microsoft requires before it delivers NON-MENTION messages in this scope, or
+ *  `undefined` for a scope the seam does not anchor (a 1:1 chat, which needs no grant — a personal
+ *  message is delivered to its own bot unconditionally). */
+export function teamsSeamGrant(scope) {
+    if (scope === "personal")
+        return undefined;
+    return scope === "groupChat" ? "ChatMessage.Read.Chat" : "ChannelMessage.Read.Group";
+}
+/** The named platform reason the seam is UNSUPPORTED without the tenant's RSC grant. One sentence,
+ *  naming the grant, so a log line or a doc row can carry it verbatim. */
+export function teamsSeamUnsupportedReason(scope) {
+    const grant = teamsSeamGrant(scope) ?? "no RSC grant";
+    const room = scope === "groupChat" ? "group-chat" : "channel";
+    return (`Microsoft delivers non-mention ${room} messages only with the ${grant} RSC grant consented in this tenant; ` +
+        `without it a plain follow-up never reaches this deployment, so the engaged seam can wake nothing here`);
+}
+/**
+ * Is this activity MACHINE-AUTHORED — the agent itself, a Bot-Framework bot role, or any `28:`
+ * application id?
+ *
+ * 🔴 ONE PREDICATE, TWO CALLERS, AND THAT IS THE POINT. `teams-front.ts` computes this to decide
+ * whether an activity may wake anything, and the native gate below needs the SAME answer: a
+ * machine-authored CHANNEL activity is still FORWARDED to the native path (only the DM branch and
+ * the single-window branch drop one), so an engaged conversation would otherwise admit a bot's own
+ * post and self-trigger. A weaker second copy here — `from.role === "bot"` alone, say — would miss
+ * exactly the id-shaped cases the front catches.
+ */
+export function teamsMachineAuthored(a) {
+    // DEFENSIVE ON `recipient`, unlike the front's own copy. The front only ever sees an activity
+    // `parseTeamsActivity` produced, which always carries one; this is also called from the native
+    // handler, which a test or an ops script can drive with a hand-built activity. An absent recipient
+    // must not throw here — the author question still has two other answers.
+    const self = a.recipient?.id;
+    return (self !== undefined && a.from.id === self) || a.from.role === "bot" || a.from.id.startsWith("28:");
+}
+/**
+ * The engagement-registry anchor for one conversation, or `undefined` for a 1:1 chat.
+ *
+ * 🔴 IT IS THE ONE PREDICATE THE MAPPER AND THE FRONT SHARE. `bindTeams` publishes exactly this as
+ * `engagementKey`, so `stand_down`'s mark and this seam's read address the same row. Two spellings
+ * of "which conversations are anchored" is how a stop comes to mark a row no gate reads.
+ */
+export function teamsEngagementAnchor(scope, conversationId) {
+    if (!conversationId || conversationId.length === 0)
+        return undefined;
+    return teamsMode(scope) === "dm" ? undefined : conversationId;
+}
+// --- the RSC support declaration (per-process, once per scope) ---------------------------------
+//
+// Module-scoped once-flags, the same shape `teams-front.ts`'s `warnedDedupeStore` uses: a serverless
+// invocation is a fresh process, so "once" means once per cold start per scope rather than once
+// forever. That is the right grain — the declaration is for the operator reading logs, and a
+// deployment whose grant is missing keeps saying so on each cold start rather than saying it once
+// and never again.
+const seamDeliveryProven = new Set();
+const seamUnsupportedLogged = new Set();
+/** Record that a NON-MENTION message arrived in this scope — positive proof the RSC grant is
+ *  consented, because Microsoft would not have delivered it otherwise. ONE-DIRECTIONAL: silence
+ *  here is not evidence of an absent grant (see the module header). */
+export function noteTeamsSeamDelivery(scope) {
+    if (teamsSeamGrant(scope) !== undefined)
+        seamDeliveryProven.add(scope);
+}
+/** Has a non-mention message ever arrived in this scope in this process? */
+export function teamsSeamDeliveryProven(scope) {
+    return seamDeliveryProven.has(scope);
+}
+/**
+ * Declare the seam UNSUPPORTED-so-far for this scope, ONCE. Called when an @mention arms the seam
+ * and no non-mention message has yet proved the grant present. It logs and returns whether it
+ * logged, so a test can drive the once-ness; it never throws and never suppresses a wake.
+ */
+export function noteTeamsSeamArmed(scope) {
+    if (teamsSeamGrant(scope) === undefined)
+        return false; // a 1:1 needs no grant
+    if (seamDeliveryProven.has(scope) || seamUnsupportedLogged.has(scope))
+        return false;
+    seamUnsupportedLogged.add(scope);
+    // WORDED AS A DEPENDENCY, NOT A VERDICT. On a cold start whose first activity is a mention, nothing
+    // has been observed either way — and a serverless invocation is a fresh process, so that is the
+    // COMMON case even on a fully granted tenant. Saying "unsupported" there would be a confident wrong
+    // answer in an operator's log. The line says what the seam needs and what would prove it instead.
+    console.warn(`[open-everywhere:teams-engagement] engaged seam armed, delivery UNPROVEN in this process — ${teamsSeamUnsupportedReason(scope)}. One non-mention message from a person, in a conversation this deployment can anchor, would prove the grant present; nothing else this process sees can.`);
+    return true;
+}
+/** Test seam: clear both per-process flags. */
+export function resetTeamsSeamSupport() {
+    seamDeliveryProven.clear();
+    seamUnsupportedLogged.clear();
+}
+/**
+ * The partition one activity's engagement row lives in — the CONVERSATION grain
+ * (`teams/<tenant>/<conversationId>`), never `domainKeyOf`'s channel grain.
+ *
+ * 🔴 THE GRAIN IS THE CONTRACT WITH `stand_down`. The verb resolves its own partition through
+ * `bindFrom` → `resolvePartition`, which keys on the binding's `surface` (the conversation). A seam
+ * that read the widened channel key would look at a different row from the one the stop marked, and
+ * the stop would suppress nothing. Null on an unresolvable identity — the caller then keeps today's
+ * path, the fail-open posture every carriage leg in this file family takes.
+ */
+function teamsSeamPartition(a) {
+    try {
+        const auth = buildTeamsAuth({
+            userId: a.from.id,
+            tenantId: a.tenantId ?? a.conversation.tenantId,
+            conversationId: a.conversation.id,
+            channelId: a.teamsChannelId,
+            teamId: a.teamId,
+            scope: a.scope,
+            membershipType: teamsMembershipType(a.channelData),
+        });
+        return resolvePartition({ channel: { kind: "teams" }, session: { auth: { current: auth } } });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the seam for one verified message activity — READ-ONLY. The mark is a separate call
+ * ({@link markTeamsEngaged}) so that exactly one caller writes the row: two writers is how a mention
+ * comes to engage a conversation twice per activity, once on each path.
+ *
+ * ORDERING. A mention is settled before any read: it is always answered by the caller's own path, so
+ * its verdict costs no store round-trip. Only a plain message pays for a read, and it pays for
+ * exactly one — the ROW, not a boolean, because the row carries both facts the decision needs (is
+ * this engaged, and was the agent asked to stand down here) and two reads could disagree.
+ *
+ * The DECISION ITSELF IS CORE'S. `shouldDeliverReply` owns the disqualifier order and the reasons;
+ * this function only translates Teams facts into its input. Nothing here re-states the policy.
+ *
+ * FAIL-CLOSED on a store error: `getThreadEngagement` reads a failure as `null`, so an unreadable
+ * registry holds rather than delivers — the agent does not barge into a conversation it cannot prove
+ * it was invited to.
+ */
+export async function resolveTeamsEngagement(a, machineAuthored, deps = {}) {
+    const anchor = teamsEngagementAnchor(a.scope, a.conversation.id);
+    if (!anchor)
+        return { kind: "unanchored", reason: "a 1:1 chat carries no engagement anchor — it is answered unconditionally" };
+    const partition = teamsSeamPartition(a);
+    if (!partition)
+        return { kind: "unanchored", reason: "the activity has no resolvable partition — no row to address" };
+    if (a.isBotMentioned)
+        return { kind: "engage", anchor, org: partition.org };
+    // A non-mention message ARRIVED, which is positive proof Microsoft is delivering this scope's
+    // ambient traffic — the RSC grant is consented. Recorded before the decision, so a stood-down
+    // conversation still counts as proof.
+    noteTeamsSeamDelivery(a.scope);
+    const read = deps.getEngagement ?? ((p, key) => getThreadEngagement(p, key));
+    const row = await read(partition, anchor);
+    const decision = shouldDeliverReply({
+        isEngaged: row !== null,
+        stopped: row?.stopped ?? false,
+        authorIsBot: machineAuthored,
+        isAppMention: false, // settled above — a mention never reaches this branch
+        inThread: true, // an anchored Teams conversation IS the container engagement is kept per
+    });
+    if (decision.deliver)
+        return { kind: "deliver", anchor, reason: decision.reason };
+    return { kind: "hold", anchor, reason: decision.reason, stopped: row?.stopped === true };
+}
+/**
+ * Mark one conversation ENGAGED on an @mention, and declare the RSC dependency once.
+ *
+ * `participating: true` is the re-invitation: it promotes the row and CLEARS a previous stand-down,
+ * which is what "an @mention brings the agent back" means on every surface that wires this seam.
+ * Best-effort throughout — `markThreadEngaged` swallows a store failure, because engagement
+ * bookkeeping must never fail a turn.
+ *
+ * 🔴 THE PROMOTION CARRIES THE ACTIVITY ID, SO REPLAYING ONE THE ROW STILL HOLDS LIFTS NOTHING
+ * (OPE-1527). The
+ * Bot Framework redelivers an activity whenever it does not get a prompt 200, and a redelivered
+ * @mention is a REPLAYED invitation: it used to clear a `stopped` flag nobody asked to lift. The
+ * front's dedupe caught the ordinary case and could not catch this one, because it expires — its
+ * store TTL is ten minutes and a stand-down has no expiry at all, so a redelivery on a fresh process
+ * an hour later re-marked a stood-down conversation as engaged. `engagedBy` closes that durably: the
+ * store records the promoting id and refuses to clear `stopped` when a promotion repeats it. A
+ * SECOND, GENUINE @mention carries a different activity id and still brings the agent back, which is
+ * the behaviour this must not break.
+ *
+ * BE EXACT ABOUT THE REACH. The store keeps a BOUNDED LIST of recent promoters (OPE-1562), so what
+ * cannot be replayed is every promotion the list still holds — see `EngagementRow.recentPromoters`.
+ * Mention A, mention B, a stand-down, then a redelivery of A leaves the stop SET: a superseded
+ * mention is guarded like the latest one. What remains open is the BOUND — a replay of a mention
+ * that `PROMOTER_LIST_MAX` distinct later promotions have pushed off the list clears again.
+ */
+export async function markTeamsEngaged(a, deps = {}) {
+    const anchor = teamsEngagementAnchor(a.scope, a.conversation.id);
+    if (!anchor)
+        return null;
+    const partition = teamsSeamPartition(a);
+    if (!partition)
+        return null;
+    const now = deps.now ?? (() => new Date().toISOString());
+    const mark = deps.markEngaged ?? ((p, key, atIso) => markThreadEngaged(p, key, atIso, { participating: true, engagedBy: a.id }));
+    await mark(partition, anchor, now());
+    // The seam is armed here. Whether Microsoft will DELIVER the follow-ups is the tenant's RSC grant,
+    // which nothing can probe — so say it once rather than leave the gap silent.
+    noteTeamsSeamArmed(a.scope);
+    return anchor;
+}
+// --- THE ROOM-GRAIN WATCH ROW (OPE-1511) -------------------------------------------------------
+//
+// 🔴 A SECOND GRAIN, FOR A SECOND WAKE. Everything above is keyed per CONVERSATION, because an
+// @mention engages a reply chain. Leg A of the single-window front (teams-front.ts) is a different
+// wake with a different grain: on a vouched channel it wakes on ANY message in the ROOM, including a
+// reply chain nobody ever @mentioned the agent in. That wake read no registry of its own, so
+// `stand_down` found no row, refused, and the only off switch left was an operator un-vouching the
+// surface — a person in the room could not stop it and the agent could not stop it for them.
+//
+// THE RULE IS THAT A STORED STOP EXISTS EXACTLY WHERE A STORED WAKE EXISTS. So Leg A stores a
+// room-grain row on each ambient wake, its own gate reads that row's `stopped` flag, and
+// `tools/stand_down.ts` marks it when the conversation grain holds nothing. The address is core's
+// (`roomEngagementAddress`), derived from the partition by BOTH sides, so the wake and the stop
+// cannot drift onto two spellings of one room.
+//
+// WHAT THE ROOM ROW IS AND IS NOT. Leg E never reads it: the seam above keys on the CONVERSATION and
+// is untouched by any of this. The only two fields that matter here are `stopped` and — through the
+// promotion that clears it — `recentPromoters`.
+//
+// 🔴 `participating` ON A ROOM ROW MEANS NOTHING, AND THAT IS A HAZARD WORTH NAMING. An ambient
+// WATCH writes `participating: false`, but the @mention clear below writes `true`, and the flag is
+// monotonic in both store backends — so after the first @mention in the room it stays `true`
+// forever. Nothing reads it today: no production caller reads `listEngagements`, and Teams never
+// calls `bumpSilentStreak`, which is what the flag exists to gate. It is set as a side effect of
+// being the only way to clear `stopped`, not as a claim that anybody invited the agent into the
+// room. A future warm-shed rule must not read this row and conclude the agent was invited here.
+/**
+ * Has a stand-down landed on this partition's ROOM row?
+ *
+ * 🔴 FAIL-CLOSED, and the direction is the opposite of core's `isThreadStopped` on purpose. That
+ * predicate fails OPEN because it decides whether to SILENCE an answer the model has already
+ * written, where "unknown" must mean deliver. This one is a WAKE GATE: it decides whether to barge
+ * into a room nobody invited the agent into, where "unknown" must mean stay out. It is the same
+ * posture the group-chat branch of `teams-front.ts` takes two screens above, in its own words — an
+ * unreadable registry cannot prove the agent is still welcome.
+ *
+ * The cost is real and worth stating: while the operational store is unreadable, EVERY room on this
+ * surface holds its ambient wakes, including rooms nobody ever stood down. An @mention is
+ * unaffected — the addressed arm never reads this — so a person can still reach the agent through
+ * the affordance the stop copy itself points them at. That is the right trade for a gate whose
+ * failure mode in the other direction is an agent that keeps talking in a room that asked it to
+ * stop, and cannot be re-silenced because the same outage fails the write.
+ *
+ * It reads the store DIRECTLY rather than through `getThreadEngagement`, because that wrapper
+ * swallows an error to `null` and a null is indistinguishable from "no row" — which is exactly the
+ * distinction this answer turns on.
+ */
+export async function teamsRoomWatchStopped(partition) {
+    const room = roomEngagementAddress(partition);
+    try {
+        return (await getOperationalStore().getEngagement(room.partition.org, room.partition.surfaceKey, room.anchor))?.stopped === true;
+    }
+    catch (err) {
+        console.warn(`[open-everywhere:teams-engagement] room stop unreadable for ${room.partition.surfaceKey} — HOLDING the ambient wake (fail-closed): ${String(err)}`);
+        return true;
+    }
+}
+/** Store the ROOM-grain wake row for an ambient (undirected) Leg A wake — the row a later stop
+ *  marks. Best-effort: `markThreadEngaged` swallows a store failure, and a lost watch row costs a
+ *  stop that could not land, never a turn. */
+export async function markTeamsRoomWatched(partition, atIso) {
+    const room = roomEngagementAddress(partition);
+    // `participating: false` — a WATCH, not an invitation. It also means this write never clears a
+    // `stopped` flag, which is what keeps an ambient wake from lifting the stand-down that should be
+    // suppressing it.
+    await markThreadEngaged(room.partition, room.anchor, atIso, { participating: false });
+}
+/**
+ * Lift a ROOM-grain stand-down on an @mention — the way back in, and the reason the room stop is not
+ * a trap. Without it a room stop would outlive every invitation: Leg E's mention mark promotes the
+ * CONVERSATION row, which says nothing about the room, so the room would stay silent with no verb
+ * able to reach it.
+ *
+ * `engagedBy` carries the mention's activity id for the same reason the conversation mark does — a
+ * redelivered mention must not lift a stand-down twice over.
+ */
+export async function clearTeamsRoomStop(partition, atIso, engagedBy) {
+    const room = roomEngagementAddress(partition);
+    await markThreadEngaged(room.partition, room.anchor, atIso, { participating: true, engagedBy });
+}
+/**
+ * The NATIVE path's one-line admission (channels/teams.ts's mention gate): may this plain,
+ * non-mention message run a turn?
+ *
+ * It exists because the native channel is where a Teams turn is actually minted — the front holds no
+ * continuation-token primitive it could wake an existing native session with, so admitting the
+ * activity through the mention gate IS the wake. The front owns the SUPPRESSION half above it (a
+ * stood-down conversation is never forwarded at all) and the MARK, so this call only ever answers
+ * the delivery question, and it never writes.
+ */
+export async function teamsEngagedAdmits(a, deps = {}) {
+    if (a.isBotMentioned)
+        return true; // the caller's own mention gate already admitted it
+    // 🔴 THE AUTHOR GATE RUNS HERE TOO, over the SAME predicate the front uses. A machine-authored
+    // CHANNEL activity IS forwarded to the native path, so this is the line that stops an engaged
+    // conversation from admitting the agent's own post and looping on itself.
+    const verdict = await resolveTeamsEngagement(a, teamsMachineAuthored(a), deps);
+    return verdict.kind === "deliver";
+}
+//# sourceMappingURL=teams-engagement.js.map

package/dist/agent/channels/teams-engagement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"teams-engagement.js","sourceRoot":"","sources":["../../../agent/channels/teams-engagement.ts"],"names":[],"mappings":"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"}

package/dist/agent/channels/teams-fire-eligibility.d.ts

@@ -0,0 +1,26 @@
+import type { TeamsAccountActiveCheck, TeamsRoomMembership, TeamsRoomMembershipCheck } from "@open-everywhere/core/agent/adapter-api.js";
+import { type TeamsGraphRequester } from "./teams-read.js";
+/**
+ * Is `aadObjectId` a member of Teams channel `channelId` (inside team `botTeamId`) RIGHT NOW?
+ * Resolves `botTeamId` — the activity's own Bot Connector team id — into the Microsoft 365 group id
+ * Graph takes, then paginates `GET /teams/{team}/channels/{channel}/members`, bounded at
+ * {@link TEAMS_MEMBER_MAX_PAGES}.
+ *
+ * Pure but for the injected `req` — exported (not the `req`-defaulted live wrapper below) so the
+ * resolution, the pagination and every fail-open arm are unit-testable with a canned requester, no
+ * token mint and no network call. The team-id resolution is driven in a test through
+ * teams-graph-team-id.ts's own `_seedTeamsGraphTeamIdForTest` seam rather than a second injected
+ * dependency here: one team id maps to one group id for the life of the process, so the cache IS
+ * the seam.
+ */
+export declare function teamsRoomMembershipViaGraph(botTeamId: string, channelId: string, aadObjectId: string, serviceUrl: string | undefined, req: TeamsGraphRequester): Promise<TeamsRoomMembership>;
+/** Live default: {@link teamsRoomMembershipViaGraph} through the real Graph token + transport. */
+export declare const liveTeamsRoomMembership: TeamsRoomMembershipCheck;
+/**
+ * Is `aadObjectId`'s Entra account CURRENTLY enabled? `GET /users/{id}?$select=accountEnabled`.
+ * Pure but for the injected `req` — same DI shape as {@link teamsRoomMembershipViaGraph}.
+ */
+export declare function teamsAccountActiveViaGraph(aadObjectId: string, req: TeamsGraphRequester): Promise<boolean | undefined>;
+/** Live default: {@link teamsAccountActiveViaGraph} through the real Graph token + transport. */
+export declare const liveTeamsAccountActive: TeamsAccountActiveCheck;
+//# sourceMappingURL=teams-fire-eligibility.d.ts.map

package/dist/agent/channels/teams-fire-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"teams-fire-eligibility.d.ts","sourceRoot":"","sources":["../../../agent/channels/teams-fire-eligibility.ts"],"names":[],"mappings":"AA6CA,OAAO,KAAK,EACV,uBAAuB,EAEvB,mBAAmB,EACnB,wBAAwB,EACzB,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EAAyB,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAuBlF;;;;;;;;;;;;GAYG;AACH,wBAAsB,2BAA2B,CAC/C,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,GAAG,EAAE,mBAAmB,GACvB,OAAO,CAAC,mBAAmB,CAAC,CA4B9B;AAED,kGAAkG;AAClG,eAAO,MAAM,uBAAuB,EAAE,wBAC0D,CAAC;AAMjG;;;GAGG;AACH,wBAAsB,0BAA0B,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAY5H;AAED,iGAAiG;AACjG,eAAO,MAAM,sBAAsB,EAAE,uBAAyG,CAAC"}