@prjct.app/pi-team 0.5.2 → 0.5.3

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.5.3](https://github.com/prjct-app/pi-team/compare/v0.5.2...v0.5.3) (2026-09-10)
+
+### Performance Improvements
+
+* stop opening a mailbox transaction on every idle tick ([#22](https://github.com/prjct-app/pi-team/issues/22)) ([561001f](https://github.com/prjct-app/pi-team/commit/561001f1fe8bb3048c005d74ef45d97e75b7ec09))
+
 ## [0.5.2](https://github.com/prjct-app/pi-team/compare/v0.5.1...v0.5.2) (2026-09-10)
 
 ### Performance Improvements

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prjct.app/pi-team",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Coordinate independent PI Agent sessions with local team messaging, queued tasks, and shared results.",
   "type": "module",
   "keywords": [

package/src/index.ts

@@ -140,6 +140,8 @@ type Session = Readonly<{
   lastReview: number;
   lastRevision: number;
   quietReviews: number;
+  widgetText?: string;
+  widgetCtx?: ExtensionContext;
 }>;
 
 const INITIAL: Session = {
@@ -182,6 +184,20 @@ export function installTeam(pi: ExtensionAPI, options: { root?: string; pollMs?:
       needsCompaction, compactionSubject: needsCompaction ? compactionSubject : undefined,
     } : null);
   }
+  /**
+   * The widget is rebuilt on every tick otherwise. Keyed on context identity
+   * as well as text: `ctx` is replaced on session start and by the command
+   * handler, and a new context needs its own registration.
+   */
+  function showWidget(text: string | undefined) {
+    const { ctx, widgetText, widgetCtx } = get();
+    if (text === widgetText && ctx === widgetCtx) return;
+    set(() => ({ widgetText: text, widgetCtx: ctx }));
+    ctx?.ui.setWidget('team', text === undefined ? undefined : () => ({
+      invalidate() {},
+      render(width: number) { return [truncateToWidth(text, width)]; },
+    }));
+  }
   function stop() {
     const { timer, watcher } = get();
     if (timer) clearInterval(timer);
@@ -195,7 +211,7 @@ export function installTeam(pi: ExtensionAPI, options: { root?: string; pollMs?:
       needsCompaction: false, compactionSubject: '', compactionGeneration: session.compactionGeneration + 1,
     }));
     persist();
-    get().ctx?.ui.setWidget('team', undefined);
+    showWidget(undefined);
   }
   async function detach() {
     stop();
@@ -288,19 +304,16 @@ export function installTeam(pi: ExtensionAPI, options: { root?: string; pollMs?:
     }
     const snap = await box.snapshot(member);
     set(() => ({ aliases: snap.members.map(m => m.alias) }));
-    const pending = snap.messages.filter(m => m.to === member.alias && m.state === 'pending').length;
+    const inbox = snap.messages.filter(m => m.to === member.alias && m.state === 'pending');
+    const pending = inbox.length;
     const { compacting, needsCompaction, paused, active } = get();
     const status = `${member.team} · ${member.alias} · ${compacting || needsCompaction ? 'compacting' : paused ? 'paused' : !ctx.model ? 'select a model' : active ? 'working' : 'connected'}${pending ? ` · ${pending} pending` : ''}`;
-    ctx.ui.setWidget('team', () => ({
-      invalidate() {},
-      render(width: number) { return [truncateToWidth(status, width)]; },
-    }));
+    showWidget(status);
     if (get().leaving) return;
     // A disconnected peer holding a claim must be interrupted so its
-    // requester receives a result instead of waiting forever.
-    if (snap.messages.some(m => m.state === 'processing') && snap.members.some(m => m.status === 'offline')) {
-      await box.sweep(member);
-    }
+    // requester receives a result instead of waiting forever. Sweeping is a
+    // full mailbox transaction, so it runs only when it would change something.
+    if (snap.sweepable) await box.sweep(member);
     // Keep the session branch stable while Pi summarizes it. Team commands stay
     // registered, but no new peer content is appended or claimed until callback.
     if (get().compacting) return;
@@ -308,7 +321,11 @@ export function installTeam(pi: ExtensionAPI, options: { root?: string; pollMs?:
       compactPendingContext(ctx);
       return;
     }
-    for (const message of await box.notes(member)) pi.appendEntry('team-event', message);
+    // Consuming notes is a mailbox transaction too. The snapshot already lists
+    // every message addressed to this member, so it decides whether to open one.
+    if (inbox.some(m => m.kind === 'note')) {
+      for (const message of await box.notes(member)) pi.appendEntry('team-event', message);
+    }
     if (!ready()) return;
     if (get().budget >= 5) {
       if (pending) {
@@ -670,7 +687,7 @@ export function installTeam(pi: ExtensionAPI, options: { root?: string; pollMs?:
         await box.leave(member).catch(notice);
       }
       set(() => ({ member: undefined, active: undefined }));
-      get().ctx?.ui.setWidget('team', undefined);
+      showWidget(undefined);
     });
   });
 }

package/src/mailbox.ts

@@ -15,7 +15,7 @@ export type Message = {
 };
 export type Outgoing = { to: string; kind: 'request' | 'note'; subject: string; body: string; parentId?: string };
 export type FlowItem = Pick<Message, 'id' | 'from' | 'to' | 'subject' | 'state' | 'created'>;
-export type Snapshot = { revision: number; members: Member[]; messages: Message[]; flow: FlowItem[] };
+export type Snapshot = { revision: number; sweepable: boolean; members: Member[]; messages: Message[]; flow: FlowItem[] };
 type State = { version: 1; members: Member[]; messages: Message[] };
 type Presence = { token: string; status: 'idle' | 'busy' | 'paused'; seen: number };
 export const LEASE_MS = 30_000;
@@ -219,8 +219,17 @@ export class Mailbox {
     const record = await this.readState(member.team, true);
     this.owner(record.payload, member);
     const presence = await this.readPresence(member.team);
+    // Members the record still counts as connected but whose session is gone.
+    // Collected here so liveness is probed once per member, not twice.
+    const stale = record.payload.members.filter(m => m.status !== 'offline' && !this.alive(m, presence));
     return {
       revision: record.revision,
+      // A sweep only has an observable effect when a dead member still holds a
+      // claim: `disconnect` interrupts it so its requester gets a result.
+      // Members are never removed from the record, so "someone is offline" is
+      // permanently true once anyone leaves and cannot gate the sweep.
+      sweepable: stale.some(dead => record.payload.messages.some(
+        m => m.state === 'processing' && m.claim === dead.token && m.to === dead.alias)),
       members: record.payload.members.map(m => this.withStatus(m, presence)),
       messages: record.payload.messages.filter(m => m.from === member.alias || m.to === member.alias),
       // Expose only the metadata needed to understand team-wide request flow;

package/src/store.ts

@@ -25,6 +25,13 @@ const KEEP_REVISIONS = 32;
 
 export const sha256 = (value: string): string => createHash('sha256').update(value).digest('hex');
 
+/**
+ * Diagnostics for the polling loop. `reads` counts full record parses, which
+ * happen once per attempted mutation and on a cache miss, never on a cache hit.
+ * A joined but idle session should leave both of these flat.
+ */
+export const counters = { reads: 0, publishes: 0 };
+
 /** Standard envelope parser: schema marker, revision, and content hash. */
 export function envelope<T>(raw: string): Record<T> {
   const parsed = JSON.parse(raw) as { schemaVersion?: unknown; revision?: unknown; contentHash?: unknown; payload?: unknown };
@@ -62,6 +69,7 @@ export async function readRecord<T>(path: string, normalize: Normalize<T>, maxBy
   if (!handle) return undefined;
   try {
     assertSafeFile(path, await handle.stat(), maxBytes);
+    counters.reads++;
     return normalize(await handle.readFile('utf8'));
   } finally { await handle.close(); }
 }
@@ -175,6 +183,7 @@ export async function publish<T>(
       if (durability === 'full') await syncDirectory(path);
     } finally { await unlink(tmp).catch(() => {}); }
     cache.delete(path);
+    counters.publishes++;
     await pruneRevisions(dirname(path), next).catch(() => {});
     return { revision: next, payload };
   } finally {