@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/pi-intercom/identity.js

@@ -1,42 +1,17 @@
-function environmentText(name) {
-    return process.env[name]?.trim() ?? "";
-}
-export function readChildOrchestratorMetadata() {
-    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;
+export function readIntercomLineage() {
+    const rootSessionId = process.env.PI_INTERCOM_ROOT_SESSION_ID?.trim();
+    const parentSessionId = process.env.PI_INTERCOM_PARENT_SESSION_ID?.trim();
+    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, metadata, message) {
-    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 ||
+        parentSessionId === undefined ||
+        rootSessionId === "" ||
+        parentSessionId === "" ||
+        rootSessionId !== parentSessionId) {
+        throw new Error("Intercom child launch requires matching root and parent native session IDs.");
+    }
+    return { rootSessionId, parentSessionId };
 }
 export function resolveIntercomPresenceName(sessionName, sessionId) {
     const name = sessionName?.trim();
@@ -49,10 +24,5 @@ export function resolveIntercomPresenceName(sessionName, sessionId) {
     return `subagent-chat-${normalized.slice(0, 8)}`;
 }
 export function buildPresenceIdentity(pi, sessionId) {
-    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/dist/pi-intercom/inbound-delivery.js

@@ -1,9 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { needsIntercom, requestedDelivery, isBlockingSupervisorMessage } from "./inbound-record.js";
+import { requestedDelivery } from "./inbound-record.js";
 import { isRecord } from "./validation.js";
-import { activateTools } from "../shared/lazy-tools.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 +66,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()) {
@@ -173,10 +159,8 @@ 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)));
+            if (requestedDelivery(entry.message) === "steer") {
+                onDetach(this.detach(entry, entry.message.expectsReply !== true));
             }
             yield;
         }
@@ -218,10 +202,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,9 +226,6 @@ export class InboundDeliveryOwner {
                 message: entry.message,
                 receivedAt: Date.now(),
             });
-            if (needsIntercom(entry)) {
-                activateTools(this.pi, ["intercom"]);
-            }
         }
     }
     nativeMessage(entry) {
@@ -253,18 +234,15 @@ export class InboundDeliveryOwner {
             : entry.from.name;
         const command = entry.replyCommand ?? "";
         const reply = command === "" ? "" : `\n\nTo reply, use the intercom tool: ${command}`;
-        const human = entry.message.human !== undefined;
         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}\n\n${entry.bodyText}`,
             display: true,
             details: { ...entry, bodyText: entry.bodyText },
         };
     }
     async detach(entry, attention = false) {
-        if (!attention && !isBlockingSupervisorMessage(entry)) {
+        if (!attention && entry.message.expectsReply !== true) {
             return false;
         }
         const requestId = randomUUID();
@@ -314,43 +292,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,11 @@
-import { isDurableSupervisorQuestion } from "./reply-tracker.js";
 import { INBOUND_CHECKPOINT_TYPE, } from "./runtime-types.js";
-import { isInboundCheckpoint, isInboundEntry, needsIntercom, isReplaceableProgress, } from "./inbound-record.js";
+import { isInboundCheckpoint } from "./inbound-record.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;
@@ -20,17 +17,13 @@ export class InboundJournal {
     }
     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)) {
+            if (pending.from.id === id && pending.message.expectsReply === true) {
                 this.pending.delete(pending.message.id);
                 this.checkpoint({ messageId: pending.message.id, stage: "discarded" });
             }
@@ -48,9 +41,6 @@ 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;
     }
@@ -64,9 +54,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 +66,6 @@ export class InboundJournal {
         this.pending.clear();
         this.native.clear();
         this.consumed.clear();
-        this.completed.clear();
         this.reconciledLeaf = null;
     }
     keep(entry) {
@@ -133,55 +119,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 });
@@ -204,9 +146,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);
@@ -235,7 +174,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,9 +189,6 @@ export class InboundJournal {
             return;
         }
         this.reconciledLeaf = leaf;
-        for (const entry of this.pending.values()) {
-            this.discardObsolete(entry);
-        }
     }
     isRelevant(entry) {
         return ((entry.type === "custom_message" &&

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

@@ -1,56 +1,11 @@
 import { isMessage, isSessionRegistration } from "./types.js";
-import { finiteNumber, isRecord, isUnknownArray } from "./validation.js";
+import { finiteNumber, isRecord } from "./validation.js";
 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));
-}
 function isLocalJournalMessage(value) {
     if (!isRecord(value) || !isRecord(value.content)) {
         return false;
@@ -85,8 +40,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)) {

package/dist/pi-intercom/inbound.js

@@ -1,7 +1,5 @@
-import { requestedDelivery, isBlockingSupervisorMessage } from "./inbound-record.js";
+import { requestedDelivery } from "./inbound-record.js";
 import { formatAttachments } from "./message-format.js";
-import { readQuestionOwner } from "../runs/shared/supervisor-questions.js";
-import { nativePeerId } from "./session-targets.js";
 /** Validates origin and chooses admission; state/resources remain in their owners. */
 export class IntercomInbound {
     lifecycle;
@@ -12,29 +10,6 @@ export class IntercomInbound {
         this.config = config;
         this.owners = owners;
     }
-    ownedHuman(from, message) {
-        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));
-    }
-    normalize(from, input) {
-        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;
-    }
     entry(from, message) {
         const attachments = message.content.attachments;
         return {
@@ -94,24 +69,6 @@ export class IntercomInbound {
             /* Best-effort busy reply; the non-interactive task must continue either way. */
         }
     }
-    async prepareBusy(entry, ctx, generation) {
-        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"));
-    }
-    async steerBusy(entry, generation) {
-        this.owners.delivery.send(entry, "steer", generation);
-        if (!isBlockingSupervisorMessage(entry)) {
-            await this.owners.delivery.detach(entry, true);
-        }
-    }
     async admit(entry, live, generation) {
         const active = this.lifecycle.live(live, generation);
         if (!active || this.queueAdmission(entry, active)) {
@@ -127,11 +84,9 @@ export class IntercomInbound {
     }
     async busy(entry, ctx, generation) {
         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);
+            await this.owners.delivery.detach(entry, entry.message.expectsReply !== true);
             return;
         }
         if (delivery === "queue" && entry.message.queueMode !== "replace") {
@@ -155,10 +110,11 @@ export class IntercomInbound {
             await restore;
         }
         const live = this.lifecycle.live(ctx, generation);
-        if (!live || this.owners.topics.receive(from, input)) {
+        if (!live) {
             return;
         }
-        const message = this.normalize(from, input);
+        // Peer metadata never grants user authority.
+        const message = input.human ? { ...input, human: undefined } : input;
         if (this.owners.wait.receive(from, message, () => {
             this.lifecycle.markActivity();
             this.owners.connection.syncStatus();
@@ -169,9 +125,6 @@ export class IntercomInbound {
         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);
     }
 }

package/dist/pi-intercom/index.js

@@ -1,81 +1,48 @@
 import { loadConfig } from "./config.js";
-import { readChildOrchestratorMetadata } from "./identity.js";
+import { readIntercomLineage } from "./identity.js";
 import { ReplyTracker } from "./reply-tracker.js";
-import { IntercomTopics } from "./topics.js";
 import { IntercomLifecycle } from "./lifecycle.js";
 import { InboundJournal } from "./inbound-journal.js";
 import { InboundDeliveryOwner } from "./inbound-delivery.js";
 import { ReplyWait } from "./reply-wait.js";
 import { IntercomConnection } from "./connection.js";
 import { IntercomInbound } from "./inbound.js";
-import { NativeControls } from "./native-control.js";
 import { IntercomOutbound } from "./outbound.js";
 import { IntercomInspection } from "./inspection.js";
-import { IntercomTopicActions } from "./topic-actions.js";
-import { IntercomSupervisor } from "./supervisor.js";
 import { IntercomTools } from "./tools.js";
-import { IntercomOverlay } from "./ui/overlay.js";
-import { SubagentEventBridges } from "./subagent-events.js";
 import { IntercomSessionEvents } from "./session-events.js";
-import { PeerAwareness } from "./peer-awareness.js";
-import { registerMessageRenderers } from "./ui/message-renderers.js";
 import { registerIntercomTools } from "./tool-registration.js";
 export default function piIntercomExtension(pi) {
     const config = loadConfig();
-    const child = readChildOrchestratorMetadata();
-    const lifecycle = new IntercomLifecycle(pi, config);
+    const lifecycle = new IntercomLifecycle(pi, config, readIntercomLineage());
     const replies = new ReplyTracker(config.askTimeoutMs);
-    const topics = new IntercomTopics(pi, () => lifecycle.live());
     const journal = new InboundJournal(pi, lifecycle, replies);
-    const wait = new ReplyWait(pi, lifecycle, config.askTimeoutMs);
-    // Hooks are invoked only after construction, at a native session or event boundary.
-    const connection = new IntercomConnection(lifecycle, config, topics, {
+    const wait = new ReplyWait(lifecycle, config.askTimeoutMs);
+    const connection = new IntercomConnection(lifecycle, config, {
         restoring: () => delivery.restoring,
         pendingAsks: () => replies.listPending().length,
-        incoming: async (ctx, from, message) => {
-            if (!(await controls.receive(ctx, from, message))) {
-                await inbound.receive(ctx, from, message);
-            }
-        },
+        incoming: (ctx, from, message) => inbound.receive(ctx, from, message),
         peerLeft: (id) => {
             wait.peerDisconnected(id);
             journal.peerLeft(id);
         },
         disconnected: (error) => {
-            if (!wait.durable) {
-                wait.reject(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
-            }
+            wait.reject(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
         },
     });
-    const controls = new NativeControls(lifecycle, connection);
     const delivery = new InboundDeliveryOwner(pi, lifecycle, journal, {
         replies,
         syncStatus: () => connection.syncStatus(),
     });
     const inbound = new IntercomInbound(lifecycle, config, {
-        journal,
         delivery,
         replies,
         wait,
         connection,
-        topics,
-        child,
     });
     const outbound = new IntercomOutbound({ pi, lifecycle, connection, replies, wait }, config);
     const inspection = new IntercomInspection(journal, replies);
-    const topicActions = new IntercomTopicActions({ pi, lifecycle, connection, topics });
-    const tools = new IntercomTools({ connection, outbound, topicActions, topics, inspection });
-    const supervisor = child
-        ? new IntercomSupervisor({ pi, lifecycle, connection, wait }, child)
-        : null;
-    const overlay = new IntercomOverlay({ pi, lifecycle, connection, topics });
-    const bridges = new SubagentEventBridges(lifecycle, connection, delivery, {
-        pi,
-        journal,
-        open: (ctx, scope) => overlay.open(ctx, scope),
-    });
-    const awareness = child ? null : new PeerAwareness(connection, lifecycle);
-    bridges.start();
+    const tools = new IntercomTools({ connection, outbound, inspection });
     new IntercomSessionEvents(pi, {
         lifecycle,
         connection,
@@ -83,12 +50,6 @@ export default function piIntercomExtension(pi) {
         journal,
         replies,
         wait,
-        topics,
-        bridges,
-        supervisor,
-        awareness,
     }).register();
-    registerMessageRenderers(pi);
-    registerIntercomTools(pi, tools, supervisor);
-    overlay.register(config.shortcut);
+    registerIntercomTools(pi, tools);
 }

package/dist/pi-intercom/last-message.js

@@ -0,0 +1,58 @@
+function validPage(offset, limit) {
+    return (Number.isSafeInteger(offset) &&
+        offset >= 0 &&
+        Number.isSafeInteger(limit) &&
+        limit >= 1 &&
+        limit <= 16384);
+}
+function completedResponse(manager, entryId) {
+    let id = manager.getLeafId();
+    while (id !== null) {
+        const entry = manager.getEntry(id);
+        if (!entry) {
+            throw new Error("Native session history is unavailable.");
+        }
+        if (entry.type === "message" &&
+            entry.message.role === "assistant" &&
+            (entry.message.stopReason === "stop" || entry.message.stopReason === "length") &&
+            (entryId === undefined || entry.id === entryId)) {
+            return {
+                id: entry.id,
+                text: entry.message.content
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("\n"),
+            };
+        }
+        id = entry.parentId;
+    }
+    return;
+}
+/** Reads finalized native history only; no model invocation or synthesized response. */
+export function readLastMessage(manager, session, query) {
+    const offset = query.offset ?? 0;
+    const limit = query.limit ?? 16384;
+    if (!validPage(offset, limit)) {
+        return {
+            error: "Invalid last response page: offset must be non-negative and limit must be 1–16384.",
+        };
+    }
+    const response = completedResponse(manager, query.entryId);
+    if (!response) {
+        return query.entryId !== undefined
+            ? { error: "Requested completed assistant response is not on the active session branch." }
+            : { session, entryId: null, text: "", offset: 0, totalLength: 0 };
+    }
+    if (offset > response.text.length) {
+        return { error: "Last response offset exceeds its length." };
+    }
+    const end = Math.min(response.text.length, offset + limit);
+    return {
+        session,
+        entryId: response.id,
+        text: response.text.slice(offset, end),
+        offset,
+        totalLength: response.text.length,
+        ...(end < response.text.length ? { nextOffset: end } : {}),
+    };
+}