@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/pi-intercom/connection.ts

@@ -4,23 +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 { IntercomTopics } from "./topics.ts";
-import type { Message, SessionInfo, TopicChange } from "./types.ts";
-import { asError, errorMessage } from "./validation.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";
 
-export type ConnectionReason = "startup" | "background" | "tool" | "overlay" | "peer-awareness";
-type Lifecycle = Readonly<
-  Pick<
-    IntercomLifecycle,
-    "currentSessionId" | "generation" | "health" | "identity" | "live" | "registration" | "status"
-  >
->;
-type TopicOwner = Readonly<Pick<IntercomTopics, "disconnected" | "presence" | "refresh">>;
+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;
@@ -33,41 +33,23 @@ export class IntercomConnection {
   private connecting: Promise<IntercomTransport> | null = null;
   private connectingGeneration: number | null = null;
   private attempt = 0;
-  private syncError: string | undefined;
   private readonly lifecycle: Lifecycle;
   private readonly config: IntercomConfig;
-  private readonly topics: TopicOwner;
   private readonly hooks: ConnectionHooks;
-  constructor(
-    lifecycle: Lifecycle,
-    config: IntercomConfig,
-    topics: TopicOwner,
-    hooks: ConnectionHooks,
-  ) {
+  constructor(lifecycle: Lifecycle, config: IntercomConfig, hooks: ConnectionHooks) {
     this.lifecycle = lifecycle;
     this.config = config;
-    this.topics = topics;
     this.hooks = hooks;
   }
   get active(): IntercomTransport | null {
     return this.client;
   }
-  get topicSyncError(): string | undefined {
-    return this.syncError;
-  }
-  get isConnecting(): boolean {
-    return this.startupTimer !== null || this.connecting !== null;
-  }
-  clearTopicSyncError(): void {
-    this.syncError = undefined;
-  }
   start(ctx: ExtensionContext, generation: number): void {
     this.attempt = 0;
-    this.syncError = undefined;
     this.clearTimers();
     this.scheduleStartup(ctx, generation);
   }
-  clearStartup(): void {
+  private clearStartup(): void {
     if (this.startupTimer) {
       clearTimeout(this.startupTimer);
       this.startupTimer = null;
@@ -83,14 +65,14 @@ export class IntercomConnection {
     this.clearStartup();
     this.clearReconnect();
   }
-  scheduleStartup(ctx: ExtensionContext, generation: number): void {
+  private scheduleStartup(ctx: ExtensionContext, generation: number): void {
     this.clearStartup();
     this.startupTimer = setTimeout(() => {
       this.startupTimer = null;
       if (!this.lifecycle.live(ctx, generation)) {
         return;
       }
-      this.ensure("startup").catch(() => {
+      this.ensure().catch(() => {
         if (!this.lifecycle.live(ctx, generation)) {
           return;
         }
@@ -113,7 +95,7 @@ export class IntercomConnection {
         return;
       }
       this.attempt += 1;
-      this.ensure("background").catch(() => {
+      this.ensure().catch(() => {
         /* ensure owns the next retry after settlement. */
       });
     }, delay);
@@ -133,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,
       });
     }
   }
@@ -142,6 +125,39 @@ export class IntercomConnection {
       listTimeoutMs: this.config.listTimeoutMs,
     });
     this.client = next;
+    next.on(
+      "last_request",
+      (request: { readonly requestId: string; readonly query: NativeReadQuery }) => {
+        const ctx = this.lifecycle.live();
+        const id = next.sessionId;
+        if (this.client !== next || !ctx || id === null) {
+          next.respondLast(request.requestId, { error: "Intercom runtime no longer active" });
+          return;
+        }
+        try {
+          if ("messageId" in request.query) {
+            next.respondLast(request.requestId, this.hooks.receipt(request.query));
+            return;
+          }
+          next.respondLast(
+            request.requestId,
+            readLastMessage(
+              ctx.sessionManager,
+              {
+                id,
+                ...this.lifecycle.identity(ctx.sessionManager.getSessionId()),
+                cwd: ctx.cwd,
+                model: ctx.model?.id ?? "unknown",
+                status: this.lifecycle.status(),
+              },
+              request.query,
+            ),
+          );
+        } catch (error) {
+          next.respondLast(request.requestId, { error: asError(error).message });
+        }
+      },
+    );
     next.on("message", (from: SessionInfo, message: Message) => {
       const ctx = this.lifecycle.live();
       if (this.client !== next || !ctx) {
@@ -155,7 +171,6 @@ export class IntercomConnection {
       if (this.client !== next) {
         return;
       }
-      this.topics.disconnected(id);
       this.hooks.peerLeft(id);
     });
     next.on("disconnected", (error: Readonly<Error>) => {
@@ -164,7 +179,7 @@ export class IntercomConnection {
       }
       this.hooks.disconnected(error);
       this.client = null;
-      this.topics.disconnected();
+      this.lifecycle.transport(null);
       this.clearReconnect();
       this.scheduleReconnect();
     });
@@ -173,63 +188,14 @@ export class IntercomConnection {
     });
     return next;
   }
-  private async restoreTopics(active: IntercomTransport): Promise<string | undefined> {
-    const changes: TopicChange[] = [
-      ...[...this.topics.presence().topics].map((topic): TopicChange => ({
-        action: "restore",
-        topic,
-      })),
-      ...[...this.topics.presence().subscriptions].map((subscription): TopicChange => ({
-        action: "restore",
-        subscription,
-      })),
-    ];
-    let failure: string | undefined;
-    for (const change of changes) {
-      try {
-        // Restore order preserves publication/subscription admission and bounded transport pressure.
-        // oxlint-disable-next-line no-await-in-loop
-        await active.updateTopics(change);
-      } catch (error) {
-        if (!active.isConnected()) {
-          throw error;
-        }
-        failure ??= errorMessage(error);
-      }
-    }
-    return failure;
-  }
-  private async synchronizeTopics(
-    next: IntercomTransport,
-    ctx: ExtensionContext,
-    generation: number,
-  ): Promise<void> {
-    if (!next.supportsTopics) {
-      this.topics.disconnected();
-      return;
-    }
-    const failure = await this.restoreTopics(next);
-    const sessions = await next.listSessions();
-    if (!this.lifecycle.live(ctx, generation)) {
-      return;
-    }
-    this.syncError = failure;
-    this.topics.refresh(sessions);
-    if (failure !== undefined && failure !== "" && next.sessionId !== null) {
-      this.topics.disconnected(next.sessionId);
-    }
-  }
   private async connect(
-    reason: ConnectionReason,
     ctx: ExtensionContext,
     generation: number,
     sessionId: string,
   ): Promise<IntercomTransport> {
     const next = this.createClient();
     try {
-      if (reason !== "peer-awareness") {
-        await spawnBrokerIfNeeded(this.config.brokerCommand, this.config.brokerArgs);
-      }
+      await spawnBrokerIfNeeded(this.config.brokerCommand, this.config.brokerArgs);
       await next.connect(
         await this.lifecycle.registration(this.hooks.pendingAsks()),
         nativePeerId(sessionId),
@@ -239,22 +205,22 @@ 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;
-      await this.synchronizeTopics(next, ctx, generation);
       return next;
     } catch (error) {
       if (this.client === next) {
         this.client = null;
       }
-      // A failed topic snapshot can leave a registered socket alive; the attempt still owns it.
+      // A failed registration still owns its socket.
       await next.disconnect().catch((cleanupError: unknown) => {
         console.error("Intercom failed connection cleanup:", cleanupError);
       });
       throw asError(error);
     }
   }
-  async ensure(reason: ConnectionReason): Promise<IntercomTransport> {
+  async ensure(): Promise<IntercomTransport> {
     const generation = this.lifecycle.generation;
     const restoring = this.hooks.restoring();
     if (restoring) {
@@ -276,7 +242,7 @@ export class IntercomConnection {
     }
     this.clearReconnect();
     // Publish ownership before registration, which can synchronously invoke subscribers.
-    const attempt = Promise.resolve().then(() => this.connect(reason, ctx, generation, sessionId));
+    const attempt = Promise.resolve().then(() => this.connect(ctx, generation, sessionId));
     this.connecting = attempt;
     this.connectingGeneration = generation;
     return await this.finishAttempt(attempt, ctx, generation);
@@ -322,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

@@ -1,49 +1,30 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { ChildOrchestratorMetadata } from "./runtime-types.ts";
-function environmentText(name: string): string {
-  return process.env[name]?.trim() ?? "";
+
+export interface IntercomLineage {
+  readonly rootSessionId: string;
+  readonly parentSessionId: string;
 }
-export function readChildOrchestratorMetadata(): ChildOrchestratorMetadata | null {
-  const orchestratorTarget = environmentText("PI_SUBAGENT_ORCHESTRATOR_TARGET");
-  const runId = environmentText("PI_SUBAGENT_RUN_ID");
-  const agent = environmentText("PI_SUBAGENT_CHILD_AGENT");
-  const index = environmentText("PI_SUBAGENT_CHILD_INDEX");
-  if ([orchestratorTarget, runId, agent, index].includes("")) {
-    return null;
+// 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;
+  const parentSessionId = process.env.PI_INTERCOM_PARENT_SESSION_ID;
+  if (rootSessionId === undefined && parentSessionId === undefined) {
+    return;
   }
-  const sessionName = environmentText("PI_SUBAGENT_INTERCOM_SESSION_NAME");
-  return {
-    orchestratorTarget,
-    runId,
-    agent,
-    index,
-    ...(sessionName !== "" ? { sessionName } : {}),
-  };
-}
-export function formatChildOrchestratorMessage(
-  kind: "ask" | "update" | "interview",
-  metadata: ChildOrchestratorMetadata,
-  message: string,
-): string {
-  const headings = {
-    ask: "Subagent needs a supervisor decision.",
-    interview: "Subagent requests a structured supervisor interview.",
-    update: "Subagent progress update.",
-  };
-  return [
-    headings[kind],
-    `Run: ${metadata.runId}`,
-    `Agent: ${metadata.agent}`,
-    `Child index: ${metadata.index}`,
-    metadata.sessionName !== undefined && metadata.sessionName !== ""
-      ? `Child intercom target: ${metadata.sessionName}`
-      : undefined,
-    "",
-    message,
-  ]
-    .filter((line) => line !== undefined)
-    .join("\n");
+  if (
+    rootSessionId === undefined ||
+    rootSessionId === "" ||
+    rootSessionId !== rootSessionId.trim() ||
+    rootSessionId !== parentSessionId
+  ) {
+    throw new Error(
+      "Child launch requires identical, unpadded root and parent native session IDs.",
+    );
+  }
+  return { rootSessionId, parentSessionId };
 }
+
 export function resolveIntercomPresenceName(
   sessionName: string | undefined,
   sessionId: string,
@@ -61,11 +42,5 @@ export function buildPresenceIdentity(
   pi: ExtensionAPI,
   sessionId: string,
 ): { readonly name: string } {
-  const name = process.env.PI_SUBAGENT_INTERCOM_SESSION_NAME?.trim();
-  return {
-    name:
-      name !== undefined && name !== ""
-        ? name
-        : resolveIntercomPresenceName(pi.getSessionName(), sessionId),
-  };
+  return { name: resolveIntercomPresenceName(pi.getSessionName(), sessionId) };
 }

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";
@@ -7,44 +6,29 @@ import type {
   InboundDelivery,
   InboundMessageEntry,
   PendingInboundMessage,
-  SubagentCompletion,
 } from "./runtime-types.ts";
-import { needsIntercom, requestedDelivery, isBlockingSupervisorMessage } from "./inbound-record.ts";
-import { isRecord } from "./validation.ts";
-import { activateTools } from "../shared/lazy-tools.ts";
+import { requestedDelivery } from "./inbound-record.ts";
 import { runCooperatively } from "../shared/cooperative.ts";
-import { listSupervisorQuestionsAsync } from "../runs/shared/supervisor-questions.ts";
 
-type Lifecycle = Readonly<
-  Pick<
-    IntercomLifecycle,
-    "currentSessionId" | "generation" | "isIdle" | "live" | "runtimeStarted" | "toolCount"
-  >
->;
+type Lifecycle = Pick<Readonly<IntercomLifecycle>, "generation" | "isIdle" | "live" | "toolCount">;
 type Journal = Readonly<
   Pick<
     InboundJournal,
-    | "discardObsolete"
     | "freshRuntime"
     | "get"
-    | "hasSeen"
     | "markNative"
     | "owns"
     | "queued"
     | "reconcileConsumed"
-    | "reconcileTools"
     | "reload"
     | "remember"
-    | "rememberCompletion"
     | "reset"
     | "restore"
     | "size"
     | "unconsumed"
   >
 >;
-type Replies = Readonly<
-  Pick<ReplyTracker, "hasReplyContext" | "markReplied" | "queueTurnContext" | "reset">
->;
+type Replies = Readonly<Pick<ReplyTracker, "queueTurnContext" | "reset">>;
 
 interface DeliveryHooks {
   readonly replies: Replies;
@@ -114,19 +98,7 @@ export class InboundDeliveryOwner {
     if (!this.lifecycle.live(ctx, generation)) {
       return;
     }
-    if (this.hooks.replies.hasReplyContext) {
-      const questions = await listSupervisorQuestionsAsync(ctx.sessionManager.getSessionId());
-      if (!this.lifecycle.live(ctx, generation)) {
-        return;
-      }
-      for (const question of questions) {
-        if (question.answer || question.state === "cancelled") {
-          this.hooks.replies.markReplied(question.questionId);
-        }
-      }
-    }
     this.journal.reconcileConsumed(ctx);
-    this.journal.reconcileTools();
   }
   schedule(delayMs = 200): void {
     if (!this.lifecycle.live()) {
@@ -147,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);
@@ -179,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[],
@@ -196,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) {
@@ -228,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)) {
@@ -238,13 +214,6 @@ export class InboundDeliveryOwner {
         continue;
       }
       this.send(entry, "steer", generation);
-      if (
-        requestedDelivery(entry.message) === "steer" &&
-        entry.from.id !== "subagent-result" &&
-        entry.from.id !== "subagent-control"
-      ) {
-        onDetach(this.detach(entry, !isBlockingSupervisorMessage(entry)));
-      }
       yield;
     }
   }
@@ -273,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;
@@ -300,10 +261,10 @@ export class InboundDeliveryOwner {
     delivery: InboundDelivery,
     generation = this.lifecycle.generation,
   ): void {
-    if (this.lifecycle.runtimeStarted && !this.live(generation)) {
+    if (!this.live(generation)) {
       return;
     }
-    if (!this.journal.owns(entry) || this.journal.discardObsolete(entry)) {
+    if (!this.journal.owns(entry)) {
       return;
     }
     this.trackNative(entry, delivery);
@@ -324,66 +285,23 @@ export class InboundDeliveryOwner {
         message: entry.message,
         receivedAt: Date.now(),
       });
-      if (needsIntercom(entry)) {
-        activateTools(this.pi, ["intercom"]);
-      }
     }
   }
   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 human = entry.message.human !== undefined;
+    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: human ? "subagent-human-message" : "intercom_message",
-      content: human
-        ? `Direct user message to this agent (human origin, not peer advice). Respond in this conversation; the user sees it directly. Do not ask the parent to relay or approve it.\n\n${entry.bodyText}`
-        : `**📨 From ${sender}** (Native session cwd: ${entry.from.cwd})${reply}\n\n${entry.bodyText}`,
+      customType: "intercom_message",
+      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 && !isBlockingSupervisorMessage(entry)) {
-      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;
@@ -400,51 +318,4 @@ export class InboundDeliveryOwner {
       generation,
     );
   }
-  private localEntry(
-    sender: "subagent-control" | "subagent-result",
-    status: string,
-    data: { readonly text: string; readonly completion?: SubagentCompletion },
-  ): InboundMessageEntry {
-    const { text, completion } = data;
-    const sessionId = this.lifecycle.currentSessionId;
-    const completionId = completion?.completionId;
-    const entry: InboundMessageEntry = {
-      from: {
-        id: sender,
-        name: sender,
-        cwd: this.lifecycle.live()?.cwd ?? process.cwd(),
-        model: sender,
-        status,
-      },
-      message: {
-        id:
-          completionId !== undefined && completionId !== ""
-            ? `subagent-completion:${completionId}`
-            : randomUUID(),
-        timestamp: Date.now(),
-        content: { text },
-      },
-      bodyText: text,
-      ...(sender === "subagent-result" && completion && sessionId !== null
-        ? { subagentCompletion: { ...completion, ownerSessionId: sessionId } }
-        : {}),
-    };
-    return entry;
-  }
-  local(
-    sender: "subagent-control" | "subagent-result",
-    status: string,
-    data: { readonly text: string; readonly completion?: SubagentCompletion },
-  ): void {
-    const entry = this.localEntry(sender, status, data);
-    if (this.journal.hasSeen(entry.message.id)) {
-      return;
-    }
-    this.journal.rememberCompletion(entry);
-    if (this.batching) {
-      this.queue(entry, "steer");
-    } else {
-      this.send(entry, "trigger");
-    }
-  }
 }