@patimweb/pi-teams 1.1.0 → 1.2.0

package/src/config/index.ts

@@ -89,9 +89,54 @@ export interface TenantConfig {
 	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;
@@ -117,6 +162,8 @@ export interface AccountConfig {
 	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[];
 }
@@ -132,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) */
@@ -161,6 +210,8 @@ export interface TeamsConnection {
 	loopbackPort?: number;
 	safetyLevel: SafetyLevel;
 	permissions: ResolvedPermissions;
+	/** Listen-mode settings in force for this account+tenant */
+	watch: ResolvedWatchConfig;
 	maxMessages: number;
 	audit: boolean;
 	graphBaseUrl: string;
@@ -220,6 +271,29 @@ const DEFAULTS = {
 	authorityHost: "https://login.microsoftonline.com",
 };
 
+/**
+ * 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",
@@ -454,6 +528,7 @@ export function resolveConnection(
 		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(/\/+$/, ""),
@@ -593,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,

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

@@ -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

package/src/status.ts

@@ -27,6 +27,10 @@ export interface ConnectionCard {
 	otherAccounts: string[];
 	/** Rendered scope rules */
 	permissionSummary: string;
+	/** Listen mode is switched on */
+	watching?: boolean;
+	/** One line on what the watcher is doing, when it runs */
+	watchSummary?: string;
 }
 
 export function buildConnectionCard(
@@ -50,6 +54,19 @@ export function buildConnectionCard(
 		expiresAt: cache.expiresAt ? new Date(cache.expiresAt).toISOString() : undefined,
 		otherAccounts: conn.allAccounts.map((a) => a.name).filter((name) => name !== conn.account),
 		permissionSummary: formatPermissions(conn.permissions),
+		// What the configuration asks for; a caller that knows whether the watcher
+		// is actually running overrides this with the runtime truth.
+		watching: conn.watch.enabled,
+		watchSummary: conn.watch.enabled
+			? [
+					`every ${conn.watch.intervalSeconds} s`,
+					conn.watch.chats.length > 0 ? conn.watch.chats.join(", ") : "all recent chats",
+					conn.watch.from.length > 0 ? `from ${conn.watch.from.join(", ")}` : undefined,
+					`max ${conn.watch.maxTriggersPerHour}/h`,
+				]
+					.filter(Boolean)
+					.join(" · ")
+			: undefined,
 	};
 }
 
@@ -59,7 +76,8 @@ export function buildConnectionLabel(card: ConnectionCard | undefined): string {
 	if (!card.signedIn) return `Teams · ${card.account} · not signed in`;
 
 	const scope = card.tenant === card.account ? card.account : `${card.account}/${card.tenant}`;
-	return `✓ Teams · ${scope}${card.user ? ` · ${card.user}` : ""}`;
+	const listening = card.watching ? " · 👂 listening" : "";
+	return `✓ Teams · ${scope}${card.user ? ` · ${card.user}` : ""}${listening}`;
 }
 
 /** Rich markdown for `/teams-status` and the expanded card. */
@@ -98,6 +116,9 @@ export function formatStatusText(card: ConnectionCard | undefined): string {
 	if (card.otherAccounts.length > 0) {
 		lines.push(`- **Other accounts:** ${card.otherAccounts.join(", ")}`);
 	}
+	lines.push(
+		`- **Listen mode:** ${card.watching ? `on — ${card.watchSummary ?? "running"}` : "off"}`,
+	);
 
 	lines.push("", "### What pi may do", "", card.permissionSummary);
 	return lines.join("\n");

package/src/tools/teams-send-channel-message.ts

@@ -57,14 +57,17 @@ async function resolveMentions(
 const sharedParams = {
 	channel: Type.String({ description: "Channel name or ID, or a 'Team/Channel' path" }),
 	team: Type.Optional(Type.String({ description: "Team name or ID (omit when using a path)" })),
-	body: Type.String({ description: "Message text. Plain text unless 'html' is true." }),
+	body: Type.String({
+			description:
+				"Message text as lightweight markdown (bold, italics, code, bullets, numbered lists, links)",
+		}),
 	account: AccountParam,
 	tenant: TenantParam,
 	mentions: Type.Optional(
 		Type.Array(Type.String(), { description: "People to @-mention, by name, UPN or e-mail" }),
 	),
 	importance: Type.Optional(Type.String({ description: "'normal' (default), 'high' or 'urgent'" })),
-	html: Type.Optional(Type.Boolean({ description: "Treat 'body' as raw HTML instead of plain text" })),
+	html: Type.Optional(Type.Boolean({ description: "Send 'body' as raw HTML instead of converting markdown" })),
 };
 
 export const teamsSendChannelMessageTool = {
@@ -81,6 +84,8 @@ export const teamsSendChannelMessageTool = {
 	promptGuidelines: [
 		"Write in the user's voice — the post is attributed to them, not to an assistant.",
 		"Show the exact text and the target channel before posting when there is any ambiguity.",
+		"Format for a chat, not for a document: lead with the answer, three short paragraphs at most, bullets for lists. Bold, italics, code, links and bullets are rendered; headings become bold lines and tables are not supported — keep those out.",
+		"Answer in the language of the conversation you are writing into, and match its register.",
 	],
 
 	async execute(

package/src/tools/teams-send-chat-message.ts

@@ -46,7 +46,10 @@ export const teamsSendChatMessageTool = {
 		"where the mention should appear.",
 	parameters: Type.Object({
 		chat: Type.String({ description: "Chat ID, group chat topic, or a participant's name/e-mail" }),
-		body: Type.String({ description: "Message text. Plain text unless 'html' is true." }),
+		body: Type.String({
+			description:
+				"Message text as lightweight markdown (bold, italics, code, bullets, numbered lists, links)",
+		}),
 		account: AccountParam,
 		tenant: TenantParam,
 		mentions: Type.Optional(
@@ -58,7 +61,7 @@ export const teamsSendChatMessageTool = {
 			Type.String({ description: "'normal' (default), 'high' or 'urgent'" }),
 		),
 		html: Type.Optional(
-			Type.Boolean({ description: "Treat 'body' as raw HTML instead of plain text" }),
+			Type.Boolean({ description: "Send 'body' as raw HTML instead of converting markdown" }),
 		),
 	}),
 	promptSnippet: "Send a message in a Teams chat as the user",
@@ -66,6 +69,8 @@ export const teamsSendChatMessageTool = {
 		"Write the message in the user's voice — it is sent from their account, not from an assistant.",
 		"Show the user the exact text before sending when the intent is even slightly ambiguous.",
 		"Do not add signatures, disclaimers, or a note that the message was written by an AI unless the user asks.",
+		"Format for a chat, not for a document: lead with the answer, three short paragraphs at most, bullets for lists. Bold, italics, code, links and bullets are rendered; headings become bold lines and tables are not supported — keep those out.",
+		"Answer in the language of the conversation you are writing into, and match its register.",
 	],
 
 	async execute(