@fitchmultz/pi-subagents 0.46.0 → 0.46.2

package/src/pi-intercom/broker/broker.ts

@@ -23,7 +23,7 @@ import { errorMessage, isRecord, type UnknownRecord } from "../../shared/unknown
 import {
   messageSender,
   snapshotFrames,
-  prepareTopicChange,
+  TopicSnapshot,
   publicationMessage,
   deliveryAcknowledgement,
   shouldReplaceDelivery,
@@ -36,6 +36,7 @@ const REPLACE_DELIVERY_DELAY_MS = 1500;
 interface ConnectedSession {
   readonly socket: net.Socket;
   info: SessionInfo;
+  topics: TopicSnapshot;
   readonly topicFrames: boolean;
 }
 
@@ -178,7 +179,12 @@ class IntercomBroker {
     const info: SessionInfo = { ...msg.session, id, lastSeen: msg.session.lastSeen ?? Date.now() };
     snapshotFrames(randomUUID(), [info], true);
     const topicFrames = msg.topicFrames === true;
-    this.sessions.set(id, { socket, info, topicFrames });
+    this.sessions.set(id, {
+      socket,
+      info: messageSender(info),
+      topics: new TopicSnapshot(info),
+      topicFrames,
+    });
     setId(id);
     if (this.shutdownTimer) {
       clearTimeout(this.shutdownTimer);
@@ -208,9 +214,7 @@ class IntercomBroker {
       return deliveries;
     }
     for (const target of this.sessions.values()) {
-      const subscription = target.info.subscriptions?.find(
-        (entry) => entry.topic === publication.topic,
-      );
+      const subscription = target.topics.subscription(publication.topic);
       if (target.info.id === fromId || !subscription) {
         continue;
       }
@@ -234,24 +238,28 @@ class IntercomBroker {
       if (!session) {
         throw new Error("Sender session not found");
       }
-      const prepared = prepareTopicChange(session.info, msg.change, session.topicFrames);
-      const nextInfo = prepared.info;
+      const prepared = session.topics.prepare(msg.change, session.topicFrames);
+      const nextInfo = prepared.restore
+        ? session.info
+        : session.topics.snapshot(session.info, prepared);
       const from = messageSender(nextInfo);
       const deliveries = this.planPublications(currentId, from, prepared.publication);
-      const restore = prepared.restore;
-      const infos = [...this.sessions.values()].map((entry) =>
-        entry === session ? nextInfo : entry.info,
-      );
       // Validate every frame before committing state or delivering publications.
-      if (restore) {
-        snapshotFrames(requestId, [nextInfo], true);
+      if (prepared.restore) {
+        session.topics.validateRestore(session.info, prepared, requestId);
       }
-      const frames = snapshotFrames(requestId, restore ? [] : infos, msg.stream === true);
+      const infos = prepared.restore
+        ? []
+        : [...this.sessions.values()].map((entry) => {
+            if (entry === session) {
+              return nextInfo;
+            }
+            return msg.stream === true ? entry.topics.snapshot(entry.info) : entry.info;
+          });
+      const frames = snapshotFrames(requestId, infos, msg.stream === true);
       const last = frames.pop();
-      if (!last) {
-        throw new Error("Missing final snapshot frame");
-      }
-      session.info = nextInfo;
+      session.topics.commit(prepared);
+      session.info = messageSender(nextInfo);
       const receipts: Array<SessionSnapshot["receipts"][number]> = [];
       for (const { to, message } of deliveries) {
         receipts.push({ to, ...this.sendToSession(currentId, to, from, message) });
@@ -326,7 +334,10 @@ class IntercomBroker {
     if (!session) {
       return;
     }
-    const update: Record<string, unknown> = { ...session.info, lastSeen: Date.now() };
+    const update: Record<string, unknown> = {
+      ...session.topics.snapshot(session.info),
+      lastSeen: Date.now(),
+    };
     for (const key of [
       "name",
       "status",
@@ -346,7 +357,10 @@ class IntercomBroker {
       throw new Error("Invalid presence update");
     }
     snapshotFrames(randomUUID(), [nextInfo], true);
-    session.info = nextInfo;
+    if (msg.topics !== undefined || msg.subscriptions !== undefined) {
+      session.topics = new TopicSnapshot(nextInfo);
+    }
+    session.info = messageSender(nextInfo);
   }
 
   private sendToSession(

package/src/pi-intercom/broker/framing.ts

@@ -19,17 +19,67 @@ export function validateIntercomMessageSize(msg: unknown): Error | null {
  * Format: 4-byte big-endian length + JSON payload
  */
 export function writeMessage(socket: Socket, msg: unknown): void {
-  const tooLarge = validateIntercomMessageSize(msg);
-  if (tooLarge) {
-    throw tooLarge;
-  }
   const json = JSON.stringify(msg);
+  const size = Buffer.byteLength(json, "utf-8");
+  if (size > MAX_FRAME_SIZE_BYTES) {
+    throw new Error(`Intercom message too large (${size} bytes; max ${MAX_FRAME_SIZE_BYTES})`);
+  }
   const payload = Buffer.from(json, "utf-8");
   const header = Buffer.alloc(4);
   header.writeUInt32BE(payload.length, 0);
   socket.write(Buffer.concat([header, payload]));
 }
 
+/** Retain fragments until a header or payload is complete; copy each fragmented value once. */
+class MessageBuffer {
+  private chunks: Buffer[] = [];
+  private index = 0;
+  length = 0;
+
+  append(data: Buffer): void {
+    if (data.length > 0) {
+      this.chunks.push(data);
+      this.length += data.length;
+    }
+  }
+
+  clear(): void {
+    this.chunks = [];
+    this.index = 0;
+    this.length = 0;
+  }
+
+  read(size: number): Buffer {
+    const first = this.chunks[this.index];
+    if (size === 0) {
+      return Buffer.alloc(0);
+    }
+    const result = first.length >= size ? first.subarray(0, size) : Buffer.allocUnsafe(size);
+    let written = 0;
+    while (written < size) {
+      const chunk = this.chunks[this.index];
+      const count = Math.min(chunk.length, size - written);
+      if (first.length < size) {
+        chunk.copy(result, written, 0, count);
+      }
+      written += count;
+      this.length -= count;
+      if (count === chunk.length) {
+        this.index++;
+      } else {
+        this.chunks[this.index] = chunk.subarray(count);
+      }
+    }
+    if (this.index === this.chunks.length) {
+      this.clear();
+    } else if (this.index * 2 >= this.chunks.length) {
+      this.chunks = this.chunks.slice(this.index);
+      this.index = 0;
+    }
+    return result;
+  }
+}
+
 /**
  * Create a message reader that handles partial reads.
  * Calls onMessage for each complete message received.
@@ -39,27 +89,28 @@ export function createMessageReader(
   onMessage: (msg: unknown) => void,
   onError: (error: Readonly<Error>) => void,
 ): (data: Buffer) => void {
-  let buffer = Buffer.alloc(0);
+  const buffer = new MessageBuffer();
+  let length: number | undefined;
 
   return (data: Buffer) => {
-    buffer = Buffer.concat([buffer, data]);
-
-    while (buffer.length >= 4) {
-      const length = buffer.readUInt32BE(0);
-      if (length > MAX_FRAME_SIZE_BYTES) {
-        onError(
-          new Error(`Intercom frame too large (${length} bytes; max ${MAX_FRAME_SIZE_BYTES})`),
-        );
-        buffer = Buffer.alloc(0);
-        return;
-      }
+    buffer.append(data);
 
-      if (buffer.length < 4 + length) {
-        break;
+    while (buffer.length >= (length ?? 4)) {
+      if (length === undefined) {
+        length = buffer.read(4).readUInt32BE(0);
+        if (length > MAX_FRAME_SIZE_BYTES) {
+          onError(
+            new Error(`Intercom frame too large (${length} bytes; max ${MAX_FRAME_SIZE_BYTES})`),
+          );
+          buffer.clear();
+          length = undefined;
+          return;
+        }
+        continue;
       }
 
-      const payload = buffer.subarray(4, 4 + length);
-      buffer = buffer.subarray(4 + length);
+      const payload = buffer.read(length);
+      length = undefined;
 
       let msg: unknown;
       try {

package/src/pi-intercom/broker/snapshot-reader.ts

@@ -1,5 +1,11 @@
 import { isRecord, isUnknownArray, type UnknownRecord } from "../../shared/unknown.ts";
-import { normalizeSessionInfo, type SessionInfo, type SessionSnapshot } from "../types.ts";
+import {
+  normalizeSessionInfo,
+  type SessionInfo,
+  type SessionSnapshot,
+  type TopicSubscription,
+  type TopicUpdate,
+} from "../types.ts";
 
 type Receipt = SessionSnapshot["receipts"][number];
 
@@ -46,9 +52,30 @@ function receipt(value: unknown): Receipt {
   };
 }
 
+interface SessionParts {
+  readonly info: SessionInfo;
+  readonly topics: TopicUpdate[] | undefined;
+  readonly subscriptions: TopicSubscription[] | undefined;
+}
+
+function appendRows<T>(
+  previous: T[] | undefined,
+  rows: readonly T[] | undefined,
+  supplied: boolean,
+): T[] | undefined {
+  if (rows === undefined) {
+    return supplied ? undefined : previous;
+  }
+  const result = previous ?? [];
+  for (const row of rows) {
+    result.push(row);
+  }
+  return result;
+}
+
 /** Multipart frames build a private cache; only a complete validated snapshot escapes. */
 export class SnapshotReader {
-  private readonly sessions = new Map<string, SessionInfo>();
+  private readonly sessions = new Map<string, SessionParts>();
   private readonly receipts: Receipt[] = [];
 
   private addSession(row: unknown): void {
@@ -59,17 +86,20 @@ export class SnapshotReader {
     const subscriptions = optionalArray(row.subscriptions);
     const previous = this.sessions.get(row.id);
     const info = normalizeSessionInfo({
-      ...previous,
+      ...previous?.info,
       ...row,
-      ...(topics !== undefined ? { topics: [...(previous?.topics ?? []), ...topics] } : {}),
-      ...(subscriptions !== undefined
-        ? { subscriptions: [...(previous?.subscriptions ?? []), ...subscriptions] }
-        : {}),
+      ...(topics !== undefined ? { topics } : {}),
+      ...(subscriptions !== undefined ? { subscriptions } : {}),
     });
     if (!info) {
       throw new Error("Invalid session snapshot");
     }
-    this.sessions.set(info.id, info);
+    const { topics: newTopics, subscriptions: newSubscriptions, ...identity } = info;
+    this.sessions.set(info.id, {
+      info: identity,
+      topics: appendRows(previous?.topics, newTopics, "topics" in row),
+      subscriptions: appendRows(previous?.subscriptions, newSubscriptions, "subscriptions" in row),
+    });
   }
 
   append(sessions: readonly unknown[], receipts: unknown): void {
@@ -86,6 +116,14 @@ export class SnapshotReader {
   }
 
   finish(): SessionSnapshot {
-    return { sessions: [...this.sessions.values()], receipts: this.receipts };
+    const sessions: SessionInfo[] = [];
+    for (const { info, topics, subscriptions } of this.sessions.values()) {
+      sessions.push({
+        ...info,
+        ...(topics !== undefined ? { topics } : {}),
+        ...(subscriptions !== undefined ? { subscriptions } : {}),
+      });
+    }
+    return { sessions, receipts: this.receipts };
   }
 }

package/src/pi-intercom/broker/snapshots.ts

@@ -10,7 +10,11 @@ import {
   type TopicSubscription,
   type SendResult,
 } from "../types.ts";
-import { validateIntercomMessageSize } from "./framing.ts";
+import {
+  intercomMessageSizeBytes,
+  MAX_FRAME_SIZE_BYTES,
+  validateIntercomMessageSize,
+} from "./framing.ts";
 
 /** Direct messages and old clients receive identity, not potentially large topic state. */
 export function messageSender(info: SessionInfo): SessionInfo {
@@ -124,72 +128,201 @@ function publicationUpdate(
   return { ...topic, revision };
 }
 
-class TopicSnapshot {
-  private readonly info: SessionInfo;
-  private readonly topics: Map<string, TopicUpdate>;
-  private readonly subscriptions: Map<string, TopicSubscription>;
+class SnapshotRecords<T extends { readonly topic: string }> {
+  private readonly records = new Map<string, { readonly value: T; readonly bytes: number }>();
+  private largest = 0;
+  private initial: readonly T[] | undefined;
+  private present: boolean;
 
-  constructor(info: SessionInfo) {
-    this.info = info;
-    this.topics = new Map((info.topics ?? []).map((topic) => [topic.topic, topic]));
-    this.subscriptions = new Map((info.subscriptions ?? []).map((entry) => [entry.topic, entry]));
+  constructor(values: readonly T[] | undefined) {
+    this.initial = values;
+    this.present = values !== undefined;
+    for (const value of values ?? []) {
+      this.set(value, intercomMessageSizeBytes(value));
+    }
   }
 
-  apply(mutation: TopicMutation): TopicUpdate | undefined {
-    switch (mutation.kind) {
-      case "publication": {
-        const previous = this.topics.get(mutation.topic.topic);
-        const update = publicationUpdate(mutation.topic, previous, mutation.publish);
-        if (mutation.publish || (previous?.revision ?? 0) < update.revision) {
-          this.topics.set(update.topic, update);
-        }
-        if (mutation.publish) {
-          return update;
-        }
+  get(topic: string, first = false): T | undefined {
+    if (first && this.initial !== undefined) {
+      return this.initial.find((record) => record.topic === topic);
+    }
+    return this.records.get(topic)?.value;
+  }
+
+  maximumAfter(topic?: string, bytes = 0): number {
+    const previous = topic === undefined ? undefined : this.records.get(topic);
+    if (previous?.bytes !== this.largest || bytes >= this.largest) {
+      return Math.max(this.largest, bytes);
+    }
+    // ponytail: shrinking the largest record scans cached sizes; index sizes if churn warrants it.
+    let largest = bytes;
+    for (const [key, record] of this.records) {
+      if (key !== topic) {
+        largest = Math.max(largest, record.bytes);
+      }
+    }
+    return largest;
+  }
+
+  set(value: T, bytes: number): void {
+    this.largest = this.maximumAfter(value.topic, bytes);
+    this.records.set(value.topic, { value, bytes });
+  }
+
+  delete(topic: string): void {
+    this.largest = this.maximumAfter(topic);
+    this.records.delete(topic);
+  }
+
+  accept(): void {
+    this.initial = undefined;
+    this.present = true;
+  }
+
+  valuesAfter(topic?: string, value?: T, changed = false): readonly T[] | undefined {
+    if (!changed) {
+      if (this.initial !== undefined) {
+        return this.initial;
+      }
+      if (!this.present) {
         return;
       }
+    }
+    const values: T[] = [];
+    for (const [key, record] of this.records) {
+      const next = key === topic ? value : record.value;
+      if (next !== undefined) {
+        values.push(next);
+      }
+    }
+    if (value !== undefined && !this.records.has(value.topic)) {
+      values.push(value);
+    }
+    return values;
+  }
+}
+
+interface PreparedTopicChange {
+  readonly topic?: TopicUpdate;
+  readonly subscription?: TopicSubscription;
+  readonly unsubscribe?: string;
+  readonly publication?: TopicUpdate;
+  readonly restore: boolean;
+  readonly changed: boolean;
+  readonly bytes: number;
+}
+
+const UNCHANGED: PreparedTopicChange = { restore: false, changed: false, bytes: 0 };
+
+/** Keep committed records indexed; restores validate only new bytes and cached envelope maxima. */
+export class TopicSnapshot {
+  private readonly topics: SnapshotRecords<TopicUpdate>;
+  private readonly subscriptions: SnapshotRecords<TopicSubscription>;
+
+  constructor(info: SessionInfo) {
+    this.topics = new SnapshotRecords(info.topics);
+    this.subscriptions = new SnapshotRecords(info.subscriptions);
+  }
+
+  subscription(topic: string): TopicSubscription | undefined {
+    return this.subscriptions.get(topic, true);
+  }
+
+  prepare(change: unknown, supported: boolean): PreparedTopicChange {
+    if (change === undefined) {
+      return UNCHANGED;
+    }
+    if (!supported || !isRecord(change)) {
+      throw new Error("Topic snapshots unavailable for this client");
+    }
+    const mutation = topicMutation(change);
+    const base = { restore: change.action === "restore", changed: true, bytes: 0 };
+    switch (mutation.kind) {
+      case "publication":
+        return this.preparePublication(mutation, base);
       case "subscription":
-        this.subscriptions.set(mutation.subscription.topic, mutation.subscription);
-        return;
+        return {
+          ...base,
+          subscription: mutation.subscription,
+          bytes: intercomMessageSizeBytes(mutation.subscription),
+        };
       case "unsubscribe":
-        this.subscriptions.delete(mutation.topic);
-        return;
+        return { ...base, unsubscribe: mutation.topic };
+    }
+  }
+
+  private preparePublication(
+    mutation: Extract<TopicMutation, { readonly kind: "publication" }>,
+    base: PreparedTopicChange,
+  ): PreparedTopicChange {
+    const previous = this.topics.get(mutation.topic.topic);
+    const update = publicationUpdate(mutation.topic, previous, mutation.publish);
+    if (!mutation.publish && (previous?.revision ?? 0) >= update.revision) {
+      return base;
     }
+    return {
+      ...base,
+      topic: update,
+      bytes: intercomMessageSizeBytes(update),
+      ...(mutation.publish ? { publication: update } : {}),
+    };
   }
 
-  snapshot(publication?: TopicUpdate): SessionInfo {
+  snapshot(info: SessionInfo, prepared = UNCHANGED): SessionInfo {
+    const topics = this.topics.valuesAfter(prepared.topic?.topic, prepared.topic, prepared.changed);
+    const subscriptions = this.subscriptions.valuesAfter(
+      prepared.subscription?.topic ?? prepared.unsubscribe,
+      prepared.subscription,
+      prepared.changed,
+    );
     return {
-      ...this.info,
-      topics: [...this.topics.values()],
-      subscriptions: [...this.subscriptions.values()],
-      ...(publication ? { lastIntercomActivity: Date.now() } : {}),
+      ...info,
+      ...(topics !== undefined ? { topics } : {}),
+      ...(subscriptions !== undefined ? { subscriptions } : {}),
+      ...(prepared.publication ? { lastIntercomActivity: Date.now() } : {}),
     };
   }
-}
 
-/** Prepare a change without mutating the usable broker snapshot before frame validation. */
-export function prepareTopicChange(
-  info: SessionInfo,
-  change: unknown,
-  supported: boolean,
-): {
-  readonly info: SessionInfo;
-  readonly publication?: TopicUpdate;
-  readonly restore: boolean;
-} {
-  if (change === undefined) {
-    return { info, restore: false };
+  validateRestore(info: SessionInfo, prepared: PreparedTopicChange, requestId: string): void {
+    snapshotFrames(requestId, [{ ...info, topics: [], subscriptions: [] }], true);
+    const topicBytes = this.topics.maximumAfter(
+      prepared.topic?.topic,
+      prepared.topic ? prepared.bytes : 0,
+    );
+    const subscriptionBytes = this.subscriptions.maximumAfter(
+      prepared.subscription?.topic,
+      prepared.subscription ? prepared.bytes : 0,
+    );
+    for (const [field, bytes] of [
+      ["topics", topicBytes],
+      ["subscriptions", subscriptionBytes],
+    ] as const) {
+      const size =
+        intercomMessageSizeBytes({
+          type: "sessions",
+          requestId,
+          sessions: [{ id: info.id, [field]: [] }],
+          more: true,
+        }) + bytes;
+      if (size > MAX_FRAME_SIZE_BYTES) {
+        throw new Error(`Intercom message too large (${size} bytes; max ${MAX_FRAME_SIZE_BYTES})`);
+      }
+    }
   }
-  if (!supported || !isRecord(change)) {
-    throw new Error("Topic snapshots unavailable for this client");
+
+  commit(prepared: PreparedTopicChange): void {
+    if (prepared.changed) {
+      this.topics.accept();
+      this.subscriptions.accept();
+    }
+    if (prepared.topic) {
+      this.topics.set(prepared.topic, prepared.bytes);
+    } else if (prepared.subscription) {
+      this.subscriptions.set(prepared.subscription, prepared.bytes);
+    } else if (prepared.unsubscribe !== undefined) {
+      this.subscriptions.delete(prepared.unsubscribe);
+    }
   }
-  const pending = new TopicSnapshot(info);
-  const publication = pending.apply(topicMutation(change));
-  return {
-    info: pending.snapshot(publication),
-    restore: change.action === "restore",
-    ...(publication ? { publication } : {}),
-  };
 }
 
 export function deliveryAcknowledgement(receipt: SendResult): BrokerMessage {

package/src/pi-intercom/session-targets.ts

@@ -18,7 +18,6 @@ export interface TargetResolution<T extends TargetIdentity> {
   readonly status: "none" | "found" | "ambiguous" | "prefix_too_short";
   readonly target?: T;
   readonly matches: readonly T[];
-  readonly minLength?: number;
 }
 
 export function shortSessionId(sessionId: string): string {
@@ -180,7 +179,6 @@ function shortTargetResolution<T extends TargetIdentity>(
     return {
       status: "prefix_too_short",
       matches: prefixes,
-      minLength: MIN_SESSION_TARGET_PREFIX_LENGTH,
     };
   }
   const byId = new Map<string, T>();

package/src/runs/background/async-run-discovery.ts

@@ -6,12 +6,12 @@ import { runSynchronously } from "../../shared/cooperative.ts";
 import { asyncRunRoots, readAsyncRunRecord } from "./async-resume.ts";
 import type { AsyncRunRecord } from "./async-run-record.ts";
 import type { AsyncRunSummary } from "./async-run-summary.ts";
-import { getRunMetadataDir, readRunJson } from "../shared/supervisor-questions.ts";
+import { readQuestionOwner } from "../shared/supervisor-questions.ts";
 import { findNestedRouteForRootId } from "../shared/nested-events.ts";
 import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
 import { validateStatusForSummary } from "./async-status-validation.ts";
 import { asyncStatusToSummary } from "./async-status-projection.ts";
-import { errorCode, errorMessage, hasText, isRecord } from "./async-value.ts";
+import { errorCode, errorMessage, hasText } from "./async-value.ts";
 
 interface AsyncRunListOptions {
   readonly states?: readonly AsyncRunSummary["state"][];
@@ -112,14 +112,8 @@ class AsyncRunDiscovery {
     let owner = this.owners.get(entry);
     if (!hasText(owner) && hasText(this.ownerSessionId)) {
       try {
-        const saved: unknown = readRunJson(
-          path.join(getRunMetadataDir(entry), "question-owner.json"),
-        );
-        if (
-          isRecord(saved) &&
-          typeof saved.sessionId === "string" &&
-          saved.sessionId.trim().length > 0
-        ) {
+        const saved = readQuestionOwner(entry);
+        if (saved?.sessionId !== undefined && saved.sessionId.trim().length > 0) {
           owner = saved.sessionId;
           this.owners.set(entry, owner);
         }