@patimweb/pi-teams 1.9.0 → 1.9.2

package/docs/listen-mode.md

@@ -15,8 +15,11 @@ understanding before switching on.
 Listen mode never starts on its own. It belongs to the session it was switched
 on in and ends with it: quitting pi closes the watcher, and `/new` or `/resume`
 stops it too. A stored `enabled: true` is a setting, not an instruction — set
-`autoStart` if a session is meant to start listening by itself, which is only
-sensible for an unattended one.
+`autoStart` if a session is meant to start listening by itself. Only a session
+with a UI does: a pi started headless by another pi loads the same extensions
+and the same configuration, and a watcher there would answer chats inside a
+throwaway process and move the shared cursor past messages the real session
+never sees.
 
 ## Settings
 
@@ -36,7 +39,7 @@ sensible for an unattended one.
 | Key | Default | Meaning |
 |-----|---------|---------|
 | `enabled` | `false` | whether listen mode is switched on |
-| `autoStart` | `false` | whether a pi session may start the watcher without being asked |
+| `autoStart` | `false` | whether a session with a UI may start the watcher without being asked |
 | `intervalSeconds` | `60` | seconds between polls (minimum 15) |
 | `chats` | `[]` | **where** pi listens: glob patterns matched against topic, label, chat ID and participant names. Empty means every recent chat. |
 | `from` | `[]` | **who** pi listens to: glob patterns matched against display name, UPN and e-mail. Empty means any sender. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patimweb/pi-teams",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "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/src/extension/index.ts

@@ -429,7 +429,12 @@ export default function (pi: ExtensionAPI) {
 		// A stored setting is not a decision. A session starts the watcher only when
 		// the configuration opts into it; otherwise listen mode waits until it is
 		// switched on in this session with `/teams-listen on`.
-		if (connection.watch.autoStart) startWatch(ctx, { explicit: true });
+		// Only an interactive session listens on its own. A pi started headless by
+		// another pi (`--mode json -p`, e.g. a subagent) loads the same extensions
+		// and the same config: autoStart there would run a second watcher that
+		// answers chats inside a throwaway process and advances the shared cursor,
+		// so the real session never sees those messages.
+		if (connection.watch.autoStart && ctx.hasUI) startWatch(ctx, { explicit: true });
 
 		paintStatus(ctx);
 

package/src/watch/loop.ts

@@ -97,6 +97,18 @@ export interface WatchRuntimeStatus {
 // One tick
 // ---------------------------------------------------------------------------
 
+/** A tick was asked to run without knowing who pi is signed in as. */
+export class WatchIdentityError extends Error {
+	constructor(cause?: unknown) {
+		super(
+			"Listen mode is waiting: the signed-in user could not be determined, so pi's own replies " +
+				"could not be told apart from new messages. Retrying on the next poll." +
+				(cause ? ` ${formatGraphError(cause)}` : ""),
+		);
+		this.name = "WatchIdentityError";
+	}
+}
+
 /**
  * Bound on how many chats one tick examines.
  *
@@ -165,8 +177,14 @@ export async function runWatchTick(
 	deps: WatchTickDeps,
 	state: WatchState,
 	watch: ResolvedWatchConfig,
-	me: SignedInUser | undefined,
+	me: SignedInUser,
 ): Promise<WatchTickResult> {
+	// Who pi acts as is what tells its own replies apart from everybody else's
+	// (`isFromMe`). Without it, the answer pi just sent looks like a new message
+	// from a colleague and wakes pi again — a loop that answers itself. So a tick
+	// without an identity examines nothing, and in particular writes no cursor.
+	if (!me) throw new WatchIdentityError();
+
 	const now = deps.now();
 	pruneState(state, now);
 
@@ -337,8 +355,15 @@ export function startWatchLoop(options: WatchLoopOptions): WatchLoop {
 	 * instead of starting a second one.
 	 */
 	let inFlight: Promise<void> | undefined;
+	/**
+	 * Who pi acts as, looked up on the first tick that can reach Graph.
+	 *
+	 * A failed lookup is not an answer: it is retried on every tick until it
+	 * succeeds, and no tick runs before it has. A watcher started before sign-in
+	 * (autoStart in a fresh container, say) would otherwise settle for "nobody"
+	 * for the whole session and wake on its own replies.
+	 */
 	let me: SignedInUser | undefined;
-	let meResolved = false;
 	let failureCount = 0;
 
 	const status: WatchRuntimeStatus = {
@@ -361,9 +386,12 @@ export function startWatchLoop(options: WatchLoopOptions): WatchLoop {
 		if (stopped) return;
 
 		try {
-			if (!meResolved) {
-				me = await getMe(connection).catch(() => undefined);
-				meResolved = true;
+			if (!me) {
+				try {
+					me = await getMe(connection);
+				} catch (err) {
+					throw new WatchIdentityError(err);
+				}
 			}
 
 			const result = await runWatchTick(