@ctliz/agent-intercom-pi 0.11.0-connect.2 → 0.12.0-connect.1

package/index.ts

@@ -487,17 +487,50 @@ function parseSubagentIntercomPayload(payload: unknown): { to: string; message:
   const requestId = typeof record.requestId === "string" ? record.requestId : undefined;
   return { to: record.to, message: record.message, ...(requestId ? { requestId } : {}) };
 }
-function resolveIntercomPresenceName(sessionName: string | undefined, sessionId: string): string {
+
+const GENERIC_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+
+export function resolveIntercomSessionId(
+  fallbackSessionId: string,
+  environment: NodeJS.ProcessEnv = process.env,
+): string {
+  const harnessSessionId = environment[INTERCOM_SESSION_ID_ENV]?.trim();
+  if (harnessSessionId) {
+    return harnessSessionId;
+  }
+  const genericSessionId = environment.AGENT_INTERCOM_SESSION_ID?.trim();
+  if (genericSessionId) {
+    if (!GENERIC_SESSION_ID_PATTERN.test(genericSessionId)) {
+      throw new Error("Invalid AGENT_INTERCOM_SESSION_ID: must match ^[A-Za-z0-9_-]{1,128}$");
+    }
+    return genericSessionId;
+  }
+  return fallbackSessionId;
+}
+
+export function resolveIntercomPresenceName(
+  sessionName: string | undefined,
+  sessionId: string,
+  environment: NodeJS.ProcessEnv = process.env,
+): string {
   const trimmedName = sessionName?.trim();
   if (trimmedName) {
     return trimmedName;
   }
+  const subagentName = environment[SUBAGENT_INTERCOM_SESSION_NAME_ENV]?.trim();
+  if (subagentName) {
+    return subagentName;
+  }
+  const genericName = environment.AGENT_INTERCOM_SESSION_NAME?.trim();
+  if (genericName) {
+    return genericName;
+  }
   const normalizedSessionId = sessionId.startsWith("session-") ? sessionId.slice("session-".length) : sessionId;
   return `${DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX}-${normalizedSessionId.slice(0, 8)}`;
 }
-function buildPresenceIdentity(pi: ExtensionAPI, sessionId: string): { name: string } {
+function buildPresenceIdentity(pi: ExtensionAPI, sessionId: string, environment: NodeJS.ProcessEnv = process.env): { name: string } {
   return {
-    name: resolveIntercomPresenceName(pi.getSessionName(), sessionId),
+    name: resolveIntercomPresenceName(pi.getSessionName(), sessionId, environment),
   };
 }
 function formatSessionLabel(session: SessionInfo, duplicates: Set<string>, idPrefix: string): string {
@@ -623,6 +656,14 @@ function getNamePollMs(): number {
 }
 export default function piIntercomExtension(pi: ExtensionAPI) {
   const runtimeScopeId = intercomScopeIdFromEnvForRegistration();
+  const initialHarnessSessionId = process.env[INTERCOM_SESSION_ID_ENV]?.trim();
+  const initialGenericSessionId = process.env.AGENT_INTERCOM_SESSION_ID?.trim();
+  if (initialGenericSessionId && !initialHarnessSessionId) {
+    if (!GENERIC_SESSION_ID_PATTERN.test(initialGenericSessionId)) {
+      throw new Error("Invalid AGENT_INTERCOM_SESSION_ID: must match ^[A-Za-z0-9_-]{1,128}$");
+    }
+  }
+  const configuredSessionId = initialHarnessSessionId || initialGenericSessionId;
   let client: IntercomClient | null = null;
   const config: IntercomConfig = loadConfig();
   const bossTeamScope = readBossTeamScope();
@@ -739,8 +780,11 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       return null;
     }
     try {
-      if (currentSessionId && ctx.sessionManager.getSessionId() !== currentSessionId) {
-        return null;
+      if (currentSessionId) {
+        const expectedSessionId = configuredSessionId || ctx.sessionManager.getSessionId();
+        if (expectedSessionId !== currentSessionId) {
+          return null;
+        }
       }
       void ctx.hasUI;
       return ctx;
@@ -789,11 +833,12 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       ...(runtimeInstanceId ? { runtimeInstanceId } : {}),
     };
   }
-  function syncPresenceIdentity(sessionId: string): void {
+  function syncPresenceIdentity(sessionId?: string): void {
     if (!client || !getLiveContext()) {
       return;
     }
-    const identity = buildPresenceIdentity(pi, sessionId);
+    const resolvedId = currentSessionId ?? (configuredSessionId || (sessionId ? sessionId : "default"));
+    const identity = buildPresenceIdentity(pi, resolvedId);
     lastPresenceName = identity.name;
     client.updatePresence({ ...identity, status: currentStatus() });
   }
@@ -1343,7 +1388,8 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     rejectAllReplyWaiters(new Error("Session replaced"));
     replyTracker.reset();
     runtimeContext = ctx;
-    currentSessionId = ctx.sessionManager.getSessionId();
+    currentSessionId = configuredSessionId || ctx.sessionManager.getSessionId();
+    publishIntercomSessionId(currentSessionId);
     if (bossTeamScope.present && bossSelfSessionError(bossTeamScope, currentSessionId)) {
       const staleOutbox = new PersistentOutboundOutbox(currentSessionId);
       const removed = staleOutbox.list().length;
@@ -1666,7 +1712,8 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     scheduleInboundFlush(0);
   });
   pi.on("turn_start", (_event, ctx) => {
-    const sessionId = ctx.sessionManager.getSessionId();
+    const rawSessionId = ctx.sessionManager.getSessionId();
+    const sessionId = configuredSessionId || rawSessionId;
     if (!currentSessionId || sessionId !== currentSessionId) {
       if (!config.enabled) {
         return;
@@ -1688,7 +1735,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     currentModel = event.model.id;
     if (client) {
       client.updatePresence({
-        ...buildPresenceIdentity(pi, ctx.sessionManager.getSessionId()),
+        ...buildPresenceIdentity(pi, currentSessionId ?? (configuredSessionId || ctx.sessionManager.getSessionId())),
         model: event.model.id,
         status: currentStatus(),
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctliz/agent-intercom-pi",
-  "version": "0.11.0-connect.2",
+  "version": "0.12.0-connect.1",
   "license": "AGPL-3.0-or-later",
   "type": "module",
   "main": "index.ts",
@@ -44,7 +44,7 @@
     ]
   },
   "dependencies": {
-    "@ctliz/agent-intercom-core": "git+https://github.com/ctliz/agent-intercom-core.git#37e074970e2a9de32a16fc325607c3b476b0bd45",
+    "@ctliz/agent-intercom-core": "0.2.0",
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",

package/team.ts

@@ -1,11 +1,13 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { readTeamManifest, TeamManifestError } from "@ctliz/agent-intercom-core/team-manifest";
 import { getAgentDirPath } from "./broker/paths.ts";
 import { bossSelfSessionError, resolveBossLiveSession, type BossTeamScope } from "./boss-team-scope.ts";
 
 export interface TeamSession {
   id: string;
   name?: string;
+  model?: string;
   origin?: "local" | "remote";
 }
 
@@ -29,9 +31,12 @@ export interface TeamMember {
   connected: boolean;
 }
 
+export type IntercomTeamSource = "orchestrator" | "manifest" | "live_roster" | "standalone";
+
 export interface IntercomTeam {
+  source: IntercomTeamSource;
   teamId?: string;
-  self: { id: string; workerId?: string; isManager: boolean };
+  self: { id: string; workerId?: string; isManager: boolean; role?: string };
   manager?: { target: string; connected: boolean };
   controller?: { target: string; connected: boolean };
   coworkers: TeamMember[];
@@ -46,6 +51,9 @@ export function resolveManagedInboxSession(input: {
   if (!input.team.self.isManager) {
     throw new Error("Only a manager may inspect another session's pending-ask inbox");
   }
+  if (input.team.source !== "orchestrator") {
+    throw new Error("Pending-ask inbox inspection is only available for orchestrator-managed teams");
+  }
   const member = input.team.coworkers.find((entry) => entry.target === input.requestedSession);
   if (!member) {
     throw new Error(`Pending-ask inbox access denied for "${input.requestedSession}"; select an owned coworker target returned by intercom_team`);
@@ -80,6 +88,13 @@ async function readWorkers(agentDir: string): Promise<StoredWorker[]> {
   }
 }
 
+/**
+ * Resolves the Intercom team following the exact priority hierarchy:
+ * 1. Authoritative Orchestrator record in workers.json (matching AGENT_INTERCOM_WORKER_ID or active manager ownership)
+ * 2. Explicit TmuxDeck Manifest (AGENT_INTERCOM_TEAM_MANIFEST)
+ * 3. Workspace Live Same-Scope Non-Human Roster Fallback (AGENT_INTERCOM_SCOPE_ID present)
+ * 4. Standalone unmanaged session
+ */
 export async function resolveIntercomTeam(input: {
   selfId: string;
   sessions: TeamSession[];
@@ -93,39 +108,184 @@ export async function resolveIntercomTeam(input: {
   const current = workerId
     ? workers.find((worker) => stringValue(worker.id) === workerId && (!runId || stringValue(worker.runId) === runId))
     : undefined;
-  const managerTarget = stringValue(current?.managerSessionId) ?? stringValue(env.AGENT_INTERCOM_MANAGER_TARGET) ?? stringValue(env.AGENT_INTERCOM_MANAGER_SESSION_ID);
-  const teamId = managerTarget ?? input.selfId;
-  const isManager = !managerTarget;
-  const coworkers = workers
-    .filter((worker) => worker.owned === true)
-    .filter((worker) => stringValue(worker.managerSessionId) === teamId)
-    .filter((worker) => LIVE_STATES.has(stringValue(worker.state) ?? ""))
-    .filter((worker) => stringValue(worker.id) !== workerId)
-    .map((worker): TeamMember | undefined => {
-      const id = stringValue(worker.id);
-      if (!id) return undefined;
-      const target = stringValue(worker.intercomTarget) ?? id;
+
+  // 1. Authoritative Orchestrator Record
+  if (current) {
+    const managerTarget =
+      stringValue(current.managerSessionId) ??
+      stringValue(env.AGENT_INTERCOM_MANAGER_TARGET) ??
+      stringValue(env.AGENT_INTERCOM_MANAGER_SESSION_ID);
+
+    const coworkers: TeamMember[] = managerTarget
+      ? workers
+          .filter((worker) => worker.owned === true)
+          .filter((worker) => stringValue(worker.managerSessionId) === managerTarget)
+          .filter((worker) => LIVE_STATES.has(stringValue(worker.state) ?? ""))
+          .filter((worker) => stringValue(worker.id) !== workerId)
+          .map((worker): TeamMember | undefined => {
+            const id = stringValue(worker.id);
+            if (!id) return undefined;
+            const target = stringValue(worker.intercomTarget) ?? id;
+            return {
+              id,
+              target,
+              ...(stringValue(worker.harness) ? { harness: stringValue(worker.harness) } : {}),
+              ...(stringValue(worker.role) ? { role: stringValue(worker.role) } : {}),
+              ...(stringValue(worker.state) ? { state: stringValue(worker.state) } : {}),
+              connected: connectedTo(input.sessions, target),
+            };
+          })
+          .filter((member): member is TeamMember => Boolean(member))
+      : [];
+
+    return {
+      source: "orchestrator",
+      ...(managerTarget ? { teamId: managerTarget } : {}),
+      self: { id: input.selfId, ...(workerId ? { workerId } : {}), isManager: false },
+      ...(managerTarget
+        ? { manager: { target: managerTarget, connected: connectedTo(input.sessions, managerTarget) } }
+        : {}),
+      coworkers,
+    };
+  }
+
+  if (workerId === undefined && input.selfId) {
+    const managerOwnedCoworkers = workers
+      .filter((worker) => worker.owned === true)
+      .filter((worker) => stringValue(worker.managerSessionId) === input.selfId)
+      .filter((worker) => LIVE_STATES.has(stringValue(worker.state) ?? ""))
+      .map((worker): TeamMember | undefined => {
+        const id = stringValue(worker.id);
+        if (!id) return undefined;
+        const target = stringValue(worker.intercomTarget) ?? id;
+        return {
+          id,
+          target,
+          ...(stringValue(worker.harness) ? { harness: stringValue(worker.harness) } : {}),
+          ...(stringValue(worker.role) ? { role: stringValue(worker.role) } : {}),
+          ...(stringValue(worker.state) ? { state: stringValue(worker.state) } : {}),
+          connected: connectedTo(input.sessions, target),
+        };
+      })
+      .filter((member): member is TeamMember => Boolean(member));
+
+    if (managerOwnedCoworkers.length > 0) {
       return {
-        id,
-        target,
-        ...(stringValue(worker.harness) ? { harness: stringValue(worker.harness) } : {}),
-        ...(stringValue(worker.role) ? { role: stringValue(worker.role) } : {}),
-        ...(stringValue(worker.state) ? { state: stringValue(worker.state) } : {}),
-        connected: connectedTo(input.sessions, target),
+        source: "orchestrator",
+        teamId: input.selfId,
+        self: { id: input.selfId, isManager: true },
+        manager: { target: input.selfId, connected: true },
+        coworkers: managerOwnedCoworkers,
       };
-    })
-    .filter((member): member is TeamMember => Boolean(member));
+    }
+  }
 
+  // 2. Explicit TmuxDeck Team Manifest
+  if (env.AGENT_INTERCOM_TEAM_MANIFEST !== undefined) {
+    const rawManifestPath = env.AGENT_INTERCOM_TEAM_MANIFEST;
+    if (typeof rawManifestPath !== "string" || !rawManifestPath.trim()) {
+      throw new TeamManifestError("ERR_TEAM_MANIFEST_INVALID");
+    }
+    const manifest = readTeamManifest(rawManifestPath.trim());
+    if (!manifest) {
+      throw new TeamManifestError("ERR_TEAM_MANIFEST_INVALID");
+    }
+
+    const selfMember = manifest.members.find((member) => member.sessionId === input.selfId);
+    if (!selfMember) {
+      throw new TeamManifestError("ERR_TEAM_MANIFEST_INVALID");
+    }
+
+    const isManager = input.selfId === manifest.leadId;
+    const managerTarget = manifest.leadId;
+
+    // Coworkers:
+    // Lead: all workers
+    // Worker: other workers (excluding self and excluding Lead/manager)
+    const coworkers: TeamMember[] = manifest.members
+      .filter((member) => member.sessionId !== input.selfId && member.sessionId !== manifest.leadId)
+      .map((member) => ({
+        id: member.sessionId,
+        target: member.sessionId,
+        role: member.role,
+        connected: connectedTo(input.sessions, member.sessionId),
+      }));
+
+    return {
+      source: "manifest",
+      teamId: manifest.runId,
+      self: {
+        id: input.selfId,
+        isManager,
+        role: selfMember.role,
+      },
+      manager: { target: managerTarget, connected: connectedTo(input.sessions, managerTarget) },
+      coworkers,
+    };
+  }
+
+  // 3. Workspace Live Same-Scope Non-Human Roster Fallback
+  const scopeId = stringValue(env.AGENT_INTERCOM_SCOPE_ID);
+  if (scopeId !== undefined) {
+    const managerTarget =
+      stringValue(env.AGENT_INTERCOM_MANAGER_TARGET) ??
+      stringValue(env.AGENT_INTERCOM_MANAGER_SESSION_ID);
+    const isManager = !managerTarget || managerTarget === input.selfId;
+    const effectiveManagerTarget = isManager ? input.selfId : managerTarget;
+
+    const coworkers: TeamMember[] = input.sessions
+      .filter((session) => session.id !== input.selfId)
+      .filter((session) => session.model !== "human")
+      .filter((session) => isManager || session.id !== effectiveManagerTarget)
+      .map((session) => ({
+        id: session.id,
+        target: session.id,
+        connected: true,
+      }));
+
+    return {
+      source: "live_roster",
+      teamId: effectiveManagerTarget,
+      self: { id: input.selfId, isManager },
+      manager: {
+        target: effectiveManagerTarget,
+        connected: connectedTo(input.sessions, effectiveManagerTarget),
+      },
+      coworkers,
+    };
+  }
+
+  // 4. Standalone Session Fallback
   return {
-    teamId,
-    self: { id: input.selfId, ...(workerId ? { workerId } : {}), isManager },
-    manager: managerTarget
-      ? { target: managerTarget, connected: connectedTo(input.sessions, managerTarget) }
-      : { target: input.selfId, connected: true },
-    coworkers,
+    source: "standalone",
+    self: { id: input.selfId, isManager: false },
+    coworkers: [],
   };
 }
 
+export function formatIntercomTeam(team: IntercomTeam): string {
+  const manager = team.manager
+    ? `${team.manager.target} [${team.manager.connected ? "connected" : "not connected"}]`
+    : "unknown";
+  const lines = [
+    `Manager: ${manager}`,
+    `You: ${team.self.id}${team.self.isManager ? " [manager]" : ""}`,
+  ];
+  if (team.controller) {
+    lines.push(`Controller: ${team.controller.target} [connected]`);
+  }
+  if (team.coworkers.length === 0) {
+    lines.push("Coworkers: none");
+  } else {
+    lines.push("Coworkers:");
+    for (const coworker of team.coworkers) {
+      const metadata = [coworker.harness, coworker.role, coworker.state].filter(Boolean).join(", ");
+      lines.push(`- ${coworker.id} target=${coworker.target}${metadata ? ` (${metadata})` : ""} [${coworker.connected ? "connected" : "not connected"}]`);
+    }
+  }
+  return lines.join("\n");
+}
+
 export function resolveBossIntercomTeam(input: {
   selfId: string;
   sessions: TeamSession[];
@@ -160,6 +320,7 @@ export function resolveBossIntercomTeam(input: {
   }
 
   return {
+    source: "orchestrator",
     ...(manager ? { teamId: manager.target } : {}),
     self: { id: input.selfId, isManager },
     ...(manager ? { manager } : {}),
@@ -167,26 +328,3 @@ export function resolveBossIntercomTeam(input: {
     coworkers,
   };
 }
-
-export function formatIntercomTeam(team: IntercomTeam): string {
-  const manager = team.manager
-    ? `${team.manager.target} [${team.manager.connected ? "connected" : "not connected"}]`
-    : "unknown";
-  const lines = [
-    `Manager: ${manager}`,
-    `You: ${team.self.id}${team.self.isManager ? " [manager]" : ""}`,
-  ];
-  if (team.controller) {
-    lines.push(`Controller: ${team.controller.target} [connected]`);
-  }
-  if (team.coworkers.length === 0) {
-    lines.push("Coworkers: none");
-  } else {
-    lines.push("Coworkers:");
-    for (const coworker of team.coworkers) {
-      const metadata = [coworker.harness, coworker.role, coworker.state].filter(Boolean).join(", ");
-      lines.push(`- ${coworker.id} target=${coworker.target}${metadata ? ` (${metadata})` : ""} [${coworker.connected ? "connected" : "not connected"}]`);
-    }
-  }
-  return lines.join("\n");
-}