@patimweb/pi-teams 1.0.0 → 1.2.0

package/src/config/index.ts

@@ -37,6 +37,7 @@ import {
 	type PermissionBlock,
 	type ResolvedPermissions,
 } from "./scope.ts";
+import { canOpenBrowser } from "../utils/environment.ts";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -45,15 +46,23 @@ import {
 /**
  * How pi obtains a token.
  *
- * - `device-code`: delegated. pi acts **as the signed-in user** — messages are
- *   sent from their account and everything they can see, pi can see.
+ * - `interactive`: delegated. The browser opens at the Microsoft sign-in page
+ *   and MSAL catches the redirect on a loopback port. pi then acts **as the
+ *   signed-in user** — messages come from their account, and everything they
+ *   can see, pi can see.
+ * - `device-code`: delegated as well, but the user types a short code on
+ *   another device. For SSH sessions, containers, and anything headless.
  * - `client-credentials`: app-only. No user identity; Microsoft Graph does not
  *   allow posting chat or channel messages this way (outside of migration
  *   scenarios), so writes are refused with an explanation.
- * - `auto`: use `client-credentials` when a secret is configured, otherwise
- *   `device-code`.
+ * - `auto`: `client-credentials` when a secret is configured, otherwise
+ *   `interactive` where a browser is reachable and `device-code` where it is
+ *   not.
  */
-export type AuthMode = "device-code" | "client-credentials" | "auto";
+export type AuthMode = "interactive" | "device-code" | "client-credentials" | "auto";
+
+/** An auth mode after "auto" has been resolved away. */
+export type ResolvedAuthMode = "interactive" | "device-code" | "client-credentials";
 
 /** Safety level for mutation operations. */
 export type SafetyLevel = "open" | "confirm" | "readonly";
@@ -72,15 +81,62 @@ export interface TenantConfig {
 	authMode?: AuthMode;
 	/** Requested Graph scopes override */
 	scopes?: string[];
+	/** Fixed loopback port for the browser sign-in redirect */
+	loopbackPort?: number;
 	/** Safety level override — most specific wins */
 	safetyLevel?: SafetyLevel;
 	/** Scope rules layered on top of the account's */
 	permissions?: PermissionBlock;
 }
 
+/**
+ * Settings for "listen" mode — where pi is woken by an incoming Teams chat.
+ *
+ * Every field is optional and merges field by field down the cascade
+ * (global → account), so an interval can be set once while the chat filter is
+ * narrowed per account.
+ */
+export interface WatchConfig {
+	/** Whether the watcher runs at all (default: false) */
+	enabled?: boolean;
+	/** Seconds between polls (default: 60, minimum: 15) */
+	intervalSeconds?: number;
+	/**
+	 * Glob patterns for the chats to watch — matched against topic, label,
+	 * chat ID and participant names, exactly like the scope rules. Empty or
+	 * absent means every recent chat.
+	 */
+	chats?: string[];
+	/**
+	 * Only wake pi for messages from these people — matched against display
+	 * name, UPN and e-mail. Empty or absent means any sender.
+	 *
+	 * This is the "listen to these people" switch: `chats` decides *where* pi
+	 * listens, `from` decides *to whom*.
+	 */
+	from?: string[];
+	/** Only wake pi where the signed-in user is mentioned (default: false) */
+	mentionOnly?: boolean;
+	/** Seconds to stay quiet in a chat after waking pi for it (default: 300) */
+	cooldownSeconds?: number;
+	/** Hard cap on wakes per hour, across all chats (default: 10) */
+	maxTriggersPerHour?: number;
+}
+
+/** A watch config after every default and clamp has been applied. */
+export interface ResolvedWatchConfig {
+	enabled: boolean;
+	intervalSeconds: number;
+	chats: string[];
+	from: string[];
+	mentionOnly: boolean;
+	cooldownSeconds: number;
+	maxTriggersPerHour: number;
+}
+
 /** A Teams identity pi can sign in as. */
 export interface AccountConfig {
-	/** Short label used in tool parameters, e.g. "neoimpulse" */
+	/** Short label used in tool parameters, e.g. "work" */
 	name: string;
 	/** Friendly name for status output */
 	displayName?: string;
@@ -94,10 +150,20 @@ export interface AccountConfig {
 	authMode?: AuthMode;
 	/** Requested Graph scopes (default: DEFAULT_SCOPES) */
 	scopes?: string[];
+	/**
+	 * Fixed loopback port for the browser sign-in redirect.
+	 *
+	 * Only needed where the app registration lists an exact redirect URI such
+	 * as `http://localhost:3000`; by default MSAL picks a free port and Entra
+	 * accepts any port on localhost for a public client.
+	 */
+	loopbackPort?: number;
 	/** Safety level override */
 	safetyLevel?: SafetyLevel;
 	/** Scope rules layered on top of the global ones */
 	permissions?: PermissionBlock;
+	/** Listen-mode overrides for this identity */
+	watch?: WatchConfig;
 	/** Additional tenants this identity reaches */
 	tenants?: TenantConfig[];
 }
@@ -113,6 +179,8 @@ export interface TeamsRootConfig {
 	safetyLevel?: SafetyLevel;
 	/** Global scope rules */
 	permissions?: PermissionBlock;
+	/** Global listen-mode settings */
+	watch?: WatchConfig;
 	/** Default page size for message listings (default: 25) */
 	maxMessages?: number;
 	/** Append every write to ~/.pi/agent/pi-teams-audit.jsonl (default: true) */
@@ -136,10 +204,14 @@ export interface TeamsConnection {
 	clientId: string;
 	clientSecret?: string;
 	/** Effective auth mode — never "auto" after resolution */
-	authMode: "device-code" | "client-credentials";
+	authMode: ResolvedAuthMode;
 	scopes: string[];
+	/** Fixed loopback port for the browser sign-in, when one is configured */
+	loopbackPort?: number;
 	safetyLevel: SafetyLevel;
 	permissions: ResolvedPermissions;
+	/** Listen-mode settings in force for this account+tenant */
+	watch: ResolvedWatchConfig;
 	maxMessages: number;
 	audit: boolean;
 	graphBaseUrl: string;
@@ -165,13 +237,11 @@ export class ConfigError extends Error {
 /**
  * Delegated scopes requested by default.
  *
- * `offline_access` is what makes the sign-in last: without it pi would have to
- * ask for a device code again every hour.
+ * `openid`, `profile` and `offline_access` are absent on purpose: MSAL always
+ * requests them and rejects them in an explicit scope list. The lasting
+ * sign-in they buy is therefore automatic.
  */
 export const DEFAULT_SCOPES: string[] = [
-	"offline_access",
-	"openid",
-	"profile",
 	"User.Read",
 	"User.ReadBasic.All",
 	"Team.ReadBasic.All",
@@ -201,7 +271,35 @@ const DEFAULTS = {
 	authorityHost: "https://login.microsoftonline.com",
 };
 
-const VALID_AUTH_MODES = new Set<string>(["device-code", "client-credentials", "auto"]);
+/**
+ * Listen-mode defaults and the bounds they are clamped to.
+ *
+ * The lower bound on `intervalSeconds` is what keeps a watcher from turning
+ * into a Graph-throttling loop: every tick costs at least one `/me/chats`
+ * round-trip, and each wake costs a full model turn.
+ */
+export const WATCH_DEFAULTS: ResolvedWatchConfig = {
+	enabled: false,
+	intervalSeconds: 60,
+	chats: [],
+	from: [],
+	mentionOnly: false,
+	cooldownSeconds: 300,
+	maxTriggersPerHour: 10,
+};
+
+const WATCH_BOUNDS = {
+	intervalSeconds: { min: 15, max: 3600 },
+	cooldownSeconds: { min: 0, max: 86400 },
+	maxTriggersPerHour: { min: 0, max: 1000 },
+};
+
+const VALID_AUTH_MODES = new Set<string>([
+	"interactive",
+	"device-code",
+	"client-credentials",
+	"auto",
+]);
 const VALID_SAFETY_LEVELS = new Set<string>(["open", "confirm", "readonly"]);
 
 // ---------------------------------------------------------------------------
@@ -299,18 +397,27 @@ export function resolveEffectiveSafetyLevel(
 	);
 }
 
-/** Effective auth mode, resolving "auto" against the available credentials. */
+/**
+ * Effective auth mode, resolving "auto" against the available credentials and
+ * the environment.
+ *
+ * `browserAvailable` is injected rather than detected here so the cascade stays
+ * a pure function — the detection itself lives in ../auth/msal.ts.
+ */
 export function resolveAuthMode(
 	account: AccountConfig | undefined,
 	tenant: TenantConfig | undefined,
 	hasSecret: boolean,
-): "device-code" | "client-credentials" {
+	browserAvailable = true,
+): ResolvedAuthMode {
 	const configured =
 		validateAuthMode(tenant?.authMode) ??
 		validateAuthMode(account?.authMode) ??
 		DEFAULTS.authMode;
-	if (configured === "auto") return hasSecret ? "client-credentials" : "device-code";
-	return configured;
+
+	if (configured !== "auto") return configured;
+	if (hasSecret) return "client-credentials";
+	return browserAvailable ? "interactive" : "device-code";
 }
 
 // ---------------------------------------------------------------------------
@@ -395,7 +502,7 @@ export function resolveConnection(
 	if (missing.length > 0) throw new ConfigError(missing);
 
 	const clientSecret = tenant?.clientSecret ?? account.clientSecret ?? undefined;
-	const authMode = resolveAuthMode(account, tenant, !!clientSecret);
+	const authMode = resolveAuthMode(account, tenant, !!clientSecret, canOpenBrowser());
 
 	if (authMode === "client-credentials" && !clientSecret) {
 		throw new ConfigError(
@@ -417,9 +524,11 @@ export function resolveConnection(
 		clientId,
 		clientSecret,
 		authMode,
+		loopbackPort: tenant?.loopbackPort ?? account.loopbackPort,
 		scopes,
 		safetyLevel: resolveEffectiveSafetyLevel(config.safetyLevel, account, tenant),
 		permissions: resolvePermissions([config.permissions, account.permissions, tenant?.permissions]),
+		watch: resolveWatchConfig(config.watch, account),
 		maxMessages: config.maxMessages ?? DEFAULTS.maxMessages,
 		audit: config.audit ?? DEFAULTS.audit,
 		graphBaseUrl: (config.graphBaseUrl ?? DEFAULTS.graphBaseUrl).replace(/\/+$/, ""),
@@ -559,6 +668,75 @@ export function setDefaultAccount(name: string, tenantName?: string): void {
 	writeRootConfig(config);
 }
 
+/**
+ * Effective listen-mode settings: account > global > defaults.
+ *
+ * Exported for tests — every field is clamped here, so the watcher itself can
+ * assume sane numbers instead of defending against a hand-edited config file.
+ */
+export function resolveWatchConfig(
+	global: WatchConfig | undefined,
+	account: AccountConfig | undefined,
+): ResolvedWatchConfig {
+	const local = account?.watch;
+	const pick = <K extends keyof WatchConfig>(key: K): WatchConfig[K] => local?.[key] ?? global?.[key];
+
+	return {
+		enabled: pick("enabled") ?? WATCH_DEFAULTS.enabled,
+		intervalSeconds: clamp(pick("intervalSeconds"), WATCH_BOUNDS.intervalSeconds, WATCH_DEFAULTS.intervalSeconds),
+		chats: normalizePatterns(pick("chats")),
+		from: normalizePatterns(pick("from")),
+		mentionOnly: pick("mentionOnly") ?? WATCH_DEFAULTS.mentionOnly,
+		cooldownSeconds: clamp(pick("cooldownSeconds"), WATCH_BOUNDS.cooldownSeconds, WATCH_DEFAULTS.cooldownSeconds),
+		maxTriggersPerHour: clamp(
+			pick("maxTriggersPerHour"),
+			WATCH_BOUNDS.maxTriggersPerHour,
+			WATCH_DEFAULTS.maxTriggersPerHour,
+		),
+	};
+}
+
+function clamp(value: unknown, bounds: { min: number; max: number }, fallback: number): number {
+	const number = typeof value === "number" && Number.isFinite(value) ? value : fallback;
+	return Math.min(bounds.max, Math.max(bounds.min, Math.round(number)));
+}
+
+function normalizePatterns(patterns: string[] | undefined): string[] {
+	if (!Array.isArray(patterns)) return [];
+	const cleaned = patterns
+		.filter((pattern): pattern is string => typeof pattern === "string")
+		.map((pattern) => pattern.trim())
+		.filter((pattern) => pattern.length > 0);
+	return [...new Set(cleaned)];
+}
+
+/**
+ * Merge a watch patch into the config file and report what is now in force.
+ *
+ * Writes to the account block when an account is named and to the global block
+ * otherwise — matching how `watch` itself is resolved. The resolved settings
+ * are returned rather than the patch, so a caller reports the effect and not
+ * the request.
+ */
+export function setWatchConfig(patch: WatchConfig, accountName?: string): ResolvedWatchConfig {
+	const config = readRootConfig();
+
+	if (!accountName) {
+		config.watch = { ...config.watch, ...patch };
+		writeRootConfig(config);
+		return resolveWatchConfig(config.watch, undefined);
+	}
+
+	const account = config.accounts.find((a) => a.name.toLowerCase() === accountName.toLowerCase());
+	if (!account) {
+		throw new ConfigError([`account "${accountName}"`], `Account "${accountName}" not found.`);
+	}
+
+	account.watch = { ...account.watch, ...patch };
+	writeRootConfig(config);
+	return resolveWatchConfig(config.watch, account);
+}
+
 /** Set the safety level globally, on an account, or on a tenant. */
 export function setSafetyLevel(
 	level: SafetyLevel,
@@ -644,7 +822,7 @@ const TEMPLATE_JSON = `{
       "displayName": "Work account",
       "tenantId": "contoso.onmicrosoft.com",
       "clientId": "00000000-0000-0000-0000-000000000000",
-      "authMode": "device-code",
+      "authMode": "interactive",
       "safetyLevel": "confirm",
       "permissions": {
         "read": {

package/src/extension/index.ts

@@ -12,6 +12,7 @@ import { Box, Text } from "@earendil-works/pi-tui";
 import {
 	ensureConfigTemplate,
 	getConfigPath,
+	setWatchConfig,
 	tryResolveConnection,
 	type TeamsConnection,
 } from "../config/index.ts";
@@ -22,6 +23,13 @@ import {
 	isMutationTool,
 	LOCAL_CONFIG_TOOLS,
 } from "../safety/index.ts";
+import {
+	setActiveWatchLoop,
+	startWatchLoop,
+	stopActiveWatchLoop,
+	type WatchLoop,
+} from "../watch/loop.ts";
+import { composeWatchPrompt } from "../watch/prompt.ts";
 
 import { teamsSetupTool } from "../tools/teams-setup.ts";
 import { teamsLoginTool, teamsLogoutTool } from "../tools/teams-login.ts";
@@ -49,6 +57,7 @@ import { teamsSearchMessagesTool } from "../tools/teams-search-messages.ts";
 import { teamsReactTool } from "../tools/teams-react.ts";
 import { teamsDeleteMessageTool } from "../tools/teams-delete-message.ts";
 import { teamsInboxTool } from "../tools/teams-inbox.ts";
+import { teamsWatchTool } from "../tools/teams-watch.ts";
 import {
 	teamsGetPresenceTool,
 	teamsSetPresenceTool,
@@ -73,6 +82,7 @@ const tools = [
 	teamsAccountsTool,
 	teamsStatusTool,
 	teamsPermissionsTool,
+	teamsWatchTool,
 	teamsDoctorTool,
 	// Discovery
 	teamsListTeamsTool,
@@ -118,6 +128,74 @@ export default function (pi: ExtensionAPI) {
 		return connection;
 	};
 
+	// -----------------------------------------------------------------------
+	// Listen mode
+	// -----------------------------------------------------------------------
+
+	/** The watcher running in this session, when listen mode is on. */
+	let watchLoop: WatchLoop | undefined;
+
+	/** The last polling error the user was told about, so it is said once. */
+	let reportedWatchError: string | undefined;
+
+	const stopWatch = () => {
+		watchLoop?.stop();
+		watchLoop = undefined;
+		setActiveWatchLoop(undefined);
+	};
+
+	/**
+	 * Start the watcher for the session's account, if the config asks for it.
+	 *
+	 * Restarting is the same call: the old loop is stopped first, so a config
+	 * change cannot leave two pollers running.
+	 */
+	const startWatch = (ctx: any) => {
+		stopWatch();
+
+		const conn = refresh();
+		if (!conn?.watch.enabled) return;
+
+		reportedWatchError = undefined;
+		const loop = startWatchLoop({
+			connection: conn,
+			onWake: (event) => {
+				pi.sendUserMessage(composeWatchPrompt(event, event.me), { deliverAs: "followUp" });
+			},
+			onTick: (status) => {
+				if (!status.lastError) reportedWatchError = undefined;
+			},
+			onError: (message) => {
+				// A watcher that fails every tick would otherwise say so every minute.
+				if (message === reportedWatchError) return;
+				reportedWatchError = message;
+				ctx.ui.notify(`Teams listen mode: ${message}`, "warning");
+			},
+		});
+
+		watchLoop = loop;
+		setActiveWatchLoop(loop);
+	};
+
+	/**
+	 * Paint the footer status line from the current connection.
+	 *
+	 * The only place the status line is written, so the three surfaces —
+	 * session start, `/teams-status`, and a tool result — cannot drift apart.
+	 */
+	const paintStatus = (ctx: any) => {
+		const card = buildConnectionCard(refresh());
+		if (!card) return;
+		const watching = !!watchLoop?.status().running;
+		ctx.ui.setStatus(
+			"teams",
+			ctx.ui.theme.fg(
+				card.signedIn ? "success" : "warning",
+				buildConnectionLabel({ ...card, watching }),
+			),
+		);
+	};
+
 	// -----------------------------------------------------------------------
 	// Status card — rendered in the transcript, never sent to the model
 	// -----------------------------------------------------------------------
@@ -162,7 +240,7 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 			pi.appendEntry<ConnectionCard>("teams-connection", card);
-			ctx.ui.setStatus("teams", ctx.ui.theme.fg("success", buildConnectionLabel(card)));
+			paintStatus(ctx);
 			ctx.ui.notify(buildConnectionLabel(card), "info");
 		},
 	});
@@ -188,6 +266,56 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	pi.registerCommand("teams-listen", {
+		description: "Let pi listen to Teams: on, off, or status (default)",
+		handler: async (args, ctx) => {
+			const conn = refresh();
+			if (!conn) {
+				ctx.ui.notify(
+					`Teams: no account configured yet. Use the teams_setup tool, or edit ${getConfigPath()}.`,
+					"warning",
+				);
+				return;
+			}
+
+			const action = args.trim().toLowerCase() || "status";
+
+			if (action === "on" || action === "off") {
+				// Written to the account, not globally: the watcher listens as one
+				// identity, and "which account" must not be a guess.
+				const watch = setWatchConfig({ enabled: action === "on" }, conn.account);
+				startWatch(ctx);
+				paintStatus(ctx);
+				ctx.ui.notify(
+					watch.enabled
+						? `Teams listen mode on — polling every ${watch.intervalSeconds} s, max ${watch.maxTriggersPerHour} wakes/hour.`
+						: "Teams listen mode off.",
+					"info",
+				);
+				return;
+			}
+
+			if (action !== "status") {
+				ctx.ui.notify(`Unknown argument "${action}". Use on, off, or status.`, "warning");
+				return;
+			}
+
+			const runtime = watchLoop?.status();
+			pi.appendEntry<ConnectionCard>("teams-connection", { ...buildConnectionCard(conn)!, watching: !!runtime?.running });
+			ctx.ui.notify(
+				[
+					`Listen mode: ${conn.watch.enabled ? "on" : "off"}`,
+					`every ${conn.watch.intervalSeconds} s`,
+					conn.watch.chats.length > 0 ? `chats: ${conn.watch.chats.join(", ")}` : "all recent chats",
+					conn.watch.from.length > 0 ? `people: ${conn.watch.from.join(", ")}` : "any sender",
+					conn.watch.mentionOnly ? "mentions only" : "every message",
+					runtime ? `${runtime.wakesThisHour} wake(s) this hour` : "not running in this session",
+				].join(" · "),
+				"info",
+			);
+		},
+	});
+
 	pi.registerCommand("teams-inbox", {
 		description: "Show what needs your attention in Microsoft Teams",
 		handler: async (_args, ctx) => {
@@ -246,7 +374,8 @@ export default function (pi: ExtensionAPI) {
 		const card = buildConnectionCard(connection);
 		if (!card) return;
 
-		ctx.ui.setStatus("teams", ctx.ui.theme.fg(card.signedIn ? "success" : "warning", buildConnectionLabel(card)));
+		paintStatus(ctx);
+		startWatch(ctx);
 
 		if (!card.signedIn) {
 			ctx.ui.notify(
@@ -294,6 +423,16 @@ export default function (pi: ExtensionAPI) {
 		});
 	}
 
+	// -----------------------------------------------------------------------
+	// Listen mode lifecycle
+	// -----------------------------------------------------------------------
+
+	pi.on("session_shutdown", () => {
+		// The timer would be unref'd anyway, but a poll in flight during shutdown
+		// would still be a Graph call for a session that is gone.
+		stopWatch();
+	});
+
 	// -----------------------------------------------------------------------
 	// Safety interceptor
 	// -----------------------------------------------------------------------
@@ -333,4 +472,39 @@ export default function (pi: ExtensionAPI) {
 			if (!approved) return { block: true, reason: `User declined: ${summary}` };
 		}
 	});
+
+	// -----------------------------------------------------------------------
+	// Status after a tool ran
+	// -----------------------------------------------------------------------
+
+	/**
+	 * The status line is a snapshot of session start — but every change to the
+	 * connection happens afterwards, in a tool, and tools have no UI context of
+	 * their own. Without this the footer would still read "not signed in" after a
+	 * successful login, and "listening" after listen mode was switched off.
+	 */
+	const STATUS_TOOLS = new Set([
+		"teams_login",
+		"teams_logout",
+		"teams_setup",
+		"teams_accounts",
+		"teams_watch",
+	]);
+
+	/** Tools after which the watcher has to be re-read from the config. */
+	const WATCH_CONFIG_TOOLS = new Set(["teams_watch", "teams_setup", "teams_accounts"]);
+
+	pi.on("tool_result", async (event, ctx) => {
+		if (!STATUS_TOOLS.has(event.toolName) || event.isError) return;
+
+		if (event.toolName === "teams_logout") {
+			// A watcher polling a session that was just removed only produces
+			// errors; leaving it running would be noise, not service.
+			stopWatch();
+		} else if (WATCH_CONFIG_TOOLS.has(event.toolName)) {
+			startWatch(ctx);
+		}
+
+		paintStatus(ctx);
+	});
 }

package/src/graph/messages.ts

@@ -11,7 +11,7 @@ import type { TeamsConnection } from "../config/index.ts";
 import type { ChannelSummary, MessageLocation, MessageSummary, PersonRef } from "../types.ts";
 import { graphGetOptional, graphList, graphPost } from "./client.ts";
 import { mapMessage } from "./mappers.ts";
-import { textToHtml } from "../utils/formatting.ts";
+import { markdownToTeamsHtml } from "../utils/richtext.ts";
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 type Raw = Record<string, any>;
@@ -21,9 +21,15 @@ type Raw = Record<string, any>;
 // ---------------------------------------------------------------------------
 
 export interface MessageInput {
-	/** Message text — plain text unless `html` is true */
+	/**
+	 * Message text.
+	 *
+	 * Treated as lightweight markdown by default — bold, italic, code, bullets,
+	 * numbered lists, links and `# headings` are converted to the HTML Teams
+	 * renders. Set `html` to true to send raw HTML instead.
+	 */
 	body: string;
-	/** Treat `body` as raw HTML instead of escaping it */
+	/** Treat `body` as raw HTML instead of converting markdown */
 	html?: boolean;
 	/** Channel messages only */
 	subject?: string;
@@ -39,10 +45,14 @@ export interface MessageInput {
  * Mentions are the fiddly part: Teams requires an `<at id="N">` span in the
  * HTML *and* a matching entry in the `mentions` array. The display name is
  * replaced in the text so the caller can just write "@Anna Schmidt".
+ *
+ * Markdown is converted unless the caller says the body is already HTML: what
+ * comes back from a model is markdown, and markdown sent raw arrives as
+ * asterisks and dashes.
  */
 export function buildMessageBody(input: MessageInput): Record<string, unknown> {
 	const mentions = input.mentions ?? [];
-	let content = input.html ? input.body : textToHtml(input.body);
+	let content = input.html ? input.body : markdownToTeamsHtml(input.body);
 
 	const mentionEntries: Record<string, unknown>[] = [];
 	mentions.forEach((person, index) => {

package/src/safety/index.ts

@@ -18,7 +18,7 @@
  * which channel a message is actually headed for.
  */
 
-import type { SafetyLevel, TeamsConnection } from "../config/index.ts";
+import type { ResolvedAuthMode, SafetyLevel, TeamsConnection } from "../config/index.ts";
 import { checkScope, type ScopeCategory, type ScopeMode } from "../config/scope.ts";
 import { ScopeDeniedError } from "../utils/errors.ts";
 import { MUTATION_TOOLS } from "../tools/tool-names.ts";
@@ -39,7 +39,7 @@ export function isMutationTool(toolName: string): boolean {
  * needs a way to add an account or sign out. They also work before anything is
  * configured at all, which is the whole point of `teams_setup`.
  */
-export const LOCAL_CONFIG_TOOLS = new Set<string>(["teams_setup", "teams_logout"]);
+export const LOCAL_CONFIG_TOOLS = new Set<string>(["teams_setup", "teams_logout", "teams_watch"]);
 
 /**
  * Why a mutation must be refused outright, or undefined when it may proceed
@@ -47,7 +47,7 @@ export const LOCAL_CONFIG_TOOLS = new Set<string>(["teams_setup", "teams_logout"
  */
 export function blockReason(
 	safetyLevel: SafetyLevel,
-	authMode: "device-code" | "client-credentials",
+	authMode: ResolvedAuthMode,
 	toolName: string,
 ): string | undefined {
 	if (!isMutationTool(toolName)) return undefined;
@@ -64,7 +64,7 @@ export function blockReason(
 		return (
 			`"${toolName}" cannot run on an app-only token. Microsoft Graph only permits app-only writes to ` +
 			`chats and channels for migration scenarios, so pi cannot post as a person this way. ` +
-			`Set authMode to "device-code" for this account and run teams_login.`
+			`Set authMode to "interactive" for this account and run teams_login.`
 		);
 	}