@prjct.app/pi-team 0.5.3 → 0.5.4

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prjct.app/pi-team",
-  "version": "0.5.3",
+  "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 };
@@ -651,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; }

package/src/mailbox.ts

@@ -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. */

package/src/store.ts

@@ -17,8 +17,13 @@ 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;
@@ -99,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' });