@fitchmultz/pi-subagents 0.49.1 → 0.51.0

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

@@ -1,22 +1,22 @@
 import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
-import type { IntercomLifecycle } from "./lifecycle.ts";
-import { isDurableSupervisorQuestion, type ReplyTracker } from "./reply-tracker.ts";
+import { createHash } from "node:crypto";
+import { isContextRequest, type IntercomLifecycle } from "./lifecycle.ts";
+import type { ReplyTracker } from "./reply-tracker.ts";
 import {
   INBOUND_CHECKPOINT_TYPE,
   type InboundCheckpoint,
   type InboundMessageEntry,
   type PendingInboundMessage,
-  type SubagentCompletion,
 } from "./runtime-types.ts";
+import { isInboundCheckpoint, publicationMetadata, requestedDelivery } from "./inbound-record.ts";
 import {
-  isInboundCheckpoint,
-  isInboundEntry,
-  needsIntercom,
-  isReplaceableProgress,
-} from "./inbound-record.ts";
+  isReceiptQuery,
+  type NativeReceipt,
+  type ReceiptQuery,
+  type ReceiptResult,
+} from "./types.ts";
 import { inboundIdFromCustomMessage } from "./message-format.ts";
 import { isRecord } from "./validation.ts";
-import { activateTools } from "../shared/lazy-tools.ts";
 
 /** Owns durable delivery stages, receipts and completion tombstones. */
 type Lifecycle = Readonly<Pick<IntercomLifecycle, "currentSessionId" | "live">>;
@@ -28,7 +28,6 @@ export class InboundJournal {
   private readonly pending = new Map<string, PendingInboundMessage>();
   private readonly native = new Set<string>();
   private readonly consumed = new Set<string>();
-  private readonly completed = new Map<string, SubagentCompletion["children"][number]>();
   private reconciledLeaf: string | null = null;
   private readonly pi: ExtensionAPI;
   private readonly lifecycle: Lifecycle;
@@ -37,25 +36,96 @@ 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()) {
-      if (
-        pending.from.id === id &&
-        !isDurableSupervisorQuestion(pending.message) &&
-        this.pending.get(pending.message.id)?.stage !== "queued"
-      ) {
+      if (pending.from.id === id && this.pending.get(pending.message.id)?.stage !== "queued") {
         this.retire(pending.message.id);
       }
     }
     this.replies.expireSender(id);
     for (const pending of this.queued()) {
-      if (
-        pending.from.id === id &&
-        pending.message.expectsReply === true &&
-        !isDurableSupervisorQuestion(pending.message)
-      ) {
-        this.pending.delete(pending.message.id);
+      if (pending.from.id === id && pending.message.expectsReply === true) {
+        this.consume(pending.message.id);
         this.checkpoint({ messageId: pending.message.id, stage: "discarded" });
       }
     }
@@ -72,11 +142,11 @@ export class InboundJournal {
   get(id: string): PendingInboundMessage | undefined {
     return this.pending.get(id);
   }
-  hasSeen(id: string): boolean {
-    return this.consumed.has(id) || this.pending.has(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;
@@ -88,9 +158,6 @@ export class InboundJournal {
     this.replies.markReplied(id);
     this.checkpoint({ messageId: id, stage });
   }
-  remove(id: string): boolean {
-    return this.pending.delete(id);
-  }
   consume(id: string): void {
     this.consumed.add(id);
     this.pending.delete(id);
@@ -103,7 +170,6 @@ export class InboundJournal {
     this.pending.clear();
     this.native.clear();
     this.consumed.clear();
-    this.completed.clear();
     this.reconciledLeaf = null;
   }
   keep(entry: PendingInboundMessage): void {
@@ -119,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);
         }
       }
@@ -167,58 +233,11 @@ export class InboundJournal {
       (entry) => entry.stage === "native" && !this.native.has(entry.message.id),
     );
   }
-  rememberCompletion(entry: InboundMessageEntry): void {
-    const completion = entry.subagentCompletion;
-    if (
-      entry.from.id !== "subagent-result" ||
-      !completion ||
-      completion.ownerSessionId !== this.lifecycle.currentSessionId
-    ) {
-      return;
-    }
-    for (const child of completion.children) {
-      const thread = `subagent-progress:${completion.runId}:${child.agent}:${child.index}`;
-      if (child.status === "detached") {
-        this.completed.delete(thread);
-      } else {
-        this.completed.set(thread, child);
-      }
-    }
-    for (const pending of this.queued()) {
-      this.discardObsolete(pending);
-    }
-  }
-  discardObsolete(entry: InboundMessageEntry): boolean {
-    const message = entry.message;
-    if (!isReplaceableProgress(message)) {
-      return false;
-    }
-    const child = this.completed.get(message.threadId ?? "");
-    if (
-      !child ||
-      (entry.from.id !== child.intercomTarget && entry.from.name !== child.intercomTarget)
-    ) {
-      return false;
-    }
-    if (!this.pending.has(message.id)) {
-      this.remember(entry, "queued", "auto");
-    }
-    this.pending.delete(message.id);
-    this.replies.markReplied(message.id);
-    this.checkpoint({ messageId: message.id, stage: "discarded" });
-    return true;
-  }
-  reconcileTools(): void {
-    if (this.entries().some(needsIntercom) || this.replies.listPending().some(needsIntercom)) {
-      activateTools(this.pi, ["intercom"]);
-    }
-  }
   private restoreCheckpoint(data: unknown): void {
     if (!isInboundCheckpoint(data) || data.sessionId !== this.lifecycle.currentSessionId) {
       return;
     }
     if ("entry" in data) {
-      this.rememberCompletion(data.entry);
       this.replies.recordIncomingMessage(
         data.entry.from,
         data.entry.message,
@@ -234,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;
     }
@@ -245,9 +264,6 @@ export class InboundJournal {
   }
   private restoreEntry(item: SessionEntry): void {
     if (item.type === "custom_message") {
-      if (isInboundEntry(item.details)) {
-        this.rememberCompletion(item.details);
-      }
       const id = inboundIdFromCustomMessage(item);
       if (id !== undefined) {
         this.consumed.add(id);
@@ -265,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 (
@@ -278,7 +301,6 @@ export class InboundJournal {
   }
   *restore(ctx: ExtensionContext, generation: number): Generator<void, void> {
     this.consumed.clear();
-    this.completed.clear();
     const leaf = ctx.sessionManager.getLeafId();
     for (const metadata of ctx.sessionManager.getEntries()) {
       yield;
@@ -294,16 +316,13 @@ export class InboundJournal {
       return;
     }
     this.reconciledLeaf = leaf;
-    for (const entry of this.pending.values()) {
-      this.discardObsolete(entry);
-    }
   }
   private isRelevant(entry: SessionEntry): boolean {
     return (
       (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,74 +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,
-  SubagentCompletion,
-  RequestedDelivery,
 } from "./runtime-types.ts";
-import { finiteNumber, isRecord, isUnknownArray } from "./validation.ts";
-export function requestedDelivery(message: Message): RequestedDelivery {
+import { finiteNumber, isRecord } from "./validation.ts";
+
+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");
-}
-export function isReplaceableProgress(message: Message): boolean {
-  return (
-    message.delivery === "queue" &&
-    message.queueMode === "replace" &&
-    (message.threadId ?? "") !== "" &&
-    message.expectsReply !== true &&
-    message.replyTo === undefined
-  );
-}
-export function needsIntercom(entry: Pick<InboundMessageEntry, "from" | "message">): boolean {
-  return (
-    entry.message.human === undefined &&
-    requestedDelivery(entry.message) !== "passive" &&
-    entry.from.id !== "subagent-result" &&
-    entry.from.id !== "subagent-control"
-  );
-}
-export function isBlockingSupervisorMessage(entry: InboundMessageEntry): boolean {
-  if (entry.message.expectsReply !== true) {
-    return false;
-  }
-  const text = entry.bodyText.trimStart();
-  return (
-    text.startsWith("Subagent needs a supervisor decision.") ||
-    text.startsWith("Subagent requests a structured supervisor interview.")
-  );
-}
-export function isCompletedChild(value: unknown): value is SubagentCompletion["children"][number] {
-  if (!isRecord(value)) {
-    return false;
-  }
-  return (
-    typeof value.agent === "string" &&
-    typeof value.index === "number" &&
-    Number.isSafeInteger(value.index) &&
-    value.index >= 0 &&
-    typeof value.intercomTarget === "string" &&
-    value.intercomTarget.length > 0 &&
-    typeof value.status === "string" &&
-    ["completed", "failed", "blocked", "paused", "timed-out", "detached"].includes(value.status)
-  );
-}
-function isCompletion(
-  value: unknown,
-): value is SubagentCompletion & { readonly ownerSessionId: string } {
-  if (!isRecord(value)) {
-    return false;
-  }
-  return (
-    typeof value.runId === "string" &&
-    typeof value.status === "string" &&
-    typeof value.ownerSessionId === "string" &&
-    (value.completionId === undefined || typeof value.completionId === "string") &&
-    isUnknownArray(value.children) &&
-    value.children.every(isCompletedChild)
-  );
+  return message.delivery ?? "steer";
 }
 function isLocalJournalMessage(value: unknown): value is Message {
   if (!isRecord(value) || !isRecord(value.content)) {
@@ -90,6 +47,8 @@ function isLocalJournalMessage(value: unknown): value is Message {
       "queueMode",
       "threadId",
       "passive",
+      "guard",
+      "replyHint",
     ].every((key) => value[key] === undefined)
   );
 }
@@ -107,8 +66,7 @@ export function isInboundEntry(value: unknown): value is InboundMessageEntry {
     isSessionRegistration(value.from) &&
     isJournalMessage(value.message, sender) &&
     typeof value.bodyText === "string" &&
-    (value.replyCommand === undefined || typeof value.replyCommand === "string") &&
-    (value.subagentCompletion === undefined || isCompletion(value.subagentCompletion))
+    (value.replyCommand === undefined || typeof value.replyCommand === "string")
   );
 }
 function isPendingInbound(value: unknown): value is PendingInboundMessage {

package/src/pi-intercom/inbound.ts

@@ -1,39 +1,32 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { IntercomConfig } from "./config.ts";
 import type { IntercomLifecycle } from "./lifecycle.ts";
-import type { InboundJournal } from "./inbound-journal.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";
-import type { IntercomTopics } from "./topics.ts";
-import type { ChildOrchestratorMetadata, InboundMessageEntry } from "./runtime-types.ts";
+import type { InboundMessageEntry } from "./runtime-types.ts";
 import type { Message, SessionInfo } from "./types.ts";
-import { requestedDelivery, isBlockingSupervisorMessage } from "./inbound-record.ts";
+import { requestedDelivery } from "./inbound-record.ts";
 import { formatAttachments } from "./message-format.ts";
-import { readQuestionOwner } from "../runs/shared/supervisor-questions.ts";
-import { nativePeerId } from "./session-targets.ts";
 
 type Lifecycle = Readonly<
-  Pick<IntercomLifecycle, "generation" | "isIdle" | "live" | "markActivity">
+  Pick<IntercomLifecycle, "accepts" | "generation" | "isIdle" | "live" | "markActivity">
 >;
-type Journal = Readonly<Pick<InboundJournal, "discardObsolete" | "get" | "remember">>;
 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 TopicOwner = Readonly<Pick<IntercomTopics, "receive">>;
-type Replies = Readonly<Pick<ReplyTracker, "markReplied" | "recordIncomingMessage">>;
+type Connection = Readonly<Pick<IntercomConnection, "syncStatus">>;
+type Replies = Readonly<Pick<ReplyTracker, "recordIncomingMessage">>;
 
 interface InboundOwners {
-  readonly journal: Journal;
   readonly delivery: InboundDeliveryHandle;
+  readonly journal: Readonly<Pick<InboundJournal, "consume" | "owns">>;
   readonly replies: Replies;
   readonly wait: ReplyWaitHandle;
   readonly connection: Connection;
-  readonly topics: TopicOwner;
-  readonly child: ChildOrchestratorMetadata | null;
 }
 /** Validates origin and chooses admission; state/resources remain in their owners. */
 export class IntercomInbound {
@@ -45,31 +38,6 @@ export class IntercomInbound {
     this.config = config;
     this.owners = owners;
   }
-  private ownedHuman(from: SessionInfo, message: Message): boolean {
-    const origin = message.human;
-    const child = this.owners.child;
-    if (!origin || !child || origin.runId !== child.runId || origin.index !== Number(child.index)) {
-      return false;
-    }
-    const owner = readQuestionOwner(origin.runId);
-    return (
-      owner?.sessionId === origin.ownerSessionId && from.id === nativePeerId(origin.ownerSessionId)
-    );
-  }
-  private normalize(from: SessionInfo, input: Message): Message {
-    const message = input.topic
-      ? {
-          ...input,
-          content: {
-            ...input.content,
-            text: `Topic ${input.topic.topic} · ${input.topic.event}\n${input.content.text}`,
-          },
-        }
-      : input;
-    return message.human && !this.ownedHuman(from, message)
-      ? { ...message, human: undefined }
-      : message;
-  }
   private entry(from: SessionInfo, message: Message): InboundMessageEntry {
     const attachments = message.content.attachments;
     return {
@@ -105,57 +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 prepareBusy(
-    entry: InboundMessageEntry,
-    ctx: ExtensionContext,
-    generation: number,
-  ): Promise<boolean> {
-    if (!isBlockingSupervisorMessage(entry)) {
-      return true;
-    }
-    const willDeliver = ctx.hasUI || requestedDelivery(entry.message) !== "auto";
-    if (willDeliver) {
-      this.owners.journal.remember(entry, "queued", "auto");
-    }
-    await this.owners.delivery.detach(entry);
-    return (
-      this.lifecycle.live(ctx, generation) !== null &&
-      (!willDeliver || this.owners.journal.get(entry.message.id)?.stage === "queued")
-    );
-  }
-  private async steerBusy(entry: InboundMessageEntry, generation: number): Promise<void> {
-    this.owners.delivery.send(entry, "steer", generation);
-    if (!isBlockingSupervisorMessage(entry)) {
-      await this.owners.delivery.detach(entry, true);
-    }
-  }
   private async admit(
     entry: InboundMessageEntry,
     live: ExtensionContext,
@@ -166,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)) {
@@ -177,32 +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 (!(await this.prepareBusy(entry, ctx, generation))) {
-      return;
-    }
     if (delivery === "steer") {
-      await this.steerBusy(entry, generation);
+      this.owners.delivery.send(entry, "steer", generation);
       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;
@@ -211,12 +113,21 @@ export class IntercomInbound {
       await restore;
     }
     const live = this.lifecycle.live(ctx, generation);
-    if (!live || this.owners.topics.receive(from, input)) {
+    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;
     }
-    const message = this.normalize(from, input);
     if (
       this.owners.wait.receive(from, message, () => {
+        this.owners.journal.consume(message.id);
         this.lifecycle.markActivity();
         this.owners.connection.syncStatus();
       })
@@ -226,10 +137,6 @@ export class IntercomInbound {
     this.owners.replies.recordIncomingMessage(from, message);
     this.lifecycle.markActivity();
     this.owners.connection.syncStatus();
-    const entry = this.entry(from, message);
-    if (this.owners.journal.discardObsolete(entry)) {
-      return;
-    }
     await this.admit(entry, live, generation);
   }
 }