@fitchmultz/pi-subagents 0.49.1 → 0.51.0

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

@@ -1,9 +1,5 @@
-import { randomUUID } from "node:crypto";
-import { needsIntercom, requestedDelivery, isBlockingSupervisorMessage } from "./inbound-record.js";
-import { isRecord } from "./validation.js";
-import { activateTools } from "../shared/lazy-tools.js";
+import { requestedDelivery } from "./inbound-record.js";
 import { runCooperatively } from "../shared/cooperative.js";
-import { listSupervisorQuestionsAsync } from "../runs/shared/supervisor-questions.js";
 /** Owns cooperative inbound batches, restoration and the flush timer. */
 export class InboundDeliveryOwner {
     timer = null;
@@ -68,19 +64,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) {
         if (!this.lifecycle.live()) {
@@ -97,6 +81,9 @@ export class InboundDeliveryOwner {
         this.timer.unref();
     }
     queue(entry, flushDelivery = "auto", delayMs = 200) {
+        if (!this.journal.owns(entry)) {
+            return;
+        }
         this.journal.remember(entry, "queued", flushDelivery);
         this.hooks.syncStatus();
         this.schedule(delayMs);
@@ -126,8 +113,7 @@ export class InboundDeliveryOwner {
     }
     triggerIndex(entries) {
         const canTrigger = (entry) => 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);
     }
     *sendTriggerLast(entries, generation) {
         const passives = entries.filter((entry) => entry.flushDelivery === "passive");
@@ -138,14 +124,15 @@ 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) {
@@ -164,7 +151,7 @@ export class InboundDeliveryOwner {
     live(generation) {
         return this.lifecycle.generation === generation && this.lifecycle.live() !== null;
     }
-    *sendSteers(entries, generation, onDetach) {
+    *sendSteers(entries, generation) {
         for (const entry of entries) {
             if (!this.live(generation)) {
                 return;
@@ -173,11 +160,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;
         }
     }
@@ -200,13 +182,7 @@ export class InboundDeliveryOwner {
             this.schedule(500);
             return;
         }
-        return this.runBatch(async () => {
-            const detachments = [];
-            await runCooperatively(this.sendSteers(steers, generation, (task) => {
-                detachments.push(task);
-            }));
-            await Promise.all(detachments);
-        }, generation);
+        return this.runBatch(() => runCooperatively(this.sendSteers(steers, generation)), generation);
     }
     messageOptions(delivery) {
         if (delivery === "trigger") {
@@ -218,10 +194,10 @@ export class InboundDeliveryOwner {
         return { triggerTurn: false };
     }
     send(entry, delivery, generation = this.lifecycle.generation) {
-        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);
@@ -242,65 +218,23 @@ export class InboundDeliveryOwner {
                 message: entry.message,
                 receivedAt: Date.now(),
             });
-            if (needsIntercom(entry)) {
-                activateTools(this.pi, ["intercom"]);
-            }
         }
     }
     nativeMessage(entry) {
-        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, attention = false) {
-        if (!attention && !isBlockingSupervisorMessage(entry)) {
-            return false;
-        }
-        const requestId = randomUUID();
-        return await new Promise((resolve) => {
-            let settled = false;
-            const finish = (accepted) => {
-                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) => {
-                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, generation) {
         if (this.batchTask) {
             await this.batchTask;
@@ -314,43 +248,4 @@ export class InboundDeliveryOwner {
         }
         await this.runBatch(() => runCooperatively(this.sendTriggerLast(this.journal.unconsumed(), generation)), generation);
     }
-    localEntry(sender, status, data) {
-        const { text, completion } = data;
-        const sessionId = this.lifecycle.currentSessionId;
-        const completionId = completion?.completionId;
-        const entry = {
-            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, status, data) {
-        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");
-        }
-    }
 }

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

@@ -1,14 +1,14 @@
-import { isDurableSupervisorQuestion } from "./reply-tracker.js";
+import { createHash } from "node:crypto";
+import { isContextRequest } from "./lifecycle.js";
 import { INBOUND_CHECKPOINT_TYPE, } from "./runtime-types.js";
-import { isInboundCheckpoint, isInboundEntry, needsIntercom, isReplaceableProgress, } from "./inbound-record.js";
+import { isInboundCheckpoint, publicationMetadata, requestedDelivery } from "./inbound-record.js";
+import { isReceiptQuery, } from "./types.js";
 import { inboundIdFromCustomMessage } from "./message-format.js";
 import { isRecord } from "./validation.js";
-import { activateTools } from "../shared/lazy-tools.js";
 export class InboundJournal {
     pending = new Map();
     native = new Set();
     consumed = new Set();
-    completed = new Map();
     reconciledLeaf = null;
     pi;
     lifecycle;
@@ -17,21 +17,83 @@ 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) {
+        const ctx = this.lifecycle.live();
+        if (!ctx || ctx.sessionManager.getSessionId() !== query.rootSessionId) {
+            return { error: "publication_unavailable" };
+        }
+        let receipt;
+        for (const item of ctx.sessionManager.getEntries()) {
+            receipt = this.receiptEntry(receipt, query, item);
+        }
+        return receipt ? { receipt } : { error: "receipt_not_found" };
+    }
+    receiptEntry(receipt, query, item) {
+        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;
+    }
+    receiptCheckpoint(receipt, query, entryId, data) {
+        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) {
         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" });
             }
         }
@@ -48,11 +110,11 @@ export class InboundJournal {
     get(id) {
         return this.pending.get(id);
     }
-    hasSeen(id) {
-        return this.consumed.has(id) || this.pending.has(id);
-    }
     owns(entry) {
-        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) {
         const sessionId = this.lifecycle.currentSessionId;
@@ -64,9 +126,6 @@ export class InboundJournal {
         this.replies.markReplied(id);
         this.checkpoint({ messageId: id, stage });
     }
-    remove(id) {
-        return this.pending.delete(id);
-    }
     consume(id) {
         this.consumed.add(id);
         this.pending.delete(id);
@@ -79,7 +138,6 @@ export class InboundJournal {
         this.pending.clear();
         this.native.clear();
         this.consumed.clear();
-        this.completed.clear();
         this.reconciledLeaf = null;
     }
     keep(entry) {
@@ -91,7 +149,7 @@ export class InboundJournal {
                 if (pending.stage === "queued" &&
                     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);
                 }
             }
@@ -133,55 +191,11 @@ export class InboundJournal {
     unconsumed() {
         return this.entries().filter((entry) => entry.stage === "native" && !this.native.has(entry.message.id));
     }
-    rememberCompletion(entry) {
-        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) {
-        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() {
-        if (this.entries().some(needsIntercom) || this.replies.listPending().some(needsIntercom)) {
-            activateTools(this.pi, ["intercom"]);
-        }
-    }
     restoreCheckpoint(data) {
         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, data.entry.receivedAt);
             if (!this.consumed.has(data.entry.message.id)) {
                 this.keep({ ...data.entry });
@@ -193,7 +207,7 @@ export class InboundJournal {
             return;
         }
         if (data.stage === "discarded") {
-            this.pending.delete(data.messageId);
+            this.consume(data.messageId);
             this.replies.markReplied(data.messageId);
             return;
         }
@@ -204,9 +218,6 @@ export class InboundJournal {
     }
     restoreEntry(item) {
         if (item.type === "custom_message") {
-            if (isInboundEntry(item.details)) {
-                this.rememberCompletion(item.details);
-            }
             const id = inboundIdFromCustomMessage(item);
             if (id !== undefined) {
                 this.consumed.add(id);
@@ -224,6 +235,11 @@ 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);
+        }
     }
     restoreSent(data) {
         if (isRecord(data) &&
@@ -235,7 +251,6 @@ export class InboundJournal {
     }
     *restore(ctx, generation) {
         this.consumed.clear();
-        this.completed.clear();
         const leaf = ctx.sessionManager.getLeafId();
         for (const metadata of ctx.sessionManager.getEntries()) {
             yield;
@@ -251,15 +266,12 @@ export class InboundJournal {
             return;
         }
         this.reconciledLeaf = leaf;
-        for (const entry of this.pending.values()) {
-            this.discardObsolete(entry);
-        }
     }
     isRelevant(entry) {
         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)));
     }
     recentEntries(ctx, fullScan) {
         if (fullScan) {

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

@@ -1,55 +1,25 @@
 import { isMessage, isSessionRegistration } from "./types.js";
-import { finiteNumber, isRecord, isUnknownArray } from "./validation.js";
+import { finiteNumber, isRecord } from "./validation.js";
+export function publicationMetadata(message) {
+    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) {
     if (message.passive === true || message.delivery === "passive") {
         return "passive";
     }
-    return message.delivery ?? (message.expectsReply === true ? "auto" : "steer");
-}
-export function isReplaceableProgress(message) {
-    return (message.delivery === "queue" &&
-        message.queueMode === "replace" &&
-        (message.threadId ?? "") !== "" &&
-        message.expectsReply !== true &&
-        message.replyTo === undefined);
-}
-export function needsIntercom(entry) {
-    return (entry.message.human === undefined &&
-        requestedDelivery(entry.message) !== "passive" &&
-        entry.from.id !== "subagent-result" &&
-        entry.from.id !== "subagent-control");
-}
-export function isBlockingSupervisorMessage(entry) {
-    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) {
-    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) {
-    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) {
     if (!isRecord(value) || !isRecord(value.content)) {
@@ -70,6 +40,8 @@ function isLocalJournalMessage(value) {
             "queueMode",
             "threadId",
             "passive",
+            "guard",
+            "replyHint",
         ].every((key) => value[key] === undefined));
 }
 function isJournalMessage(value, sender) {
@@ -85,8 +57,7 @@ export function isInboundEntry(value) {
     return (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) {
     if (!isRecord(value)) {