@prjct.app/pi-team 0.5.3 → 0.5.5

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.5.5](https://github.com/prjct-app/pi-team/compare/v0.5.4...v0.5.5) (2026-09-10)
+
+### Performance Improvements
+
+* carry the canonical payload serialization instead of recomputing it ([#24](https://github.com/prjct-app/pi-team/issues/24)) ([340c495](https://github.com/prjct-app/pi-team/commit/340c4954358e715c6aed5e37e9f0a78f33100877))
+
+## [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.5",
   "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);
 }
 
 /**
@@ -141,15 +150,22 @@ export class Mailbox {
     for (const attempt of ATTEMPTS) {
       const record = await this.readState(team);
       const state = record.payload;
-      const before = JSON.stringify(state);
+      // The parser already produced this for the content hash. A pre-envelope
+      // record carries none, so that path serializes as before. A mismatch
+      // could only ever cause one redundant publication, never a lost write:
+      // `before` comes from the pre-action object and `after` from the
+      // post-action one, so they cannot coincide by accident.
+      const before = record.payloadJson ?? JSON.stringify(state);
       const presence = await this.readPresence(team);
       const swept = state.members.filter(member => member.status !== 'offline' && !this.alive(member, presence));
       for (const member of swept) this.disconnect(state, member);
       const result = action(state);
-      if (before === JSON.stringify(state)) return result;
+      const after = JSON.stringify(state);
+      if (before === after) return result;
       if (!Value.Check(StateSchema, state)) throw new Error('Invalid mailbox format; refusing to write');
       try {
-        await publish(this.recordPath(team), record.revision, state, this.normalize(team), { maxBytes: MAX_BYTES });
+        await publish(this.recordPath(team), record.revision, state, this.normalize(team),
+          { maxBytes: MAX_BYTES, payloadJson: after });
         await Promise.all(swept.map(member => unlink(this.presencePath(team, member.alias)).catch(() => {})));
         return result;
       } catch (error) {
@@ -203,7 +219,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. */
@@ -214,7 +230,14 @@ export class Mailbox {
     await this.writePresence(member, status);
   }
 
-  /** Lock-free consistent view of the record with presence-based statuses. */
+  /**
+   * Lock-free consistent view of the record with presence-based statuses.
+   *
+   * The cached read returns a shared record, and the message objects below are
+   * the record's own, not copies. Never mutate them: it would corrupt both the
+   * process-wide cache and the `payloadJson` taken alongside it. `mutate` is
+   * safe because it reads uncached.
+   */
   async snapshot(member: Membership): Promise<Snapshot> {
     const record = await this.readState(member.team, true);
     this.owner(record.payload, member);

package/src/store.ts

@@ -14,11 +14,22 @@ import { dirname, join } from 'node:path';
  * hard-links its envelope into a bounded revisions/ history, which doubles as
  * recovery evidence for interrupted writes.
  */
-export type Record<T> = { revision: number; payload: T };
+/**
+ * `payloadJson` is the canonical `JSON.stringify(payload)`, carried when the
+ * parser already had to compute it for the content hash. It is consistent by
+ * construction, never derived from the raw file text, and always optional: a
+ * pre-envelope record has none and callers fall back to serializing.
+ */
+export type Record<T> = { revision: number; payload: T; payloadJson?: string };
 /** 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;
@@ -41,10 +52,11 @@ export function envelope<T>(raw: string): Record<T> {
   if (typeof parsed.revision !== 'number' || !Number.isSafeInteger(parsed.revision) || parsed.revision < 1) {
     throw Object.assign(new Error('Invalid record revision.'), { code: 'CORRUPT_RECORD' });
   }
-  if (parsed.contentHash !== sha256(JSON.stringify(parsed.payload))) {
+  const payloadJson = JSON.stringify(parsed.payload);
+  if (parsed.contentHash !== sha256(payloadJson)) {
     throw Object.assign(new Error('Record hash mismatch; preserved for manual recovery.'), { code: 'CORRUPT_RECORD' });
   }
-  return { revision: parsed.revision, payload: parsed.payload as T };
+  return { revision: parsed.revision, payload: parsed.payload as T, payloadJson };
 }
 
 function assertSafeFile(path: string, info: { isFile(): boolean; size: number; mode: number; uid: number }, maxBytes: number): void {
@@ -99,17 +111,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' });
@@ -152,7 +169,7 @@ async function pruneRevisions(dir: string, latest: number): Promise<void> {
  */
 export async function publish<T>(
   path: string, expectedRevision: number, payload: T, normalize: Normalize<T>,
-  options: { maxBytes: number; durability?: Durability },
+  options: { maxBytes: number; durability?: Durability; payloadJson?: string },
 ): Promise<Record<T>> {
   const durability = options.durability ?? 'full';
   await mkdir(dirname(path), { recursive: true, mode: 0o700 });
@@ -165,12 +182,15 @@ export async function publish<T>(
       throw Object.assign(new Error(`Record changed before the write; current revision is ${revision}.`), { code: 'STALE_REVISION' });
     }
     const next = revision + 1;
-    const payloadJson = JSON.stringify(payload);
+    // Supplied by callers that already serialized this exact object; it must
+    // equal JSON.stringify(payload). The record stays self-consistent either
+    // way, because the hash is taken over the string that gets embedded.
+    const payloadJson = options.payloadJson ?? JSON.stringify(payload);
     const text = `{"schemaVersion":1,"revision":${next},"contentHash":"${sha256(payloadJson)}","payload":${payloadJson}}`;
     if (Buffer.byteLength(text) > options.maxBytes) throw new Error('Record size limit exceeded.');
     const historyPath = join(dirname(path), 'revisions', `${next}.json`);
     const previous = await readRecord(historyPath, (raw: string) => envelope<T>(raw), options.maxBytes);
-    if (previous && (previous.revision !== next || sha256(JSON.stringify(previous.payload)) !== sha256(payloadJson))) {
+    if (previous && (previous.revision !== next || (previous.payloadJson ?? JSON.stringify(previous.payload)) !== payloadJson)) {
       throw new Error('An interrupted publication owns this revision; explicit recovery is required.');
     }
     if (!previous) await writeAtomic(historyPath, text, durability);
@@ -185,7 +205,7 @@ export async function publish<T>(
     cache.delete(path);
     counters.publishes++;
     await pruneRevisions(dirname(path), next).catch(() => {});
-    return { revision: next, payload };
+    return { revision: next, payload, payloadJson };
   } finally {
     await lock.close();
     await unlink(lockPath).catch(() => {});