@fitchmultz/pi-subagents 0.52.1 → 0.52.3

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [0.52.3] - 2026-10-29
+
+### Fixed
+
+- Build Intercom's duplicate-name set once per session list instead of once per row. Session names, duplicate labels and target resolution are unchanged.
+- Hash parked child state in bounded chunks when answering history requests or restoring a child. The digest and native state validation are unchanged.
+- Skip the bash-owner inventory lookup for child tool calls that are not bash commands. Bash ownership checks and child delegation restrictions are unchanged.
+- Avoid revalidating unrelated incoming messages when looking up an Intercom receipt. Receipt contents and branch-wide history remain unchanged.
+- Reuse the child-status widget's display between inventory updates instead of rebuilding it on every parent frame. Theme changes, activity, errors and click targets remain visible.
+- Batch optional bridge acknowledgements in one SQLite transaction and stop reading wake notifications once the next actionable message is known. A failed acknowledgement leaves the group pending. Later non-wake cleanup can wait behind a pending wake.
+- Stop the live child viewer from rebuilding native renderers after each streamed update. Assistant and tool cards now keep the native component's own update result and only refresh the card's outer layout. On the maintained fork, unchanged thinking or prose is no longer re-parsed while a later block streams. On both hosts, tool-argument and progress updates run native tool rendering once per update instead of twice. Visible output, theme changes, resize, selection and expansion are unchanged.
+- Stop each child continuation from rereading its whole native journal to record usage. A resident child keeps the IDs and billing fields of records it already validated and parses only records appended after its previous LF boundary. Unchanged journals are not reread; same-size edits, shrink, inode replacement, non-v3 headers and failed reads rebuild from the start. Inherited baselines, terminal stop, required usage and attribution still apply to every run. A restarted or restored child and the parent's pending-accounting repair still read the journal once from the start.
+- Reuse the running Pi's SDK for the first delegation, `/agents` and parked-history restore in production-only installs, instead of importing a second copy of the same SDK from disk. In five alternating pairs per host on a busy macOS machine, the parent no longer grew by 66–85 MiB during its first `delegate` call. The median time to that call's receipt fell from 1.4 s to 0.1 s on the maintained fork. Official Pi's median fell from 1.9 s to 0.1 s, but the size of that gain is inconclusive under the measured load: one run with the change took 2.3 s. Installs with their own SDK copy, a set `PI_PACKAGE_DIR` and detached children still load the selected Pi package directly.
+
+## [0.52.2] - 2026-10-29
+
+### Fixed
+
+- Avoid rereading historical shell records on every idle parking check while a live shell still blocks parking. Retain one publication path and revalidate its current record, owner token and process birth. Read the full inventory again when that witness disappears or dies. Stop and cold continuation keep their complete inventory checks. No records are pruned and live jobs are not interrupted.
+
 ## [0.52.1] - 2026-10-29
 
 ### Fixed

package/dist/agent/child-runtime.js

@@ -6,11 +6,11 @@ function guard(pi, directory, token) {
         if (event.toolName === "delegate" || event.toolName === "agent_runs") {
             return { block: true, reason: "Only a main session may delegate or control children." };
         }
+        if (event.toolName !== "bash" || typeof event.input.command !== "string") {
+            return;
+        }
         const owner = pi.getAllTools().find((tool) => tool.name === "bash")?.sourceInfo;
-        if (event.toolName === "bash" &&
-            typeof event.input.command === "string" &&
-            owner &&
-            (owner.source === "builtin" || localCwdOwner(owner))) {
+        if (owner && (owner.source === "builtin" || localCwdOwner(owner))) {
             // Preserve the selected local owner's cwd/env and leave remote/custom tools alone.
             const input = event.input;
             input.command = shellCommand(event.input.command, directory, token);

package/dist/agent/host.js

@@ -55,7 +55,20 @@ export function packageRoot() {
     }
     return path.dirname(manifest);
 }
+// Pi's resolution of this extension's SDK import: the running host in production installs,
+// possibly a package-local copy in development checkouts.
+let resolvedSDK;
+export function rememberSDK(sdk) {
+    resolvedSDK = sdk;
+}
 export async function loadSDK(root) {
+    // Reuse it only as the selected root. PI_PACKAGE_DIR replaces getPackageDir()'s own
+    // location, so only an unset override proves that identity.
+    if (resolvedSDK !== undefined &&
+        (process.env.PI_PACKAGE_DIR ?? "") === "" &&
+        fs.realpathSync(resolvedSDK.getPackageDir()) === fs.realpathSync(root)) {
+        return resolvedSDK;
+    }
     // Selected host SDK, not a second package-local runtime hidden behind Jiti aliases.
     // oxlint-disable-next-line typescript/no-unsafe-assignment
     const sdk = await import(__rewriteRelativeImportExtension(pathToFileURL(path.join(root, "dist/index.js")).href));

package/dist/agent/index.js

@@ -1,8 +1,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
+import * as loadedSDK from "@earendil-works/pi-coding-agent";
 import { actor, alive, ensureActor, ownIdentity, parkFailure, requestStop, signalProcess, stopChildren, } from "./process.js";
-import { isChild, errorText } from "./host.js";
+import { isChild, errorText, rememberSDK } from "./host.js";
 import { serveParked } from "./parking.js";
 import { resultSchema, attachmentSchema, admissionSchema, commandSchema, } from "./contracts.js";
 import { delegateSchema, runsSchema } from "./tool-schemas.js";
@@ -438,5 +439,7 @@ class AgentRuntime {
     }
 }
 export default function agents(pi) {
+    // Delegation, /agents and parked history then avoid importing a second SDK graph.
+    rememberSDK(loadedSDK);
     new AgentRuntime(pi).register();
 }

package/dist/agent/observe-card.js

@@ -137,7 +137,7 @@ export class Card {
         if (this.arguments !== value.args) {
             this.tool.updateArgs(projected(value.args) ?? {});
             this.arguments = value.args;
-            this.invalidate();
+            this.cache = undefined;
         }
     }
     updateTool(value, options, preparing) {
@@ -156,7 +156,7 @@ export class Card {
             this.phase = phase;
             this.value = source.result;
             this.ended = ended;
-            this.invalidate();
+            this.cache = undefined;
         }
     }
     preview(value, isError, partial) {
@@ -188,7 +188,7 @@ export class Card {
         this.status?.setText(message.ended ? "Awaiting journal publication" : "In progress");
         this.blocks = message.blocks.slice();
         this.ended = message.ended;
-        this.invalidate();
+        this.cache = undefined;
     }
     invalidate() {
         this.cache = undefined;

package/dist/agent/observe.js

@@ -176,6 +176,7 @@ class Observer {
         const scanning = this.update()
             .catch((error) => {
             this.error = plainText(errorText(error));
+            this.widget();
         })
             .finally(() => {
             if (this.scanning !== scanning) {
@@ -267,21 +268,22 @@ class Observer {
             this.widgetSignature = "";
             return;
         }
-        const signature = JSON.stringify([this.status(), rows.slice(0, 4), rows.length]);
+        const visible = rows.slice(0, 4);
+        const more = rows.length - visible.length;
+        const snapshot = { status: this.status(), rows: visible, more, error: this.error };
+        const signature = JSON.stringify(snapshot);
         if (signature === this.widgetSignature) {
             return;
         }
         this.widgetSignature = signature;
         if (this.widgetVisible) {
-            this.widgetRender?.();
+            this.widgetRender?.(snapshot);
             return;
         }
         this.widgetVisible = true;
         ctx.ui.setWidget(STATUS_KEY, (tui, theme) => {
-            this.widgetRender = () => {
-                tui.requestRender();
-            };
             const content = new Container();
+            let shown = snapshot;
             const open = (id) => {
                 if (ctx !== this.ctx) {
                     return;
@@ -290,29 +292,31 @@ class Observer {
                     ctx.ui.notify(errorText(error), "error");
                 });
             };
+            const build = () => {
+                content.clear();
+                content.addChild(actionText(theme.fg("accent", shown.status), () => open("")));
+                for (const row of shown.rows) {
+                    const glyph = row.live ? "●" : "○";
+                    const color = row.live ? "accent" : "warning";
+                    content.addChild(actionText(`${theme.fg(color, glyph)} ${theme.bold(row.name)} · ${row.activity ?? row.status}`, () => open(row.id)));
+                }
+                if (shown.more > 0) {
+                    content.addChild(actionText(theme.fg("dim", `+${shown.more} more · /agents`), () => open("")));
+                }
+                if (shown.error.length > 0) {
+                    content.addChild(new TruncatedText(theme.fg("warning", shown.error), 0, 0));
+                }
+            };
+            build();
+            this.widgetRender = (next) => {
+                shown = next;
+                build();
+                tui.requestRender();
+            };
             return {
-                render: (width) => {
-                    const strip = this.strip();
-                    const visible = strip.slice(0, 4);
-                    content.clear();
-                    content.addChild(actionText(theme.fg("accent", this.status()), () => open("")));
-                    for (const row of visible) {
-                        const glyph = row.live ? "●" : "○";
-                        const color = row.live ? "accent" : "warning";
-                        content.addChild(actionText(`${theme.fg(color, glyph)} ${theme.bold(row.name)} · ${row.activity ?? row.status}`, () => open(row.id)));
-                    }
-                    if (strip.length > visible.length) {
-                        content.addChild(actionText(theme.fg("dim", `+${strip.length - visible.length} more · /agents`), () => open("")));
-                    }
-                    if (this.error.length > 0) {
-                        content.addChild(new TruncatedText(theme.fg("warning", this.error), 0, 0));
-                    }
-                    return content.render(width);
-                },
+                render: (width) => content.render(width),
                 handleMouse: (event) => content.handleMouse(event),
-                invalidate: () => {
-                    // Render reads current rows, expansion and theme on every frame.
-                },
+                invalidate: build,
             };
         }, { placement: "aboveEditor" });
     }

package/dist/agent/parking.js

@@ -4,7 +4,7 @@ import * as path from "node:path";
 import { parkedSchema } from "./contracts.js";
 import { errorText, loadSDK } from "./host.js";
 import { conversation, latest, launchAt, list, read, runDirectory, write } from "./storage.js";
-import { alive, shells, wakeActor } from "./process.js";
+import { alive, shell, shells, wakeActor } from "./process.js";
 import { isHistoryRequest, PARK, PARKED_HISTORY, WAKE, } from "../shared/parking.js";
 import { nativePeerId } from "../pi-intercom/session-targets.js";
 function parkable(session) {
@@ -36,7 +36,21 @@ async function cut(pi, session, { quiet, errors, signal }) {
     return undefined;
 }
 const PARK_AFTER_MS = 5 * 60_000;
-const digest = (file) => createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+/** SHA-256 of every state byte through one reused chunk, like the native state reader. */
+function digest(file) {
+    const hash = createHash("sha256");
+    const fd = fs.openSync(file, "r");
+    try {
+        const chunk = Buffer.allocUnsafe(64 * 1024);
+        for (let count = fs.readSync(fd, chunk); count > 0; count = fs.readSync(fd, chunk)) {
+            hash.update(chunk.subarray(0, count));
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return hash.digest("hex");
+}
 /** Parked authority names this session and exactly the saved generation's state bytes. */
 function exact(restore, parked, state, launch) {
     if (parked.sessionId !== launch.sessionId ||
@@ -74,6 +88,7 @@ export class Parking {
     restored;
     since = 0;
     leaf;
+    shell;
     base;
     launch;
     token;
@@ -111,9 +126,7 @@ export class Parking {
     }
     /** True once this generation has exited its runtime with or without parked authority. */
     async park(runtime, actor) {
-        if (!actor.pi ||
-            !this.due(runtime.session, actor.busy) ||
-            shells(this.base, this.launch, this.token).some(alive)) {
+        if (!actor.pi || !this.due(runtime.session, actor.busy) || this.hasShell()) {
             return false;
         }
         const hold = await this.prepare(runtime, actor.pi, actor);
@@ -122,6 +135,13 @@ export class Parking {
         }
         return hold !== undefined;
     }
+    hasShell() {
+        const witness = this.shell === undefined ? undefined : shell(this.shell, this.token);
+        if (!witness || !alive(witness)) {
+            this.shell = shells(this.base, this.launch, this.token).find(alive)?.file;
+        }
+        return this.shell !== undefined;
+    }
     /** Final idle: no run, turn, journal change or viewer since the period began. */
     due(session, busy) {
         const leaf = session.sessionManager.getLeafId();

package/dist/agent/process.js

@@ -346,6 +346,13 @@ async function waitForExit(targets, timeout) {
         await delay(25);
     }
 }
+export function shell(file, token) {
+    const identity = published(file, read(file, processSchema));
+    if (identity && identity.token !== token) {
+        throw new Error("Foreign or missing native shell identity.");
+    }
+    return identity;
+}
 export function shells(base, launch, token) {
     const dir = path.join(conversation(base, launch), "shells", token);
     if (!fs.existsSync(dir)) {
@@ -356,11 +363,11 @@ export function shells(base, launch, token) {
         .filter((name) => name.endsWith(".json"))
         .map((name) => {
         const file = path.join(dir, name);
-        const identity = published(file, read(file, processSchema));
-        if (!identity || identity.token !== token) {
+        const identity = shell(file, token);
+        if (!identity) {
             throw new Error("Foreign or missing native shell identity.");
         }
-        return identity;
+        return Object.assign(identity, { file });
     });
 }
 function quote(value) {

package/dist/agent/runner.js

@@ -5,7 +5,7 @@ import { launchAt, missing, read, runDirectory, write } from "./storage.js";
 import { ownIdentity, ParentCheck, shells, signalProcess } from "./process.js";
 import { errorText, loadSDK } from "./host.js";
 import { Parking } from "./parking.js";
-import { childUsage } from "./usage.js";
+import { UsageIndex } from "./usage.js";
 import { initializeCwd } from "./cwd.js";
 import { childRuntime } from "./child-runtime.js";
 import { ActorObservation } from "./observation.js";
@@ -47,6 +47,8 @@ class Actor {
     started = new Set();
     // Actor-local validation metadata only; never retain command prompts or receipt authority.
     validated = new Map();
+    // Every run of this conversation shares one native journal; later runs read only its suffix.
+    accounting = new UsageIndex();
     session;
     observation;
     context;
@@ -97,7 +99,7 @@ class Actor {
     }
     usage(launch, baseline, terminal) {
         try {
-            return { contributions: childUsage(launch, baseline, terminal) };
+            return { contributions: this.accounting.read(launch, baseline, terminal) };
         }
         catch (error) {
             return {

package/dist/agent/usage.js

@@ -1,12 +1,13 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
-import { journalStamp } from "../shared/native-journal.js";
+import { journalStamp, nativeAppend } from "../shared/native-journal.js";
 import { nativeProjection } from "../shared/journal-projections.js";
 import { scanJournal } from "../shared/journal-frames.js";
 import { isRecord } from "../shared/unknown.js";
 import { Assert } from "./typebox.js";
 import { contributionsSchema, resultSchema, } from "./contracts.js";
 import { read, runDirectory, write } from "./storage.js";
+/** Billing evidence of one native entry. Missing required usage is an error only outside a baseline. */
 function billing(entry) {
     if (entry.checkpoint === true) {
         return;
@@ -16,11 +17,11 @@ function billing(entry) {
         (entry.type === "message" && !["assistant", "toolResult"].some((role) => role === message.role))) {
         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, launch) {
     if (message.role === "toolResult") {
@@ -34,56 +35,100 @@ function attribution(message, launch) {
         model: typeof model === "string" ? model : launch.model,
     };
 }
-export function childUsage(launch, baseline, terminal) {
-    const values = [];
-    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 }));
+function identify(header, launch) {
+    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, stat) {
+    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 {
+    prefix;
+    read(launch, baseline, terminal) {
+        const values = [];
+        const reachedTerminal = new Error("Native terminal boundary reached.");
+        const charge = (entry) => {
+            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.");
-                    }
-                    observed.header = true;
-                    return;
-                }
-                if (typeof value.id !== "string" || typeof value.type !== "string") {
-                    throw new Error("Missing native usage entry 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);
                 }
-                const message = baseline.has(value.id) ? undefined : billing(value);
-                if (message) {
-                    values.push({
-                        id: `${launch.sessionId}:${value.id}`,
-                        ...attribution(message, launch),
-                        usage: message.usage,
-                    });
+                for (const entry of prefix.entries) {
+                    charge(entry);
                 }
-                if (value.id === terminal) {
-                    observed.ended = true;
-                    throw reachedTerminal;
+                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.");
+                    }
+                    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;
                 }
-            }, { policy: "live", requireNewline: true });
-        }
-        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;
         }
-        if (journalStamp(fs.fstatSync(fd, { bigint: true })) !== stamp) {
-            throw new Error("Native usage journal changed while reading.");
+        finally {
+            fs.closeSync(fd);
         }
     }
-    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, baseline, terminal) {
+    return new UsageIndex().read(launch, baseline, terminal);
 }
 export function readCanonicalResult(base, launch) {
     const file = path.join(runDirectory(base, launch.id), "result.json");

package/dist/build-info.js

@@ -1 +1 @@
-export const EXTENSION_BUILD = Object.freeze({"version":"0.52.1","sha256":"d950f3bebb47cbe1dc09b2f7f9cc042535701b14cfe39cc518107a5626698bf4"});
+export const EXTENSION_BUILD = Object.freeze({"version":"0.52.3","sha256":"56e15afa9487e79b68bb9a924bf3cbb4a62a8492cf4fe882d0496263f87a1e33"});

package/dist/pi-intercom/bridge-mailbox.js

@@ -146,14 +146,25 @@ export class Mailbox {
     }
     ack(ids) {
         const acked = [];
-        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, limit) {

package/dist/pi-intercom/bridge-wake.js

@@ -110,22 +110,20 @@ export class WakeDeliveries {
     }
     pending(delivery) {
         let after = 0;
-        let next;
         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;
     }
     groups() {
         const groups = new Map();

package/dist/pi-intercom/inbound-journal.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { isContextRequest } from "./lifecycle.js";
 import { INBOUND_CHECKPOINT_TYPE, } from "./runtime-types.js";
-import { isInboundCheckpoint, publicationMetadata, requestedDelivery } from "./inbound-record.js";
+import { checkpointMessageId, isInboundCheckpoint, publicationMetadata, requestedDelivery, } from "./inbound-record.js";
 import { isReceiptQuery, } from "./types.js";
 import { inboundIdFromCustomMessage } from "./message-format.js";
 import { isRecord } from "./validation.js";
@@ -40,6 +40,7 @@ export class InboundJournal {
     receiptEntry(receipt, query, item) {
         if (item.type === "custom" &&
             item.customType === INBOUND_CHECKPOINT_TYPE &&
+            checkpointMessageId(item.data) === query.messageId &&
             isInboundCheckpoint(item.data) &&
             item.data.sessionId === query.rootSessionId) {
             return this.receiptCheckpoint(receipt, query, item.id, item.data);
@@ -50,7 +51,7 @@ export class InboundJournal {
     }
     receiptCheckpoint(receipt, query, entryId, data) {
         if ("entry" in data) {
-            if (receipt || data.entry.message.id !== query.messageId) {
+            if (receipt) {
                 return receipt;
             }
             const { from, message, stage, receivedAt } = data.entry;
@@ -74,7 +75,7 @@ export class InboundJournal {
                 discarded: false,
             };
         }
-        if (!receipt || data.messageId !== query.messageId) {
+        if (!receipt) {
             return receipt;
         }
         return {

package/dist/pi-intercom/inbound-record.js

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