@fitchmultz/pi-subagents 0.50.0 → 0.51.0

package/src/pi-intercom/connection.ts

@@ -4,21 +4,23 @@ import type { IntercomTransport } from "./transport.ts";
 import { spawnBrokerIfNeeded } from "./broker/spawn.ts";
 import type { IntercomConfig } from "./config.ts";
 import type { IntercomLifecycle } from "./lifecycle.ts";
-import type { LastMessageQuery, Message, SessionInfo } from "./types.ts";
+import type { Message, SessionInfo, ReceiptQuery, ReceiptResult } from "./types.ts";
+import type { NativeReadQuery } from "./broker/last.ts";
 import { readLastMessage } from "./last-message.ts";
 import { asError } from "./validation.ts";
+import { RecoveryError } from "./tool-results.ts";
 import { formatTargetOptions, resolveSessionTarget, nativePeerId } from "./session-targets.ts";
 
-type Lifecycle = Readonly<
-  Pick<
-    IntercomLifecycle,
-    "currentSessionId" | "generation" | "health" | "identity" | "live" | "registration" | "status"
-  >
->;
+type Lifecycle = Pick<
+  Readonly<IntercomLifecycle>,
+  "currentSessionId" | "generation" | "health" | "identity" | "live" | "registration" | "status"
+> &
+  Pick<Readonly<IntercomLifecycle>, "snapshot" | "transport">;
 
 interface ConnectionHooks {
   readonly restoring: () => Promise<void> | undefined;
   readonly pendingAsks: () => number;
+  readonly receipt: (query: ReceiptQuery) => ReceiptResult;
   readonly incoming: (ctx: ExtensionContext, from: SessionInfo, message: Message) => Promise<void>;
   readonly peerLeft: (id: string) => void;
   readonly disconnected: (error: Readonly<Error>) => void;
@@ -113,6 +115,7 @@ export class IntercomConnection {
       this.client.updatePresence({
         status: this.lifecycle.status(),
         ...this.lifecycle.health(this.hooks.pendingAsks()),
+        applicationGuard: this.lifecycle.snapshot().applicationGuard ?? null,
       });
     }
   }
@@ -124,7 +127,7 @@ export class IntercomConnection {
     this.client = next;
     next.on(
       "last_request",
-      (request: { readonly requestId: string; readonly query: LastMessageQuery }) => {
+      (request: { readonly requestId: string; readonly query: NativeReadQuery }) => {
         const ctx = this.lifecycle.live();
         const id = next.sessionId;
         if (this.client !== next || !ctx || id === null) {
@@ -132,6 +135,10 @@ export class IntercomConnection {
           return;
         }
         try {
+          if ("messageId" in request.query) {
+            next.respondLast(request.requestId, this.hooks.receipt(request.query));
+            return;
+          }
           next.respondLast(
             request.requestId,
             readLastMessage(
@@ -172,6 +179,7 @@ export class IntercomConnection {
       }
       this.hooks.disconnected(error);
       this.client = null;
+      this.lifecycle.transport(null);
       this.clearReconnect();
       this.scheduleReconnect();
     });
@@ -197,6 +205,7 @@ export class IntercomConnection {
         throw new Error("Intercom runtime no longer active");
       }
       this.client = next;
+      this.lifecycle.transport(next.sessionId, next.supportsGuardedDelivery);
       this.syncIdentity(ctx.sessionManager.getSessionId());
       this.attempt = 0;
       return next;
@@ -279,12 +288,14 @@ export async function resolveConnectedTarget(
     return resolution.target.id;
   }
   if (resolution.status === "ambiguous") {
-    throw new Error(
+    throw new RecoveryError(
+      "ambiguous_target",
       `Target "${name}" matches multiple sessions. Use one of these targets: ${formatTargetOptions(resolution.matches, sessions)}.`,
     );
   }
   if (resolution.status === "prefix_too_short") {
-    throw new Error(
+    throw new RecoveryError(
+      "ambiguous_target",
       `Target "${name}" is too short. Use the displayed target from intercom list, such as ${formatTargetOptions(resolution.matches, sessions)}.`,
     );
   }

package/src/pi-intercom/identity.ts

@@ -4,20 +4,23 @@ export interface IntercomLineage {
   readonly rootSessionId: string;
   readonly parentSessionId: string;
 }
+// Launches set both variables to the parent's exact native session ID. Absence means a main;
+// anything else is refused, never normalized into a different identity.
 export function readIntercomLineage(): IntercomLineage | undefined {
-  const rootSessionId = process.env.PI_INTERCOM_ROOT_SESSION_ID?.trim();
-  const parentSessionId = process.env.PI_INTERCOM_PARENT_SESSION_ID?.trim();
+  const rootSessionId = process.env.PI_INTERCOM_ROOT_SESSION_ID;
+  const parentSessionId = process.env.PI_INTERCOM_PARENT_SESSION_ID;
   if (rootSessionId === undefined && parentSessionId === undefined) {
     return;
   }
   if (
     rootSessionId === undefined ||
-    parentSessionId === undefined ||
     rootSessionId === "" ||
-    parentSessionId === "" ||
+    rootSessionId !== rootSessionId.trim() ||
     rootSessionId !== parentSessionId
   ) {
-    throw new Error("Intercom child launch requires matching root and parent native session IDs.");
+    throw new Error(
+      "Child launch requires identical, unpadded root and parent native session IDs.",
+    );
   }
   return { rootSessionId, parentSessionId };
 }

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { IntercomLifecycle } from "./lifecycle.ts";
 import type { InboundJournal } from "./inbound-journal.ts";
@@ -9,10 +8,9 @@ import type {
   PendingInboundMessage,
 } from "./runtime-types.ts";
 import { requestedDelivery } from "./inbound-record.ts";
-import { isRecord } from "./validation.ts";
 import { runCooperatively } from "../shared/cooperative.ts";
 
-type Lifecycle = Readonly<Pick<IntercomLifecycle, "generation" | "isIdle" | "live" | "toolCount">>;
+type Lifecycle = Pick<Readonly<IntercomLifecycle>, "generation" | "isIdle" | "live" | "toolCount">;
 type Journal = Readonly<
   Pick<
     InboundJournal,
@@ -121,6 +119,9 @@ export class InboundDeliveryOwner {
     flushDelivery: PendingInboundMessage["flushDelivery"] = "auto",
     delayMs = 200,
   ): void {
+    if (!this.journal.owns(entry)) {
+      return;
+    }
     this.journal.remember(entry, "queued", flushDelivery);
     this.hooks.syncStatus();
     this.schedule(delayMs);
@@ -153,10 +154,7 @@ export class InboundDeliveryOwner {
   private triggerIndex(entries: readonly PendingInboundMessage[]): number {
     const canTrigger = (entry: PendingInboundMessage) =>
       entry.flushDelivery !== "passive" && requestedDelivery(entry.message) !== "passive";
-    const ask = entries.findIndex(
-      (entry) => canTrigger(entry) && entry.message.expectsReply === true,
-    );
-    return ask === -1 ? entries.findIndex(canTrigger) : ask;
+    return entries.findLastIndex(canTrigger);
   }
   private *sendTriggerLast(
     entries: readonly PendingInboundMessage[],
@@ -170,14 +168,19 @@ export class InboundDeliveryOwner {
     }
     const index = this.triggerIndex(rest);
     const trigger = index === -1 ? undefined : rest.splice(index, 1)[0];
-    if (trigger && this.journal.get(trigger.message.id) === trigger) {
-      this.hooks.replies.queueTurnContext({ ...trigger, receivedAt: Date.now() });
+    const replyTarget = entries.find((entry) => entry.message.expectsReply === true) ?? trigger;
+    if (replyTarget && this.journal.get(replyTarget.message.id) === replyTarget) {
+      this.hooks.replies.queueTurnContext({ ...replyTarget, receivedAt: Date.now() });
     }
     for (const entry of rest) {
       if (!this.live(generation)) {
         return;
       }
-      this.send(entry, entry.flushDelivery === "steer" ? "steer" : "followUp", generation);
+      this.send(
+        entry,
+        requestedDelivery(entry.message) === "queue" ? "followUp" : "steer",
+        generation,
+      );
       yield;
     }
     if (trigger) {
@@ -202,7 +205,6 @@ export class InboundDeliveryOwner {
   private *sendSteers(
     entries: readonly PendingInboundMessage[],
     generation: number,
-    onDetach: (task: Promise<boolean>) => void,
   ): Generator<void, void> {
     for (const entry of entries) {
       if (!this.live(generation)) {
@@ -212,9 +214,6 @@ export class InboundDeliveryOwner {
         continue;
       }
       this.send(entry, "steer", generation);
-      if (requestedDelivery(entry.message) === "steer") {
-        onDetach(this.detach(entry, entry.message.expectsReply !== true));
-      }
       yield;
     }
   }
@@ -243,15 +242,7 @@ export class InboundDeliveryOwner {
       this.schedule(500);
       return;
     }
-    return this.runBatch(async () => {
-      const detachments: Promise<boolean>[] = [];
-      await runCooperatively(
-        this.sendSteers(steers, generation, (task) => {
-          detachments.push(task);
-        }),
-      );
-      await Promise.all(detachments);
-    }, generation);
+    return this.runBatch(() => runCooperatively(this.sendSteers(steers, generation)), generation);
   }
   private messageOptions(delivery: InboundDelivery): {
     readonly triggerTurn?: boolean;
@@ -297,57 +288,20 @@ export class InboundDeliveryOwner {
     }
   }
   private nativeMessage(entry: InboundMessageEntry): Parameters<ExtensionAPI["sendMessage"]>[0] {
-    const sender =
-      entry.from.name === undefined || entry.from.name === ""
-        ? entry.from.id.slice(0, 8)
-        : entry.from.name;
+    const sender = entry.from.name ?? entry.from.id.slice(0, 8);
     const command = entry.replyCommand ?? "";
     const reply = command === "" ? "" : `\n\nTo reply, use the intercom tool: ${command}`;
+    const hint = entry.message.replyHint;
+    const publication = hint
+      ? `\n\nTo publish a correlated reply, use ${hint.tool} with commandId ${hint.commandId}. This is not an intercom ask.`
+      : "";
     return {
       customType: "intercom_message",
-      content: `**📨 From ${sender}** (Native session cwd: ${entry.from.cwd})${reply}\n\n${entry.bodyText}`,
+      content: `**📨 From ${sender}** (Native session cwd: ${entry.from.cwd})${reply}${publication}\n\n${entry.bodyText}`,
       display: true,
       details: { ...entry, bodyText: entry.bodyText },
     };
   }
-  async detach(entry: InboundMessageEntry, attention = false): Promise<boolean> {
-    if (!attention && entry.message.expectsReply !== true) {
-      return false;
-    }
-    const requestId = randomUUID();
-    return await new Promise((resolve) => {
-      let settled = false;
-
-      const finish = (accepted: boolean) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        clearTimeout(timer);
-        unsubscribe();
-        resolve(accepted);
-      };
-      const timer = setTimeout(() => finish(false), 500);
-      timer.unref();
-      const unsubscribe = this.pi.events.on("pi-intercom:detach-response", (payload: unknown) => {
-        if (isRecord(payload) && payload.requestId === requestId) {
-          finish(payload.accepted === true);
-        }
-      });
-      try {
-        this.pi.events.emit("pi-intercom:detach-request", {
-          requestId,
-          ...(attention ? { reason: "attention" } : {}),
-        });
-        // Owned waits answer ordinary attention synchronously; an unanswered probe completes now.
-        if (attention) {
-          finish(false);
-        }
-      } catch {
-        finish(false);
-      }
-    });
-  }
   async redeliver(ctx: ExtensionContext, generation: number): Promise<void> {
     if (this.batchTask) {
       await this.batchTask;

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

@@ -1,5 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
-import type { IntercomLifecycle } from "./lifecycle.ts";
+import { createHash } from "node:crypto";
+import { isContextRequest, type IntercomLifecycle } from "./lifecycle.ts";
 import type { ReplyTracker } from "./reply-tracker.ts";
 import {
   INBOUND_CHECKPOINT_TYPE,
@@ -7,7 +8,13 @@ import {
   type InboundMessageEntry,
   type PendingInboundMessage,
 } from "./runtime-types.ts";
-import { isInboundCheckpoint } from "./inbound-record.ts";
+import { isInboundCheckpoint, publicationMetadata, requestedDelivery } from "./inbound-record.ts";
+import {
+  isReceiptQuery,
+  type NativeReceipt,
+  type ReceiptQuery,
+  type ReceiptResult,
+} from "./types.ts";
 import { inboundIdFromCustomMessage } from "./message-format.ts";
 import { isRecord } from "./validation.ts";
 
@@ -29,6 +36,85 @@ export class InboundJournal {
     this.pi = pi;
     this.lifecycle = lifecycle;
     this.replies = replies;
+    pi.events.on("pi-intercom:provenance-query", (request) => {
+      if (!isContextRequest(request)) {
+        return;
+      }
+      request.respond(
+        request.version === 1 && isReceiptQuery(request)
+          ? this.receipt(request)
+          : { error: "publication_unavailable" },
+      );
+    });
+  }
+  receipt(query: ReceiptQuery): ReceiptResult {
+    const ctx = this.lifecycle.live();
+    if (!ctx || ctx.sessionManager.getSessionId() !== query.rootSessionId) {
+      return { error: "publication_unavailable" };
+    }
+    let receipt: NativeReceipt | undefined;
+    for (const item of ctx.sessionManager.getEntries()) {
+      receipt = this.receiptEntry(receipt, query, item);
+    }
+    return receipt ? { receipt } : { error: "receipt_not_found" };
+  }
+  private receiptEntry(
+    receipt: NativeReceipt | undefined,
+    query: ReceiptQuery,
+    item: SessionEntry,
+  ): NativeReceipt | undefined {
+    if (
+      item.type === "custom" &&
+      item.customType === INBOUND_CHECKPOINT_TYPE &&
+      isInboundCheckpoint(item.data) &&
+      item.data.sessionId === query.rootSessionId
+    ) {
+      return this.receiptCheckpoint(receipt, query, item.id, item.data);
+    }
+    return receipt && inboundIdFromCustomMessage(item) === query.messageId
+      ? { ...receipt, placementEntryId: item.id }
+      : receipt;
+  }
+  private receiptCheckpoint(
+    receipt: NativeReceipt | undefined,
+    query: ReceiptQuery,
+    entryId: string,
+    data: InboundCheckpoint,
+  ): NativeReceipt | undefined {
+    if ("entry" in data) {
+      if (receipt || data.entry.message.id !== query.messageId) {
+        return receipt;
+      }
+      const { from, message, stage, receivedAt } = data.entry;
+      return {
+        version: 1,
+        rootSessionId: query.rootSessionId,
+        messageId: query.messageId,
+        sender: {
+          peerId: from.id,
+          rootSessionId: from.rootSessionId,
+          incarnation: from.incarnation,
+        },
+        textSha256: createHash("sha256").update(message.content.text, "utf8").digest("hex"),
+        delivery: requestedDelivery(message),
+        ...publicationMetadata(message),
+        checkpointEntryId: entryId,
+        receivedAt,
+        queued: stage === "queued",
+        nativeHandoff: stage === "native",
+        placementEntryId: null,
+        discarded: false,
+      };
+    }
+    if (!receipt || data.messageId !== query.messageId) {
+      return receipt;
+    }
+    return {
+      ...receipt,
+      queued: receipt.queued || data.stage === "queued",
+      nativeHandoff: receipt.nativeHandoff || data.stage === "native",
+      discarded: receipt.discarded || data.stage === "discarded",
+    };
   }
   peerLeft(id: string): void {
     for (const pending of this.replies.listPending()) {
@@ -39,7 +125,7 @@ export class InboundJournal {
     this.replies.expireSender(id);
     for (const pending of this.queued()) {
       if (pending.from.id === id && pending.message.expectsReply === true) {
-        this.pending.delete(pending.message.id);
+        this.consume(pending.message.id);
         this.checkpoint({ messageId: pending.message.id, stage: "discarded" });
       }
     }
@@ -57,7 +143,10 @@ export class InboundJournal {
     return this.pending.get(id);
   }
   owns(entry: InboundMessageEntry): boolean {
-    return !("stage" in entry) || this.pending.get(entry.message.id) === entry;
+    const id = entry.message.id;
+    return "stage" in entry
+      ? this.pending.get(id) === entry
+      : !this.pending.has(id) && !this.consumed.has(id);
   }
   checkpoint(update: InboundCheckpoint): void {
     const sessionId = this.lifecycle.currentSessionId;
@@ -96,7 +185,7 @@ export class InboundJournal {
           pending.from.id === entry.from.id &&
           pending.message.threadId === entry.message.threadId
         ) {
-          this.pending.delete(pending.message.id);
+          this.consume(pending.message.id);
           this.replies.markReplied(pending.message.id);
         }
       }
@@ -164,7 +253,7 @@ export class InboundJournal {
       return;
     }
     if (data.stage === "discarded") {
-      this.pending.delete(data.messageId);
+      this.consume(data.messageId);
       this.replies.markReplied(data.messageId);
       return;
     }
@@ -192,6 +281,13 @@ export class InboundJournal {
     if (item.customType === "intercom_sent") {
       this.restoreSent(item.data);
     }
+    if (
+      item.customType === "intercom_received" &&
+      isRecord(item.data) &&
+      typeof item.data.messageId === "string"
+    ) {
+      this.consume(item.data.messageId);
+    }
   }
   private restoreSent(data: unknown): void {
     if (
@@ -226,7 +322,7 @@ export class InboundJournal {
       (entry.type === "custom_message" &&
         ["intercom_message", "subagent-human-message"].includes(entry.customType)) ||
       (entry.type === "custom" &&
-        [INBOUND_CHECKPOINT_TYPE, "intercom_sent"].includes(entry.customType))
+        [INBOUND_CHECKPOINT_TYPE, "intercom_sent", "intercom_received"].includes(entry.customType))
     );
   }
   private recentEntries(ctx: ExtensionContext, fullScan: boolean): readonly SessionEntry[] {

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

@@ -1,16 +1,31 @@
-import { isMessage, isSessionRegistration, type Message } from "./types.ts";
+import { isMessage, isSessionRegistration, type Message, type MessageDelivery } from "./types.ts";
 import type {
   InboundCheckpoint,
   InboundMessageEntry,
   PendingInboundMessage,
-  RequestedDelivery,
 } from "./runtime-types.ts";
 import { finiteNumber, isRecord } from "./validation.ts";
-export function requestedDelivery(message: Message): RequestedDelivery {
+
+export function publicationMetadata(message: Message): Pick<Message, "guard" | "replyHint"> {
+  return {
+    guard: message.guard && {
+      rootSessionId: message.guard.rootSessionId,
+      peerId: message.guard.peerId,
+      incarnation: message.guard.incarnation,
+      applicationGuard: message.guard.applicationGuard,
+    },
+    replyHint: message.replyHint && {
+      tool: message.replyHint.tool,
+      commandId: message.replyHint.commandId,
+      commandFingerprint: message.replyHint.commandFingerprint,
+    },
+  };
+}
+export function requestedDelivery(message: Message): MessageDelivery {
   if (message.passive === true || message.delivery === "passive") {
     return "passive";
   }
-  return message.delivery ?? (message.expectsReply === true ? "auto" : "steer");
+  return message.delivery ?? "steer";
 }
 function isLocalJournalMessage(value: unknown): value is Message {
   if (!isRecord(value) || !isRecord(value.content)) {
@@ -32,6 +47,8 @@ function isLocalJournalMessage(value: unknown): value is Message {
       "queueMode",
       "threadId",
       "passive",
+      "guard",
+      "replyHint",
     ].every((key) => value[key] === undefined)
   );
 }

package/src/pi-intercom/inbound.ts

@@ -2,6 +2,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { IntercomConfig } from "./config.ts";
 import type { IntercomLifecycle } from "./lifecycle.ts";
 import type { InboundDeliveryOwner } from "./inbound-delivery.ts";
+import type { InboundJournal } from "./inbound-journal.ts";
 import type { ReplyTracker } from "./reply-tracker.ts";
 import type { ReplyWait } from "./reply-wait.ts";
 import type { IntercomConnection } from "./connection.ts";
@@ -11,17 +12,18 @@ import { requestedDelivery } from "./inbound-record.ts";
 import { formatAttachments } from "./message-format.ts";
 
 type Lifecycle = Readonly<
-  Pick<IntercomLifecycle, "generation" | "isIdle" | "live" | "markActivity">
+  Pick<IntercomLifecycle, "accepts" | "generation" | "isIdle" | "live" | "markActivity">
 >;
 type InboundDeliveryHandle = Readonly<
-  Pick<InboundDeliveryOwner, "batching" | "detach" | "queue" | "restoring" | "send">
+  Pick<InboundDeliveryOwner, "batching" | "queue" | "restoring" | "send">
 >;
 type ReplyWaitHandle = Readonly<Pick<ReplyWait, "receive">>;
-type Connection = Readonly<Pick<IntercomConnection, "active" | "syncStatus">>;
-type Replies = Readonly<Pick<ReplyTracker, "markReplied" | "recordIncomingMessage">>;
+type Connection = Readonly<Pick<IntercomConnection, "syncStatus">>;
+type Replies = Readonly<Pick<ReplyTracker, "recordIncomingMessage">>;
 
 interface InboundOwners {
   readonly delivery: InboundDeliveryHandle;
+  readonly journal: Readonly<Pick<InboundJournal, "consume" | "owns">>;
   readonly replies: Replies;
   readonly wait: ReplyWaitHandle;
   readonly connection: Connection;
@@ -71,33 +73,6 @@ export class IntercomInbound {
     }
     return true;
   }
-  private async busyNonInteractive(
-    entry: InboundMessageEntry,
-    ctx: ExtensionContext,
-    generation: number,
-  ): Promise<void> {
-    if (entry.message.expectsReply !== true) {
-      this.owners.delivery.send(entry, "steer", generation);
-      return;
-    }
-    const active = this.owners.connection.active;
-    if (entry.message.replyTo !== undefined || active?.isConnected() !== true) {
-      return;
-    }
-    try {
-      const result = await active.send(entry.from.id, {
-        text: "This agent is running in non-interactive mode and cannot respond to intercom messages while it is working. It will continue its current task and exit when done.",
-        replyTo: entry.message.id,
-      });
-      if (result.delivered && this.lifecycle.live(ctx, generation)) {
-        this.owners.replies.markReplied(entry.message.id);
-        this.lifecycle.markActivity();
-        this.owners.connection.syncStatus();
-      }
-    } catch {
-      /* Best-effort busy reply; the non-interactive task must continue either way. */
-    }
-  }
   private async admit(
     entry: InboundMessageEntry,
     live: ExtensionContext,
@@ -108,7 +83,7 @@ export class IntercomInbound {
       return;
     }
     if (!this.lifecycle.isIdle(active)) {
-      await this.busy(entry, active, generation);
+      this.busy(entry, generation);
       return;
     }
     if (this.lifecycle.live(live, generation)) {
@@ -119,30 +94,17 @@ export class IntercomInbound {
       );
     }
   }
-  private async busy(
-    entry: InboundMessageEntry,
-    ctx: ExtensionContext,
-    generation: number,
-  ): Promise<void> {
+  private busy(entry: InboundMessageEntry, generation: number): void {
     const delivery = requestedDelivery(entry.message);
     if (delivery === "steer") {
       this.owners.delivery.send(entry, "steer", generation);
-      await this.owners.delivery.detach(entry, entry.message.expectsReply !== true);
       return;
     }
-    if (delivery === "queue" && entry.message.queueMode !== "replace") {
+    if (delivery === "queue") {
       this.owners.delivery.send(entry, "followUp", generation);
       return;
     }
-    if (delivery === "passive") {
-      this.owners.delivery.queue(entry, "passive");
-      return;
-    }
-    if (!ctx.hasUI) {
-      await this.busyNonInteractive(entry, ctx, generation);
-      return;
-    }
-    this.owners.delivery.queue(entry, "auto");
+    this.owners.delivery.queue(entry, "passive");
   }
   async receive(ctx: ExtensionContext, from: SessionInfo, input: Message): Promise<void> {
     const generation = this.lifecycle.generation;
@@ -154,10 +116,18 @@ export class IntercomInbound {
     if (!live) {
       return;
     }
+    if (input.guard && !this.lifecycle.accepts(input.guard)) {
+      return;
+    }
     // Peer metadata never grants user authority.
     const message = input.human ? { ...input, human: undefined } : input;
+    const entry = this.entry(from, message);
+    if (!this.owners.journal.owns(entry)) {
+      return;
+    }
     if (
       this.owners.wait.receive(from, message, () => {
+        this.owners.journal.consume(message.id);
         this.lifecycle.markActivity();
         this.owners.connection.syncStatus();
       })
@@ -167,7 +137,6 @@ export class IntercomInbound {
     this.owners.replies.recordIncomingMessage(from, message);
     this.lifecycle.markActivity();
     this.owners.connection.syncStatus();
-    const entry = this.entry(from, message);
     await this.admit(entry, live, generation);
   }
 }

package/src/pi-intercom/index.ts

@@ -23,6 +23,7 @@ export default function piIntercomExtension(pi: ExtensionAPI): void {
   const connection = new IntercomConnection(lifecycle, config, {
     restoring: () => delivery.restoring,
     pendingAsks: () => replies.listPending().length,
+    receipt: (query) => journal.receipt(query),
     incoming: (ctx, from, message) => inbound.receive(ctx, from, message),
     peerLeft: (id) => {
       wait.peerDisconnected(id);
@@ -38,8 +39,10 @@ export default function piIntercomExtension(pi: ExtensionAPI): void {
     replies,
     syncStatus: () => connection.syncStatus(),
   });
+  lifecycle.registerContextEvents(() => connection.syncStatus());
   const inbound = new IntercomInbound(lifecycle, config, {
     delivery,
+    journal,
     replies,
     wait,
     connection,