pi-extended-teams 2.3.3 → 2.4.0

package/extensions/tools/agent-communication-tools.ts

@@ -122,7 +122,7 @@ export function createAgentCommunicationTools(options: AgentCommunicationToolsOp
     {
       name: "read_inbox",
       label: "Read Inbox",
-      description: "Read this agent's inbox in the current Pi session.",
+      description: "Read this agent's inbox with current sender message-admission status. Status is a snapshot, not proof of process liveness; do not send to unavailable senders.",
       parameters: Type.Object({
         unread_only: Type.Optional(Type.Boolean({ default: true })),
         mark_as_read: Type.Optional(Type.Boolean({ default: true, description: "Set false to peek without marking messages read." })),
@@ -131,7 +131,7 @@ export function createAgentCommunicationTools(options: AgentCommunicationToolsOp
         const teamName = requireCurrentSession(options);
         const markAsRead = params.mark_as_read !== false;
         const unreadOnly = params.unread_only !== false;
-        const msgs = await messaging.readInbox(teamName, options.agentName, unreadOnly, markAsRead);
+        const msgs = await messaging.readInboxWithSenderStatus(teamName, options.agentName, unreadOnly, markAsRead);
         const lifecycleRunId = options.getLifecycleRunId();
         // Do not fail after read flags are persisted; telemetry is best-effort.
         if (markAsRead && lifecycleRunId) {

package/extensions/tools/coordination-tools.ts

@@ -333,7 +333,7 @@ export function registerCoordinationTools(pi: any, options: CoordinationToolsOpt
   pi.registerTool({
     name: "read_inbox",
     label: "Read Inbox",
-    description: "Read messages from the current Pi session inbox. Defaults to this agent's inbox.",
+    description: "Read messages from the current Pi session inbox with current sender message-admission status. Defaults to your inbox. Status is a snapshot, not proof of process liveness; do not send to unavailable senders.",
     parameters: Type.Object({
       agent_name: Type.Optional(Type.String({ description: "Whose inbox to read. Defaults to your own." })),
       unread_only: Type.Optional(Type.Boolean({ default: true })),
@@ -345,7 +345,7 @@ export function registerCoordinationTools(pi: any, options: CoordinationToolsOpt
       if (process.env.PI_EXTENDED_TEAMS_HERDR_RESUME === "1" && targetAgent !== options.agentName) throw new Error("A resumed subagent can only read its own inbox.");
       const markAsRead = params.mark_as_read !== false;
       const unreadOnly = params.unread_only !== false;
-      const msgs = await messaging.readInbox(targetTeamName, targetAgent, unreadOnly, markAsRead);
+      const msgs = await messaging.readInboxWithSenderStatus(targetTeamName, targetAgent, unreadOnly, markAsRead);
 
       if (markAsRead && options.isTeammate && targetAgent === options.agentName) {
         const config = await teams.readConfig(targetTeamName).catch(() => null);

package/extensions/ui/renderers.ts

@@ -104,7 +104,11 @@ export function summarizeInboxMessage(message: any): string {
   const from = message?.from || "unknown";
   const summary = message?.summary || "message";
   const timestamp = message?.timestamp ? new Date(message.timestamp).toLocaleTimeString() : "";
-  return `${from}${timestamp ? ` ${timestamp}` : ""}: ${summary}`;
+  const sender = message?.senderStatus;
+  const availability = sender
+    ? ` [sender now: ${sender.status}; can message: ${sender.canMessage === null ? "unknown" : sender.canMessage ? "yes" : "no"}]`
+    : "";
+  return `${from}${availability}${timestamp ? ` ${timestamp}` : ""}: ${summary}`;
 }
 
 export function formatInboxMessagesForModel(messages: any[]): string {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-extended-teams",
-  "version": "2.3.3",
+  "version": "2.4.0",
   "description": "Control-first, session-connected subagents for Pi with live navigation and intent-tier routing",
   "repository": {
     "type": "git",

package/src/utils/messaging.ts

@@ -7,7 +7,12 @@ import { InboxMessage, TeamConfig } from "./models";
 import { withLock } from "./lock";
 import { configPath, inboxPath } from "./paths";
 import { readConfig } from "./teams";
-import { assertLifecycleTombstoneAbsent, withLifecycleTombstoneLock } from "./lifecycle-tombstone";
+import {
+  assertLifecycleTombstoneAbsent,
+  readLifecycleTombstoneSnapshot,
+  withLifecycleTombstoneLock,
+  type LifecycleTombstonePhase,
+} from "./lifecycle-tombstone";
 
 export interface MessageMetadataOptions {
   id?: string;
@@ -272,6 +277,57 @@ export async function readInbox(
   });
 }
 
+export interface InboxSenderStatus {
+  status: "lead" | "active" | "not_running" | "quarantined" | "unknown" | LifecycleTombstonePhase;
+  canMessage: boolean | null;
+}
+
+export async function readInboxWithSenderStatus(
+  teamName: string,
+  agentName: string,
+  unreadOnly = false,
+  markAsRead = true
+): Promise<Array<InboxMessage & { senderStatus: InboxSenderStatus }>> {
+  const messages = await readInbox(teamName, agentName, unreadOnly, markAsRead);
+  if (messages.length === 0) return [];
+
+  // Advisory admission snapshot, not process liveness or a reservation to send.
+  // Enrich only returned copies: persisted inbox history must not cache live status.
+  let members: TeamConfig["members"] | undefined;
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath(teamName), "utf-8")) as TeamConfig;
+    if (Array.isArray(config.members)) members = config.members;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") members = [];
+  }
+
+  const senders = new Map<string, InboxSenderStatus>();
+  for (const sender of new Set(messages.map(message => message.from))) {
+    let senderStatus: InboxSenderStatus = { status: "unknown", canMessage: null };
+    try {
+      if (sender === "team-lead") {
+        senderStatus = { status: "lead", canMessage: true };
+      } else {
+        const fence = readLifecycleTombstoneSnapshot(teamName, sender);
+        if (fence.status !== "absent") {
+          senderStatus = {
+            status: fence.status === "corrupt" ? "quarantined" : fence.tombstone.phase,
+            canMessage: false,
+          };
+        } else if (members) {
+          const member = members.find(member => member.name === sender);
+          const canMessage = !!member && member.isActive !== false;
+          senderStatus = { status: canMessage ? "active" : "not_running", canMessage };
+        }
+      }
+    } catch {
+      // Status lookup must not discard messages after read flags were saved.
+    }
+    senders.set(sender, senderStatus);
+  }
+  return messages.map(message => ({ ...message, senderStatus: senders.get(message.from)! }));
+}
+
 export async function markInboxMessagesRead(teamName: string, agentName: string, ids: string[]): Promise<void> {
   const p = inboxPath(teamName, agentName);
   if (!fs.existsSync(p)) throw new Error("Referenced inbox is unavailable.");