@patimweb/pi-teams 1.4.0 → 1.5.0

package/README.md

@@ -358,8 +358,8 @@ your own company can be `confirm` while a customer tenant stays `readonly`.
 
 ### AI disclosure footer
 
-Off by default. Switched on, every message, reply and edit pi sends in your name
-ends with a short note saying it was written by an AI:
+On by default. Every message, reply and edit pi sends in your name ends with a
+short note saying it was written by an AI:
 
 ```json
 "aiFooter": { "enabled": true, "text": "🤖 Erstellt mit pi (KI-Assistent)" }
@@ -367,11 +367,13 @@ ends with a short note saying it was written by an AI:
 
 | Key | Default | Meaning |
 |-----|---------|---------|
-| `enabled` | `false` | append the note to everything pi sends |
+| `enabled` | `true` | append the note to everything pi sends |
 | `text` | `🤖 Generated with pi (an AI agent)` | the wording; empty means the default |
 
-Set it globally or per account (the account level wins field by field, so one
-account can use its own wording while another keeps the global one).
+Turn it off with `"enabled": false` if the disclosure does not fit the people
+you write to. Set it globally or per account (the account level wins field by
+field, so one account can use its own wording while another keeps the global
+one).
 
 Details worth knowing:
 
@@ -427,7 +429,7 @@ teams_permissions:
 | `maxMessages` | `25` | default page size for message listings |
 | `audit` | `true` | append every write to `~/.pi/agent/pi-teams-audit.jsonl` |
 | `scopes` | see above | override the requested Graph scopes per account/tenant |
-| `aiFooter` | off | append an AI disclosure to every message pi sends — see above |
+| `aiFooter` | on | append an AI disclosure to every message pi sends — see above |
 | `graphBaseUrl` / `authorityHost` | Microsoft public cloud | sovereign cloud endpoints |
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patimweb/pi-teams",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Microsoft Teams integration for pi coding agent — acts fully as the signed-in user across multiple accounts and tenants: chats, channels, meetings, presence, with configurable guardrails",
   "keywords": [
     "pi-package",

package/skills/teams-collaboration/SKILL.md

@@ -114,11 +114,11 @@ instead of trying anyway.
 ## How to write as the user
 
 - Write in **their** voice. No "As an AI…", no signature, no note that a model
-  composed it, unless they ask for one. The one exception is configuration, not
-  judgement: with `aiFooter` switched on, the sending tools append the
-  disclosure themselves — do not write it into the body, or it arrives twice
-  (the tools detect it, but the user sees the text in the confirmation twice as
-  well, which looks like a mistake).
+  composed it — that disclosure is configuration, not judgement: the sending
+  tools append it themselves (`aiFooter`, on by default), so do not write it
+  into the body or it arrives twice (the tools detect the duplicate, but the
+  user sees the text in the confirmation twice as well, which looks like a
+  mistake).
 - Match the register of the conversation you just read. A channel post and a
   quick reply to a colleague are not the same thing.
 - Show the exact text and the destination before sending whenever the request

package/src/config/index.ts

@@ -137,13 +137,14 @@ export interface ResolvedWatchConfig {
 /**
  * The note pi can append to everything it sends in the user's name.
  *
- * Off by default, and deliberately so: pi writes as the user, and a disclosure
- * a recipient did not expect is a statement the user did not make. Where an
- * organisation wants it — a works council, a customer, a regulated process —
- * switching it on is a one-line change.
+ * On by default, and deliberately so: pi writes as the user, and a recipient
+ * who reads a message as coming from a colleague should be able to tell that a
+ * model composed it. A disclosure that depends on remembering to switch it on
+ * is not a disclosure, so the safe state is the default one — an organisation
+ * that does not want it turns it off with `enabled: false`.
  */
 export interface AiFooterConfig {
-	/** Append the note to every outgoing message (default: false) */
+	/** Append the note to every outgoing message (default: true) */
 	enabled?: boolean;
 	/** The note itself (default: see AI_FOOTER_DEFAULT) */
 	text?: string;
@@ -294,7 +295,7 @@ const DEFAULTS = {
 	authMode: "auto" as AuthMode,
 	maxMessages: 25,
 	audit: true,
-	aiFooter: false,
+	aiFooter: true,
 	graphBaseUrl: "https://graph.microsoft.com/v1.0",
 	authorityHost: "https://login.microsoftonline.com",
 };
@@ -901,7 +902,7 @@ const TEMPLATE_JSON = `{
   "safetyLevel": "confirm",
   "maxMessages": 25,
   "audit": true,
-  "aiFooter": { "enabled": false, "text": "🤖 Generated with pi (an AI agent)" }
+  "aiFooter": { "enabled": true, "text": "🤖 Generated with pi (an AI agent)" }
 }
 `;
 

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

@@ -69,7 +69,7 @@ export const teamsSendChatMessageTool = {
 	promptGuidelines: [
 		"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.",
+		"Do not add signatures, or a note that the message was written by an AI: the sending tool appends the configured AI disclosure itself (on by default), so writing one into the body duplicates it.",
 		"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.",
 	],

package/src/watch/index.ts

@@ -192,6 +192,54 @@ export function isWatchedSender(message: MessageSummary, watch: ResolvedWatchCon
 	return watch.from.some((pattern) => candidates.some((candidate) => matchesPattern(pattern, candidate)));
 }
 
+// ---------------------------------------------------------------------------
+// What the answer has to cover
+// ---------------------------------------------------------------------------
+
+/**
+ * How many recent messages of a chat the watcher pulls in.
+ *
+ * One would be enough to decide *whether* to wake, and that is what this used to
+ * be — but not enough to answer well: someone who sends three lines in a row
+ * leaves three open messages, and a reply to only the newest reads as if the
+ * other two were ignored. The window is small on purpose; it only exists to
+ * carry the context of the newest message, not to replay the conversation.
+ */
+export const WATCH_MESSAGE_WINDOW = 10;
+
+/**
+ * The messages in this chat that are still open for the user, oldest first.
+ *
+ * "Open" is the Teams read cursor talking, exactly as `isUnread` means it: a
+ * message from somebody else that the user has not caught up with yet. Messages
+ * of my own are dropped — pi posts as the user, so they are the answers that
+ * were already given, not questions waiting for one.
+ *
+ * `messages` is newest first, as Graph returns it. A `readAt` Teams will not
+ * give is treated as "all of them are open" rather than as settled, for the same
+ * reason `isUnread` does: a read state we cannot read must not silently switch
+ * listen mode off.
+ */
+export function openMessages(
+	messages: MessageSummary[],
+	readAt: string | undefined,
+	me: SignedInUser | undefined,
+): MessageSummary[] {
+	const read = readAt ? new Date(readAt).getTime() : Number.NaN;
+	const known = Number.isFinite(read);
+
+	return messages
+		.filter((entry) => {
+			if (entry.deletedDateTime) return false;
+			if (isFromMe(entry.from, me)) return false;
+			if (!known) return true;
+
+			const at = entry.createdDateTime ? new Date(entry.createdDateTime).getTime() : Number.NaN;
+			return Number.isFinite(at) && at > read;
+		})
+		.reverse();
+}
+
 // ---------------------------------------------------------------------------
 // Whether a message should wake pi
 // ---------------------------------------------------------------------------

package/src/watch/loop.ts

@@ -33,9 +33,11 @@ import {
 	noteFailure,
 	noteSuccess,
 	noteWake,
+	openMessages,
 	pruneState,
 	shouldWake,
 	wakesThisHour,
+	WATCH_MESSAGE_WINDOW,
 	type WatchState,
 } from "./index.ts";
 
@@ -46,7 +48,17 @@ import {
 /** One message that deserves a model turn. */
 export interface WatchEvent {
 	chat: ChatSummary;
+	/** The newest message in the chat — the one the wake was decided on */
 	message: MessageSummary;
+	/**
+	 * Everything still open in that chat, oldest first, the newest included.
+	 *
+	 * Waking up is about one message, answering is usually about more than one:
+	 * three lines sent in a row are three open messages, and answering only the
+	 * last of them is what the user notices. Empty means the trigger was the only
+	 * thing the read cursor left open.
+	 */
+	backlog?: MessageSummary[];
 	/** Epoch ms the wake was decided */
 	wokeAt: number;
 	/** Who pi is acting as, carried along for the prompt */
@@ -88,7 +100,11 @@ export const MAX_EXAMINATIONS_PER_TICK = 5;
 export interface WatchTickDeps {
 	/** Newest chats, most recent activity first */
 	listChats: () => Promise<ChatSummary[]>;
-	/** The most recent messages of one chat, newest first */
+	/**
+	 * A window of the chat's most recent messages, newest first — enough to find
+	 * the newest one and whatever the user has not read yet (see
+	 * `WATCH_MESSAGE_WINDOW`).
+	 */
 	listMessages: (chatId: string) => Promise<MessageSummary[]>;
 	/**
 	 * The user's read cursor for one chat (`viewpoint.lastMessageReadDateTime`).
@@ -186,7 +202,18 @@ export async function runWatchTick(
 		if (!decision.wake) continue;
 
 		noteWake(state, chat.id, now);
-		wakes.push({ chat, message, wokeAt: now, me });
+
+		// The answer has to cover the whole open thread, not just its newest line:
+		// the trigger message is the reason for the wake, the backlog is the reason
+		// for a reply that sounds like the conversation was read.
+		const backlog = openMessages(messages, readAt, me);
+		wakes.push({
+			chat,
+			message,
+			backlog: backlog.length > 0 ? backlog : [message],
+			wokeAt: now,
+			me,
+		});
 	}
 
 	// Written even when nothing woke: marking a chat examined is the progress
@@ -295,7 +322,8 @@ export function startWatchLoop(options: WatchLoopOptions): WatchLoop {
 			const result = await runWatchTick(
 				{
 					listChats: () => listChats(connection, { max: 50, meId: me?.id }),
-					listMessages: (chatId) => listChatMessages(connection, chatId, { max: 1 }),
+					listMessages: (chatId) =>
+						listChatMessages(connection, chatId, { max: WATCH_MESSAGE_WINDOW }),
 					readState: async (chatId) => (await getChatViewpoint(connection, chatId))?.lastMessageReadAt,
 					now: () => Date.now(),
 					allowed: (chat) => hasAccess(connection, "read", "chats", chatCandidates(chat)),

package/src/watch/prompt.ts

@@ -6,9 +6,13 @@
  * what pi does with a message it was woken for is decided here, and nothing in
  * the polling loop should be able to change it.
  *
- * Two things the prompt must always carry: the chat ID — so the reply cannot
+ * Three things the prompt must always carry: the chat ID — so the reply cannot
  * land in the wrong conversation, since pi posts as a person and a name is not
- * an identifier — and the instruction that doing nothing is a valid answer.
+ * an identifier — the instruction that doing nothing is a valid answer, and
+ * every message still open in that chat. The last one is not decoration: a wake
+ * is decided on the newest message, but people send three lines in a row, and a
+ * reply that answers only the last of them is the failure mode this prompt
+ * exists to prevent.
  */
 
 import type { MessageSummary, SignedInUser } from "../types.ts";
@@ -18,6 +22,45 @@ function senderName(message: MessageSummary): string {
 	return message.from?.displayName ?? message.from?.upn ?? "someone";
 }
 
+/** `17:00`, or nothing when Graph did not date the message. */
+function timeOf(message: MessageSummary): string {
+	if (!message.createdDateTime) return "";
+	const at = new Date(message.createdDateTime);
+	return Number.isFinite(at.getTime()) ? at.toLocaleTimeString() : "";
+}
+
+function quote(text: string | undefined): string {
+	const body = text?.trim() ? text.trim() : "(no text content — open the chat to see it)";
+	return body
+		.split("\n")
+		.map((line) => `> ${line}`)
+		.join("\n");
+}
+
+/**
+ * The open messages of the chat, oldest first.
+ *
+ * Falls back to the trigger message alone when the backlog is missing — a wake
+ * without one still has to produce a usable prompt.
+ */
+function openThread(event: WatchEvent): MessageSummary[] {
+	const backlog = event.backlog?.filter((entry) => !entry.deletedDateTime) ?? [];
+	return backlog.length > 0 ? backlog : [event.message];
+}
+
+/** One numbered block per open message, oldest first. */
+function renderThread(messages: MessageSummary[]): string {
+	return messages
+		.map((entry, index) => {
+			const newest = index === messages.length - 1;
+			const stamp = timeOf(entry);
+			const heading = [stamp, senderName(entry)].filter(Boolean).join(" · ");
+			const label = newest ? `${heading} — newest` : heading;
+			return [`> ${index + 1}. ${label}`, quote(entry.text)].join("\n");
+		})
+		.join("\n>\n");
+}
+
 /**
  * The prompt for one wake.
  *
@@ -26,28 +69,49 @@ function senderName(message: MessageSummary): string {
  */
 export function composeWatchPrompt(event: WatchEvent, me?: SignedInUser): string {
 	const { chat, message } = event;
-	const text = message.text?.trim() ? message.text.trim() : "(no text content — open the chat to see it)";
+	const thread = openThread(event);
 	const at = message.createdDateTime ? new Date(message.createdDateTime).toLocaleString() : "just now";
 
-	return [
-		"An incoming Microsoft Teams message arrived while you were idle.",
+	const header = [
+		"The following Microsoft Teams message arrived while you were idle.",
 		"",
 		`- Chat: ${chat.label} (${chat.chatType})`,
 		`- From: ${senderName(message)}`,
 		`- At: ${at}`,
 		`- Chat ID: ${chat.id}`,
+	];
+
+	const body =
+		thread.length > 1
+			? [
+					"",
+					`Unanswered messages in this chat (${thread.length}), oldest first:`,
+					"",
+					renderThread(thread),
+				]
+			: ["", "Message:", "", quote(message.text)];
+
+	const decision =
+		thread.length > 1
+			? [
+					"Decide whether these need an answer.",
+					"",
+					"All of them are still unread in Teams, and they arrived together as one conversation. Answer every " +
+						"one of them, not just the newest — one short reply can cover all of it, but a reply that " +
+						"ignores the earlier messages is wrong even when its wording is fine.",
+				]
+			: ["Decide whether this needs an answer."];
+
+	return [
+		...header,
+		...body,
 		"",
-		"Message:",
-		text
-			.split("\n")
-			.map((line) => `> ${line}`)
-			.join("\n"),
-		"",
-		"Decide whether this needs an answer.",
+		...decision,
 		"",
 		`- If it does: reply with teams_send_chat_message, passing chat: "${chat.id}". pi posts as ` +
 			`${me?.displayName ?? "me"}, so write in my voice, in the language of the conversation, as briefly as ` +
-			"the message allows. No greeting boilerplate, no signature.",
+			"the message allows. No greeting boilerplate, no signature, and no note that a model wrote it — " +
+			"the sending tool appends the configured AI disclosure itself.",
 		"- If it does not: say so in one line and stop.",
 		"",
 		"Format it for a chat bubble, not a document: the answer first, three short paragraphs at most, " +