@fitchmultz/pi-subagents 0.52.1 → 0.52.3

package/src/agent/usage.ts

@@ -1,9 +1,9 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
-import { journalStamp } from "../shared/native-journal.ts";
+import { journalStamp, nativeAppend } from "../shared/native-journal.ts";
 import { nativeProjection } from "../shared/journal-projections.ts";
 import { scanJournal } from "../shared/journal-frames.ts";
-import { isRecord } from "../shared/unknown.ts";
+import { isRecord, type UnknownRecord } from "../shared/unknown.ts";
 import { Assert } from "./typebox.ts";
 import {
   contributionsSchema,
@@ -14,7 +14,8 @@ import {
 } from "./contracts.ts";
 import { read, runDirectory, write } from "./storage.ts";
 
-function billing(entry: Record<string, unknown>) {
+/** Billing evidence of one native entry. Missing required usage is an error only outside a baseline. */
+function billing(entry: UnknownRecord): UnknownRecord | "missing" | undefined {
   if (entry.checkpoint === true) {
     return;
   }
@@ -25,13 +26,13 @@ function billing(entry: Record<string, unknown>) {
   ) {
     return;
   }
-  const required = entry.type === "usage" || message.role === "assistant";
-  if (required && message.usage === undefined) {
-    throw new Error("Required native usage is unavailable.");
+  if (message.usage === undefined) {
+    return entry.type === "usage" || message.role === "assistant" ? "missing" : undefined;
   }
-  return message.usage === undefined ? undefined : message;
+  const { role, provider, model, responseModel, usage } = message;
+  return { role, provider, model, responseModel, usage };
 }
-function attribution(message: Record<string, unknown>, launch: Launch) {
+function attribution(message: UnknownRecord, launch: Launch) {
   if (message.role === "toolResult") {
     return { provider: launch.provider, model: launch.model };
   }
@@ -44,63 +45,118 @@ function attribution(message: Record<string, unknown>, launch: Launch) {
     model: typeof model === "string" ? model : launch.model,
   };
 }
-export function childUsage(
-  launch: Launch,
-  baseline: ReadonlySet<string>,
-  terminal?: string,
-): Contribution[] {
-  const values: unknown[] = [];
-  const observed = { header: false, ended: false };
-  const reachedTerminal = new Error("Native terminal boundary reached.");
-  const fd = fs.openSync(launch.sessionFile, "r");
-  try {
-    const stamp = journalStamp(fs.fstatSync(fd, { bigint: true }));
+interface Entry {
+  readonly id: string;
+  readonly billing: UnknownRecord | "missing" | undefined;
+}
+/** Accounting metadata of the validated LF-published journal records before `end`. */
+interface Prefix {
+  stat: fs.BigIntStats;
+  end: number;
+  header?: UnknownRecord;
+  readonly entries: Entry[];
+}
+function identify(header: UnknownRecord, launch: Launch): void {
+  if (header.type !== "session" || header.id !== launch.sessionId) {
+    throw new Error("Foreign native usage journal identity.");
+  }
+}
+/** An unchanged or native v3 appended journal keeps its prefix; any other change rebuilds it. */
+function reusable(cached: Prefix | undefined, stat: fs.BigIntStats): Prefix {
+  return cached !== undefined &&
+    (journalStamp(cached.stat) === journalStamp(stat) ||
+      nativeAppend(cached.stat, stat, cached.header))
+    ? cached
+    : { stat, end: 0, entries: [] };
+}
+/**
+ * Child usage of one physical native journal. A retained index parses only records after its last
+ * accepted LF boundary. Baselines, required usage and attribution apply to each read.
+ */
+export class UsageIndex {
+  private prefix?: Prefix;
+  read(launch: Launch, baseline: ReadonlySet<string>, terminal?: string): Contribution[] {
+    const values: unknown[] = [];
+    const reachedTerminal = new Error("Native terminal boundary reached.");
+    const charge = (entry: Entry): void => {
+      const billed = baseline.has(entry.id) ? undefined : entry.billing;
+      if (billed === "missing") {
+        throw new Error("Required native usage is unavailable.");
+      }
+      if (billed !== undefined) {
+        values.push({
+          id: `${launch.sessionId}:${entry.id}`,
+          ...attribution(billed, launch),
+          usage: billed.usage,
+        });
+      }
+      if (entry.id === terminal) {
+        throw reachedTerminal;
+      }
+    };
+    const cached = this.prefix;
+    // Only a completed read is retained.
+    this.prefix = undefined;
+    const fd = fs.openSync(launch.sessionFile, "r");
     try {
-      scanJournal(
-        fd,
-        nativeProjection,
-        ({ value }) => {
-          if (!observed.header) {
-            if (value.type !== "session" || value.id !== launch.sessionId) {
-              throw new Error("Foreign native usage journal identity.");
+      const stat = fs.fstatSync(fd, { bigint: true });
+      const prefix = reusable(cached, stat);
+      let ended = false;
+      try {
+        if (prefix.header !== undefined) {
+          identify(prefix.header, launch);
+        }
+        for (const entry of prefix.entries) {
+          charge(entry);
+        }
+        scanJournal(
+          fd,
+          nativeProjection,
+          ({ value, end }) => {
+            if (prefix.header === undefined) {
+              identify(value, launch);
+              prefix.header = value;
+              prefix.end = end;
+              return;
+            }
+            if (typeof value.id !== "string" || typeof value.type !== "string") {
+              throw new Error("Missing native usage entry identity.");
             }
-            observed.header = true;
-            return;
-          }
-          if (typeof value.id !== "string" || typeof value.type !== "string") {
-            throw new Error("Missing native usage entry identity.");
-          }
-          const message = baseline.has(value.id) ? undefined : billing(value);
-          if (message) {
-            values.push({
-              id: `${launch.sessionId}:${value.id}`,
-              ...attribution(message, launch),
-              usage: message.usage,
-            });
-          }
-          if (value.id === terminal) {
-            observed.ended = true;
-            throw reachedTerminal;
-          }
-        },
-        { policy: "live", requireNewline: true },
-      );
-    } catch (error) {
-      if (error !== reachedTerminal) {
-        throw error;
+            const entry = { id: value.id, billing: billing(value) };
+            prefix.entries.push(entry);
+            prefix.end = end;
+            charge(entry);
+          },
+          { policy: "live", requireNewline: true, start: prefix.end },
+        );
+      } catch (error) {
+        if (error !== reachedTerminal) {
+          throw error;
+        }
+        ended = true;
       }
+      if (journalStamp(fs.fstatSync(fd, { bigint: true })) !== journalStamp(stat)) {
+        throw new Error("Native usage journal changed while reading.");
+      }
+      if (prefix.header === undefined || (terminal !== undefined && !ended)) {
+        throw new Error("Native terminal or session identity is not LF-published.");
+      }
+      Assert(contributionsSchema, values);
+      prefix.stat = stat;
+      this.prefix = prefix;
+      return values;
+    } finally {
+      fs.closeSync(fd);
     }
-    if (journalStamp(fs.fstatSync(fd, { bigint: true })) !== stamp) {
-      throw new Error("Native usage journal changed while reading.");
-    }
-  } finally {
-    fs.closeSync(fd);
-  }
-  if (!observed.header || (terminal !== undefined && !observed.ended)) {
-    throw new Error("Native terminal or session identity is not LF-published.");
   }
-  Assert(contributionsSchema, values);
-  return values;
+}
+/** A fresh read for callers without an owner lifetime. */
+export function childUsage(
+  launch: Launch,
+  baseline: ReadonlySet<string>,
+  terminal?: string,
+): Contribution[] {
+  return new UsageIndex().read(launch, baseline, terminal);
 }
 export function readCanonicalResult(base: string, launch: Launch): Result | undefined {
   const file = path.join(runDirectory(base, launch.id), "result.json");

package/src/pi-intercom/bridge-mailbox.ts

@@ -196,14 +196,24 @@ export class Mailbox {
   }
   ack(ids: readonly string[]): UnknownRecord {
     const acked: string[] = [];
-    for (const id of ids) {
-      const entry = this.get(id);
-      if (entry) {
-        this.notificationAccepted(id);
-        this.remove(id);
-        acked.push(id);
+    this.stored(() => {
+      // One FULL commit per ACK group; a rollback leaves every listed payload and intent pending.
+      this.db?.exec("BEGIN IMMEDIATE");
+      try {
+        for (const id of ids) {
+          const entry = this.get(id);
+          if (entry) {
+            this.notificationAccepted(id);
+            this.remove(id);
+            acked.push(id);
+          }
+        }
+        this.db?.exec("COMMIT");
+      } catch (error) {
+        this.db?.exec("ROLLBACK");
+        throw error;
       }
-    }
+    });
     return { acked };
   }
   page(after: number, limit: number): InboxPage {

package/src/pi-intercom/bridge-wake.ts

@@ -138,21 +138,20 @@ export class WakeDeliveries {
 
   private pending(delivery: Delivery): PendingNotification | undefined {
     let after = 0;
-    let next: PendingNotification | undefined;
     let page;
     do {
-      page = delivery.mailbox.pendingNotifications(after);
+      // Decode only the retired prefix and the oldest actionable entry, not the whole backlog.
+      page = delivery.mailbox.pendingNotifications(after, 1);
       for (const entry of page.messages) {
-        if (!actionable(entry)) {
-          // Retire only notification intent. Payload/reply obligations require actual ACK/reply.
-          delivery.mailbox.notificationAccepted(entry.message.id);
-        } else if (!next) {
-          next = entry;
+        if (actionable(entry)) {
+          return entry;
         }
+        // Retire only notification intent. Payload/reply obligations require actual ACK/reply.
+        delivery.mailbox.notificationAccepted(entry.message.id);
       }
       after = Number(page.nextCursor);
     } while (page.hasMore);
-    return next;
+    return undefined;
   }
 
   private groups(): Map<string, Candidate | undefined> {

package/src/pi-intercom/inbound-journal.ts

@@ -8,7 +8,12 @@ import {
   type InboundMessageEntry,
   type PendingInboundMessage,
 } from "./runtime-types.ts";
-import { isInboundCheckpoint, publicationMetadata, requestedDelivery } from "./inbound-record.ts";
+import {
+  checkpointMessageId,
+  isInboundCheckpoint,
+  publicationMetadata,
+  requestedDelivery,
+} from "./inbound-record.ts";
 import {
   isReceiptQuery,
   type NativeReceipt,
@@ -66,6 +71,7 @@ export class InboundJournal {
     if (
       item.type === "custom" &&
       item.customType === INBOUND_CHECKPOINT_TYPE &&
+      checkpointMessageId(item.data) === query.messageId &&
       isInboundCheckpoint(item.data) &&
       item.data.sessionId === query.rootSessionId
     ) {
@@ -82,7 +88,7 @@ export class InboundJournal {
     data: InboundCheckpoint,
   ): NativeReceipt | undefined {
     if ("entry" in data) {
-      if (receipt || data.entry.message.id !== query.messageId) {
+      if (receipt) {
         return receipt;
       }
       const { from, message, stage, receivedAt } = data.entry;
@@ -106,7 +112,7 @@ export class InboundJournal {
         discarded: false,
       };
     }
-    if (!receipt || data.messageId !== query.messageId) {
+    if (!receipt) {
       return receipt;
     }
     return {

package/src/pi-intercom/inbound-record.ts

@@ -97,3 +97,15 @@ export function isInboundCheckpoint(
       value.stage === "reply-retired")
   );
 }
+/** Unvalidated: lets a receipt skip checkpoints for other messages before full validation. */
+export function checkpointMessageId(value: unknown): unknown {
+  if (!isRecord(value)) {
+    return;
+  }
+  if ("entry" in value) {
+    return isRecord(value.entry) && isRecord(value.entry.message)
+      ? value.entry.message.id
+      : undefined;
+  }
+  return value.messageId;
+}

package/src/pi-intercom/ui/session-format.ts

@@ -11,10 +11,19 @@ function localForkStartCommand(): string {
   return `pi --name worker --extension ${shellQuote(path.join(PACKAGE_ROOT, "src", "index.ts"))}`;
 }
 function duplicateNames(sessions: readonly SessionInfo[]): ReadonlySet<string> {
-  const names = sessions
-    .map((session) => session.name?.toLowerCase())
-    .filter((name): name is string => name !== undefined && name !== "");
-  return new Set(names.filter((name, index) => names.indexOf(name) !== index));
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+  for (const session of sessions) {
+    const name = session.name?.toLowerCase();
+    if (name === undefined || name === "") {
+      continue;
+    }
+    if (seen.has(name)) {
+      duplicates.add(name);
+    }
+    seen.add(name);
+  }
+  return duplicates;
 }
 export function formatDuration(seconds: number): string {
   if (seconds < 60) {
@@ -79,7 +88,7 @@ function healthTags(session: SessionInfo, now: number): readonly string[] {
 interface RowOptions {
   readonly currentCwd: string;
   readonly self: boolean;
-  readonly duplicates: (name: string) => boolean;
+  readonly duplicates: ReadonlySet<string>;
   readonly allSessions: readonly SessionInfo[];
   readonly now: number;
 }
@@ -88,7 +97,7 @@ function row(session: SessionInfo, options: RowOptions): string {
   const duplicate =
     session.name !== undefined &&
     session.name !== "" &&
-    options.duplicates(session.name.toLowerCase());
+    options.duplicates.has(session.name.toLowerCase());
   let location: string | undefined;
   if (options.self) {
     location = "self";
@@ -132,7 +141,7 @@ export function formatSessionListSections(
   const others = scoped.filter((session) => session.id !== id);
   const options = {
     currentCwd: current.cwd,
-    duplicates: (name: string) => duplicateNames(allSessions).has(name),
+    duplicates: duplicateNames(allSessions),
     allSessions,
     now: Date.now(),
   };