@prjct.app/pi-team 0.5.2 → 0.5.4

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.5.4](https://github.com/prjct-app/pi-team/compare/v0.5.3...v0.5.4) (2026-09-10)
+
+### Performance Improvements
+
+* drop the presence fsync, the quadratic file cap and a repeated mkdir ([#23](https://github.com/prjct-app/pi-team/issues/23)) ([75e5849](https://github.com/prjct-app/pi-team/commit/75e584965bd861cea96942497618f8c261c64d8d))
+
+## [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.4",
   "description": "Coordinate independent PI Agent sessions with local team messaging, queued tasks, and shared results.",
   "type": "module",
   "keywords": [

package/src/index.ts

@@ -96,6 +96,24 @@ function excerptPath(path: string, limit: number): string {
   return path.length <= limit ? path : `…${path.slice(-limit)}`;
 }
 
+/**
+ * Fill a result's file list up to the serialized size cap. Each accepted path
+ * grows the encoded report by exactly its own encoding plus a separating
+ * comma, so a running total lands on the same boundary as re-serializing the
+ * whole report once per candidate, without the quadratic cost.
+ */
+export function fitFiles(base: Result, candidates: Iterable<string>): { files: string[]; truncated: boolean } {
+  const files: string[] = [];
+  const size = { bytes: Buffer.byteLength(JSON.stringify({ ...base, files: [] })) };
+  for (const file of candidates) {
+    const addition = Buffer.byteLength(JSON.stringify(file)) + (files.length ? 1 : 0);
+    if (files.length >= 50 || file.length > 4096 || size.bytes + addition > 31000) return { files, truncated: true };
+    files.push(file);
+    size.bytes += addition;
+  }
+  return { files, truncated: false };
+}
+
 /** Bound a list injected into the prompt, reporting what was left out. */
 function bounded<T>(items: T[], limit = STATUS_ITEMS): { items: T[]; omitted?: number } {
   return items.length <= limit ? { items } : { items: items.slice(0, limit), omitted: items.length - limit };
@@ -140,6 +158,8 @@ type Session = Readonly<{
   lastReview: number;
   lastRevision: number;
   quietReviews: number;
+  widgetText?: string;
+  widgetCtx?: ExtensionContext;
 }>;
 
 const INITIAL: Session = {
@@ -182,6 +202,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 +229,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 +322,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 +339,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) {
@@ -634,14 +669,12 @@ export function installTeam(pi: ExtensionAPI, options: { root?: string; pollMs?:
         set(() => ({ outcome: 'interrupted', finalText: 'User took over the session. Subsequent output was not forwarded. Review before continuing.' }));
       }
       const { outcome, finalText, files } = get();
-      const report: Result = { outcome, body: finalText.slice(0, 3000) || `Agent turn ${outcome}; no final text. Review the recipient session.`, files: [], tests: [] };
-      for (const file of files) {
-        if (report.files.length >= 50 || file.length > 4096 || Buffer.byteLength(JSON.stringify({ ...report, files: [...report.files, file] })) > 31000) {
-          report.body += '\nFile list truncated; review the recipient session.';
-          break;
-        }
-        report.files.push(file);
-      }
+      const body = finalText.slice(0, 3000) || `Agent turn ${outcome}; no final text. Review the recipient session.`;
+      const fitted = fitFiles({ outcome, body, files: [], tests: [] }, files);
+      const report: Result = {
+        outcome, files: fitted.files, tests: [],
+        body: fitted.truncated ? `${body}\nFile list truncated; review the recipient session.` : body,
+      };
       await box.complete(member, finished.id, report);
       set(() => ({ active: undefined, ...(outcome !== 'completed' ? { paused: true } : {}) }));
       if (get().leaving) { await detach(); return false; }
@@ -670,7 +703,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;
@@ -36,13 +36,22 @@ export function identifier(value: string): string {
   return value;
 }
 
+/**
+ * Directories known to have been created by this process. Only the `mkdir` is
+ * skipped: the `lstat` check runs every time, because detecting a directory
+ * swapped after the fact is the entire point of the check.
+ */
+const created = new Set<string>();
+
 async function privateDirectory(path: string): Promise<void> {
-  await mkdir(path, { mode: 0o700, recursive: true });
+  if (!created.has(path)) await mkdir(path, { mode: 0o700, recursive: true });
   const stat = await lstat(path);
   if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0 ||
       (process.getuid && stat.uid !== process.getuid())) {
+    created.delete(path);
     throw new Error(`Unsafe directory: ${path}. Expected a private directory owned by this user.`);
   }
+  created.add(path);
 }
 
 /**
@@ -203,7 +212,7 @@ export class Mailbox {
 
   private async writePresence(member: Membership, status: 'idle' | 'busy' | 'paused'): Promise<void> {
     const text = JSON.stringify({ token: member.token, status, seen: Date.now() } satisfies Presence);
-    await writeAtomic(this.presencePath(member.team, member.alias), text, 'light');
+    await writeAtomic(this.presencePath(member.team, member.alias), text, 'none');
   }
 
   /** Lock-free heartbeat: touches only this member's own presence file. */
@@ -219,8 +228,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

@@ -17,14 +17,26 @@ import { dirname, join } from 'node:path';
 export type Record<T> = { revision: number; payload: T };
 /** Parse raw file bytes into a record, throwing on corruption. Never deletes. */
 export type Normalize<T> = (raw: string) => Record<T>;
-/** 'full' fsyncs file and directory; 'light' fsyncs the file only (presence). */
-export type Durability = 'full' | 'light';
+/**
+ * 'full' fsyncs file and directory; 'light' fsyncs the file only; 'none'
+ * fsyncs nothing and relies on the atomic rename alone. Use 'none' only for
+ * records that are rewritten on a timer and safe to lose, such as presence:
+ * a lost write there makes a member look offline sooner, never alive longer.
+ */
+export type Durability = 'full' | 'light' | 'none';
 
 const STALE_LOCK_MS = 10_000;
 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 +74,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(); }
 }
@@ -91,17 +104,22 @@ async function syncDirectory(path: string): Promise<void> {
 
 /** Atomic last-writer-wins write for records without revision history (presence). */
 export async function writeAtomic(path: string, text: string, durability: Durability = 'full'): Promise<void> {
+  // Always: the presence directory does not exist before its first write.
   await mkdir(dirname(path), { recursive: true, mode: 0o700 });
   const tmp = `${path}.${randomUUID()}.tmp`;
   const handle = await open(tmp, 'wx', 0o600);
   try {
     await handle.writeFile(text, 'utf8');
-    await handle.sync();
+    if (durability !== 'none') await handle.sync();
   } finally { await handle.close(); }
   try {
     await rename(tmp, path);
     if (durability === 'full') await syncDirectory(path);
-  } finally { await unlink(tmp).catch(() => {}); }
+    return;
+  } catch (error) {
+    await unlink(tmp).catch(() => {});
+    throw error;
+  }
 }
 
 const locked = () => Object.assign(new Error('Another writer holds this record.'), { code: 'RECORD_LOCKED' });
@@ -175,6 +193,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 {