@ctliz/agent-intercom-claude 0.14.1 → 0.15.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-intercom",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "Claude Code MCP plugin and wakeable worker for local Pi/Codex/Claude intercom messaging.",
   "author": {
     "name": "ctliz",

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.15.0 - 2026-10-02
+
+- Add additive task teams shared with Pi, OpenCode, and Codex: one manager-approved call adds named peers without switching registration scope or losing previous memberships.
+- Preserve task teams on sends, asks, native relays, and automatic worker replies; receiver-local ask/context selectors prevent mixed-task replies and support ordinary inbound messages.
+- Prompt once for team approval on new delegations. Initial ungrouped contact remains possible across unrelated memberships.
+
 ## 0.14.1 - 2026-09-30
 
 - Expose the existing MCP owner's `runtimeReady` promise to companion Grok/AGY launchers so native identity and title updates use `syncSession` without opening a competing broker connection.

package/README.md

@@ -262,15 +262,26 @@ tools without the skill.
 ## Tools
 
 - `intercom_whoami`: show this session's intercom ID, name, cwd, and model.
-- `intercom_team`: show the current manager and live coworkers owned by that manager.
-- `intercom_join`: list, join, or create a named team without tmux (`create: true` joins as manager).
+- `intercom_team({ team? })`: show all named task memberships, inspect one team, or fall back to managed-team discovery.
+- `intercom_join({ name?, create?, members?, work? })`: add task-team membership without leaving earlier teams; managers add connected peers in one call.
 - `intercom_status`: show connection status and pending message counts.
 - `intercom_list`: list local Pi, Codex, and Claude sessions in your scope (protocol v4 is same-scope; cross-scope contact requires an exact full session ID).
 - `intercom_set_summary`: publish a short discoverable status.
 - `intercom_send`: send a non-blocking message.
 - `intercom_ask`: send a question and wait for the target's reply.
 - `intercom_pending`: read queued inbound messages and unresolved asks.
-- `intercom_reply`: reply to a pending inbound ask; use `to` plus `which: "oldest" | "latest"` if one sender has multiple unresolved asks.
+- `intercom_reply`: reply to an inbound ask or ordinary message via `askId` or `contextId` from `intercom_pending`; replies inherit the original team. Within one task, `to` plus `which: "oldest" | "latest"` also selects an ask.
+
+### Task teams
+
+When the user delegates to named peers, the agent asks once whether to form a team for this task and waits for approval. An explicit create/join request is already approval; inbound team messages and approved tasks do not prompt again. After discovery, one call adds everyone:
+
+```typescript
+intercom_join({ name: "launch", create: true, members: ["front", "writer"], work: "Launch page" })
+intercom_send({ to: "front", team: "launch", message: "Implement the header." })
+```
+
+Membership is additive, with a separate manager/member role in each team. Reuse a team for the same task and append approved peers with `intercom_join({ name: "launch", members: ["reviewer"] })`; a different task may need a different team. Registration scope and earlier memberships stay unchanged. Without a shared team, omit `team` for initial ungrouped contact—even if either session belongs to unrelated teams. When several teams are shared, sends/asks require `team`; exact reply selectors retain the source team and cannot override it. AGY and Grok inherit these rules through the same MCP runtime.
 
 Pending output never exposes protocol message IDs. Keep at most one unresolved `intercom_ask` to the same recipient; the broker rejects a second ask and recommends `intercom_send` for a non-blocking follow-up. Use `intercom_send`—not `intercom_ask`—for assignments and progress/status checkpoints.
 

package/broker/broker.ts

@@ -220,7 +220,7 @@ function isMessage(value: unknown): value is Message {
     if (message.replyTo !== undefined || message.expectsReply !== undefined) return false;
   }
 
-  if (!hasExactDataKeys(message.content, ["text"], ["attachments"])) {
+  if (!hasExactDataKeys(message.content, ["text"], ["attachments", "team"])) {
     return false;
   }
 
@@ -229,7 +229,8 @@ function isMessage(value: unknown): value is Message {
     return false;
   }
 
-  if (message.control !== undefined && (content.text !== "" || content.attachments !== undefined)) {
+  if (content.team !== undefined && (typeof content.team !== "string" || !/^[A-Za-z][A-Za-z0-9_-]{0,31}$/.test(content.team))) return false;
+  if (message.control !== undefined && (content.text !== "" || content.attachments !== undefined || content.team !== undefined)) {
     return false;
   }
 

package/broker/client.ts

@@ -43,6 +43,7 @@ export interface IntercomClientOptions {
 
 export interface SendOptions {
   text: string;
+  team?: string;
   attachments?: Attachment[];
   replyTo?: string;
   expectsReply?: boolean;
@@ -122,7 +123,7 @@ function isMessage(value: unknown): value is Message {
     if (message.replyTo !== undefined || message.expectsReply !== undefined) return false;
   }
 
-  if (!hasExactDataKeys(message.content, ["text"], ["attachments"])) {
+  if (!hasExactDataKeys(message.content, ["text"], ["attachments", "team"])) {
     return false;
   }
 
@@ -131,7 +132,8 @@ function isMessage(value: unknown): value is Message {
     return false;
   }
 
-  if (message.control !== undefined && (content.text !== "" || content.attachments !== undefined)) return false;
+  if (content.team !== undefined && (typeof content.team !== "string" || !/^[A-Za-z][A-Za-z0-9_-]{0,31}$/.test(content.team))) return false;
+  if (message.control !== undefined && (content.text !== "" || content.attachments !== undefined || content.team !== undefined)) return false;
 
   return content.attachments === undefined
     || isDenseArrayOf(content.attachments, isAttachment);
@@ -904,6 +906,7 @@ export class IntercomClient extends EventEmitter {
       ...(options.control === undefined ? {} : { control: options.control }),
       content: {
         text: options.text,
+        ...(options.team === undefined ? {} : { team: options.team }),
         ...(options.attachments === undefined ? {} : { attachments: options.attachments }),
       },
     };

package/claude/inbox.ts

@@ -15,6 +15,7 @@ export interface InboxEntry {
   fromId: string;
   fromName?: string;
   messageId: string;
+  team?: string;
   replyTo?: string;
   expectsReply: boolean;
   text: string;
@@ -34,6 +35,7 @@ export function toInboxEntry(from: SessionInfo, message: Message, now: number =
     fromId: from.id,
     ...(from.name ? { fromName: from.name } : {}),
     messageId: message.id,
+    ...(message.content.team ? { team: message.content.team } : {}),
     ...(message.replyTo ? { replyTo: message.replyTo } : {}),
     expectsReply: Boolean(message.expectsReply),
     text: message.content.text,
@@ -53,7 +55,7 @@ export function formatInboxLine(entry: InboxEntry): string {
   const who = entry.fromName ? `${entry.fromName} (${entry.fromId.slice(0, 8)})` : entry.fromId;
   const kind = entry.expectsReply ? " [asking — awaiting your reply]" : "";
   const oneLine = entry.text.replace(/\s+/g, " ").trim();
-  return `Intercom message from ${who}${kind}: ${oneLine}`;
+  return `Intercom message from ${who}${entry.team ? ` [Team: ${entry.team}]` : ""}${kind}: ${oneLine}\nReply with intercom_reply({ contextId: "ctx-${entry.messageId}", message: "..." }); inherit the original team.`;
 }
 
 /**

package/claude/mcp-protocol.ts

@@ -1,5 +1,6 @@
 import type { ClaudeIntercomRuntime, ToolResult } from "./runtime.ts";
 import { validateAskTimeoutMs } from "../config.ts";
+import { TASK_TEAM_GUIDANCE } from "./team-guidance.ts";
 import type { Attachment } from "../types.ts";
 import { hasExactDataKeys, isDenseArrayOf } from "../broker/validation.ts";
 
@@ -35,6 +36,16 @@ function asString(value: unknown, name: string): string {
   return value;
 }
 
+function optionalString(value: unknown, name: string): string | undefined {
+  return value === undefined ? undefined : asString(value, name);
+}
+
+function memberArray(value: unknown): string[] | undefined {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value)) throw new Error("members must be an array of session names or IDs");
+  return Array.from(value, (member) => asString(member, "member"));
+}
+
 function asBoolean(value: unknown, defaultValue: boolean): boolean {
   return typeof value === "boolean" ? value : defaultValue;
 }
@@ -89,26 +100,30 @@ export function buildToolDefinitions(runtime: ClaudeIntercomRuntime): ToolDefini
     },
     {
       name: "intercom_team",
-      description: "Show your current manager and the live coworkers owned by that manager. No arguments are required.",
-      inputSchema: { type: "object", properties: {}, additionalProperties: false },
+      description: "Show all your named task teams, or inspect one by name. Falls back to managed-team discovery.",
+      inputSchema: { type: "object", properties: { team: { type: "string" } }, additionalProperties: false },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-      handler: async () => runtime.team(),
+      handler: async (args) => runtime.team(optionalString(args.team, "team")),
     },
     {
       name: "intercom_join",
-      description: "List, join, or create a named intercom team without tmux. Omit name to list joinable teams. Set create=true to create a team and join as manager.",
+      description: "After user approval, create or join a task team. Membership is additive; members lets the manager add connected peers in one call. Omit name to list teams.",
       inputSchema: {
         type: "object",
         properties: {
           name: { type: "string", description: "Team name to join. Omit to list joinable teams." },
           create: { type: "boolean", description: "Create this named team and join as manager. Requires name." },
+          members: { type: "array", items: { type: "string" }, description: "Connected session names or IDs to add; manager only." },
+          work: { type: "string", maxLength: 2000, description: "Task description when creating a team." },
         },
         additionalProperties: false,
       },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
       handler: async (args) => runtime.join(
-        typeof args.name === "string" ? args.name : undefined,
+        optionalString(args.name, "name"),
         args.create === true,
+        memberArray(args.members),
+        optionalString(args.work, "work"),
       ),
     },
     {
@@ -156,12 +171,13 @@ export function buildToolDefinitions(runtime: ClaudeIntercomRuntime): ToolDefini
           to: { type: "string" },
           message: { type: "string" },
           attachments: attachmentsSchema,
+          team: { type: "string", description: "Task team; required when multiple teams are shared. Omit for ungrouped contact." },
         },
         required: ["to", "message"],
         additionalProperties: false,
       },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-      handler: async (args) => runtime.send(asString(args.to, "to"), asString(args.message, "message"), asAttachmentArray(args.attachments)),
+      handler: async (args) => runtime.send(asString(args.to, "to"), asString(args.message, "message"), asAttachmentArray(args.attachments), undefined, optionalString(args.team, "team")),
     },
     {
       name: "intercom_ask",
@@ -172,6 +188,7 @@ export function buildToolDefinitions(runtime: ClaudeIntercomRuntime): ToolDefini
           to: { type: "string" },
           message: { type: "string" },
           attachments: attachmentsSchema,
+          team: { type: "string", description: "Task team; required when multiple teams are shared." },
           timeout_ms: { type: "integer", minimum: 1, maximum: 120000, description: "Maximum time to wait for a reply before returning an error. Use intercom_send plus intercom_pending for longer work." },
         },
         required: ["to", "message"],
@@ -184,6 +201,7 @@ export function buildToolDefinitions(runtime: ClaudeIntercomRuntime): ToolDefini
         asAttachmentArray(args.attachments),
         asOptionalPositiveInteger(args.timeout_ms, "timeout_ms"),
         signal,
+        optionalString(args.team, "team"),
       ),
     },
     {
@@ -199,19 +217,22 @@ export function buildToolDefinitions(runtime: ClaudeIntercomRuntime): ToolDefini
     },
     {
       name: "intercom_reply",
-      description: "Reply to a pending inbound ask. Use to plus which=oldest/latest when one sender has multiple unresolved asks.",
+      description: "Reply to an inbound ask or ordinary message using askId or contextId from intercom_pending. Inherits the original team; team cannot override it.",
       inputSchema: {
         type: "object",
         properties: {
           message: { type: "string" },
           to: { type: "string", description: "Optional sender/session selector; never a message or thread ID." },
+          askId: { type: "string", description: "Stable receiver-local pending ask selector." },
+          contextId: { type: "string", description: "Exact inbound context selector, including ordinary messages." },
+          team: { type: "string", description: "Must match the original message; omit to inherit." },
           which: { type: "string", enum: ["oldest", "latest"], description: "Select the oldest or latest ask from the chosen sender." },
         },
         required: ["message"],
         additionalProperties: false,
       },
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
-      handler: async (args) => runtime.reply(asString(args.message, "message"), typeof args.to === "string" ? args.to : undefined, args.which === "oldest" || args.which === "latest" ? args.which : undefined),
+      handler: async (args) => runtime.reply(asString(args.message, "message"), typeof args.to === "string" ? args.to : undefined, args.which === "oldest" || args.which === "latest" ? args.which : undefined, optionalString(args.askId, "askId"), optionalString(args.contextId, "contextId"), optionalString(args.team, "team")),
     },
   ];
   return tools;
@@ -248,7 +269,8 @@ export async function handleMcpRequest(request: JsonRpcRequest, runtime: ClaudeI
       return ok(request.id, {
         protocolVersion: "2025-06-18",
         capabilities: { tools: {} },
-        serverInfo: { name: "claude-intercom", version: "0.14.0" },
+        instructions: TASK_TEAM_GUIDANCE,
+        serverInfo: { name: "claude-intercom", version: "0.15.0" },
       });
     case "ping":
       return ok(request.id, {});

package/claude/named-team-membership.ts

@@ -0,0 +1,124 @@
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { ensureIntercomRuntimeDir, getAgentDirPath, getIntercomDirPath } from "../broker/paths.ts";
+import { writeDurableJson } from "../durable-json.ts";
+import { generateNamedTeamScope, listNamedTeams, NAMED_TEAMS_FILE, NAMED_TEAMS_VERSION, parseTeamName, type NamedTeam } from "./named-teams.ts";
+import type { SessionInfo } from "../types.ts";
+
+export function namedTeamMemberIds(team: NamedTeam): string[] {
+  return team.memberSessionIds ?? [team.managerSessionId];
+}
+
+export function sessionNamedTeams(sessionId: string, agentDir?: string): NamedTeam[] {
+  return listNamedTeams(agentDir).filter((team) => namedTeamMemberIds(team).includes(sessionId));
+}
+
+/** Serialize the complete read-modify-write across independently launched agent processes. */
+export async function appendNamedTeamMembership(input: {
+  name: string;
+  selfId: string;
+  members?: string[];
+  create?: boolean;
+  work?: string;
+  agentDir?: string;
+}): Promise<NamedTeam> {
+  const name = parseTeamName(input.name);
+  const memberIds = [...new Set([input.selfId, ...(input.members ?? [])])];
+  if (memberIds.some((id) => !id || id.trim() !== id || /[\u0000-\u001f\u007f]/.test(id))) {
+    throw new Error("Invalid team member session ID");
+  }
+  if (input.work !== undefined && (!input.work.trim() || input.work.length > 2000)) {
+    throw new Error("Work must be a non-empty task description (max 2000 characters)");
+  }
+  const dir = getIntercomDirPath(input.agentDir ?? getAgentDirPath());
+  ensureIntercomRuntimeDir(dir);
+  const lock = join(dir, "named-teams.lock");
+  const deadline = Date.now() + 5000;
+  for (;;) {
+    try {
+      mkdirSync(lock, { mode: 0o700 });
+      break;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+      if (Date.now() >= deadline) throw new Error("Team registry is busy; retry. If a writer crashed, remove the stale named-teams.lock directory after verifying no writer is active.");
+      await delay(25);
+    }
+  }
+  try {
+    const teams = listNamedTeams(input.agentDir);
+    let team = teams.find((entry) => entry.name === name);
+    if (input.create) {
+      if (team) throw new Error(`A named team called ${name} already exists; join it instead.`);
+      team = { name, scopeId: generateNamedTeamScope(teams.map((entry) => entry.scopeId)), managerSessionId: input.selfId, createdAt: Date.now() };
+      teams.push(team);
+    }
+    if (!team) throw new Error(`Team "${name}" does not exist; create it explicitly.`);
+    if (memberIds.some((id) => id !== input.selfId) && team.managerSessionId !== input.selfId) {
+      throw new Error(`Only the manager of team "${name}" may add other sessions`);
+    }
+    if (input.work !== undefined && !input.create) {
+      throw new Error("Work is set when creating a team; use a new team for a different task");
+    }
+    const updated: NamedTeam = {
+      ...team,
+      memberSessionIds: [...new Set([...namedTeamMemberIds(team), ...memberIds])],
+      ...(input.work === undefined ? {} : { work: input.work.trim() }),
+    };
+    writeDurableJson(join(dir, NAMED_TEAMS_FILE), {
+      version: NAMED_TEAMS_VERSION,
+      teams: teams.map((entry) => entry.name === name ? updated : entry),
+    });
+    return updated;
+  } finally {
+    rmSync(lock, { recursive: true });
+  }
+}
+
+export function requireNamedTeamMembers(name: string, selfId: string, peerId: string, agentDir?: string): NamedTeam {
+  const team = listNamedTeams(agentDir).find((entry) => entry.name === name);
+  if (!team) throw new Error(`Unknown team "${name}"`);
+  const members = namedTeamMemberIds(team);
+  if (!members.includes(selfId) || !members.includes(peerId)) {
+    throw new Error(`Both sessions must belong to team "${name}" before messaging`);
+  }
+  return team;
+}
+
+export function resolveNamedMessageTeam(selfId: string, peerId: string, requested?: string, agentDir?: string): string | undefined {
+  if (requested !== undefined) return requireNamedTeamMembers(requested, selfId, peerId, agentDir).name;
+  const mine = sessionNamedTeams(selfId, agentDir);
+  const shared = mine.filter((team) => namedTeamMemberIds(team).includes(peerId));
+  if (shared.length === 1) return shared[0]!.name;
+  if (shared.length > 1) throw new Error("Multiple shared teams; specify `team` for this task");
+  // No shared team means an ungrouped contact, even when either session belongs
+  // to unrelated teams. Do not silently create a team or add the recipient.
+  return undefined;
+}
+
+export function namedTeamRoster(team: NamedTeam, selfId: string, sessions: SessionInfo[]) {
+  return {
+    name: team.name,
+    ...(team.work ? { work: team.work } : {}),
+    self: { id: selfId, isManager: selfId === team.managerSessionId },
+    manager: { target: team.managerSessionId, connected: sessions.some((entry) => entry.id === team.managerSessionId) },
+    members: namedTeamMemberIds(team).map((id) => ({
+      id,
+      target: id,
+      name: sessions.find((entry) => entry.id === id)?.name,
+      role: id === team.managerSessionId ? "manager" : "member",
+      connected: sessions.some((entry) => entry.id === id),
+    })),
+  };
+}
+
+export function formatNamedTeamRoster(team: ReturnType<typeof namedTeamRoster>): string {
+  return [
+    `Team: ${team.name}`,
+    ...(team.work ? [`Work: ${team.work}`] : []),
+    `You: ${team.self.id}${team.self.isManager ? " [manager]" : ""}`,
+    `Manager: ${team.manager.target}${team.manager.connected ? "" : " [offline]"}`,
+    "Members:",
+    ...team.members.map((member) => `- ${member.name || member.id} (${member.id}) [${member.role}]${member.connected ? "" : " [offline]"}`),
+  ].join("\n");
+}

package/claude/named-teams.ts

@@ -13,6 +13,8 @@ export interface NamedTeam {
   scopeId: string;
   managerSessionId: string;
   createdAt: number;
+  memberSessionIds?: string[];
+  work?: string;
 }
 
 interface NamedTeamsFile {
@@ -55,11 +57,20 @@ function parseStoredTeam(value: unknown): NamedTeam | undefined {
   if (typeof value.createdAt !== "number" || !Number.isSafeInteger(value.createdAt) || value.createdAt <= 0) {
     return undefined;
   }
+  if (value.memberSessionIds !== undefined && (
+    !Array.isArray(value.memberSessionIds)
+    || !value.memberSessionIds.every((id) => typeof id === "string" && id.trim() === id && id.length > 0 && !/[\u0000-\u001f\u007f]/.test(id))
+    || new Set(value.memberSessionIds).size !== value.memberSessionIds.length
+    || !value.memberSessionIds.includes(value.managerSessionId)
+  )) return undefined;
+  if (value.work !== undefined && (typeof value.work !== "string" || !value.work.trim() || value.work.length > 2000)) return undefined;
   return {
     name: value.name,
     scopeId: value.scopeId,
     managerSessionId: value.managerSessionId,
     createdAt: value.createdAt,
+    ...(value.memberSessionIds === undefined ? {} : { memberSessionIds: value.memberSessionIds as string[] }),
+    ...(value.work === undefined ? {} : { work: value.work as string }),
   };
 }
 

package/claude/native-bridge.ts

@@ -35,7 +35,7 @@ interface NativeBridgeClient {
   }, sessionId?: string): Promise<void>;
   disconnect(): Promise<void>;
   acknowledgeMessage(deliveryId: string): void;
-  send(to: string, message: { text: string; replyTo?: string }): Promise<{ delivered: boolean; reason?: string }>;
+  send(to: string, message: { text: string; replyTo?: string; team?: string }): Promise<{ delivered: boolean; reason?: string }>;
   updatePresence(update: { name?: string; status?: string }): void;
 }
 
@@ -72,6 +72,8 @@ function nativePrompt(from: SessionInfo, message: Message): string {
     : "\n\nAct if needed. To acknowledge or report a result, use Claude's built-in SendMessage tool to reply to this same native peer; a normal assistant response stays local.";
   return [
     `[Intercom message from ${formatSessionDisplay(from)} (${from.id})]`,
+    ...(message.content.team ? [`[Team: ${message.content.team}]`] : []),
+    `When replying via SendMessage, begin the body with [intercom-context:ctx-${message.id}] so this exact task is retained.`,
     message.content.text,
     formatAttachments(message.content.attachments),
     reply,
@@ -175,7 +177,7 @@ export class NativeClaudeBrokerBridge {
       const reason = error instanceof Error ? error.message : String(error);
       this.client.updatePresence({ status: `native delivery error: ${reason}` });
       if (message.expectsReply) {
-        await this.client.send(from.id, { text: `Native Claude delivery failed: ${reason}`, replyTo: message.id }).catch(() => undefined);
+        await this.client.send(from.id, { text: `Native Claude delivery failed: ${reason}`, replyTo: message.id, ...(message.content.team === undefined ? {} : { team: message.content.team }) }).catch(() => undefined);
       }
     }
   }
@@ -186,7 +188,13 @@ export class NativeClaudeBrokerBridge {
     if (typeof message !== "object" || message === null || !("content" in message)) return;
     const envelope = stripNativeEnvelope((message as { content?: unknown }).content);
     if (!envelope.body) return;
-    const relay = this.pending.shift();
+    const selector = /^\[intercom-context:ctx-([^\]\r\n]+)\]\s*/.exec(envelope.body);
+    const index = selector ? this.pending.findIndex((entry) => entry.message.id === selector[1]) : (this.pending.length === 1 ? 0 : -1);
+    if (index < 0) {
+      this.client.updatePresence({ status: "Reply requires the original intercom-context selector" });
+      return;
+    }
+    const relay = this.pending.splice(index, 1)[0];
     const fromAddress = typeof frame.from === "string" ? frame.from : envelope.from;
     if (fromAddress?.startsWith("uds:")) {
       void this.sendFrame(fromAddress.slice(4), buildNativeReceipt({
@@ -198,7 +206,8 @@ export class NativeClaudeBrokerBridge {
     }
     if (!relay) return;
     void this.client.send(relay.from.id, {
-      text: envelope.body,
+      text: selector ? envelope.body.slice(selector[0].length) : envelope.body,
+      ...(relay.message.content.team === undefined ? {} : { team: relay.message.content.team }),
       ...(relay.message.expectsReply ? { replyTo: relay.message.id } : {}),
     }).then(() => {
       this.client.updatePresence({ status: "idle" });

package/claude/reply-context.ts

@@ -0,0 +1,49 @@
+import type { PendingInboundMessage, ReplyWhich } from "./runtime.ts";
+import { selectPendingAsk } from "./runtime.ts";
+
+export function contextId(entry: PendingInboundMessage): string {
+  return `ctx-${entry.message.id}`;
+}
+
+export function askId(entry: PendingInboundMessage): string {
+  return `ask-${entry.message.id}`;
+}
+
+export function replyHint(entry: PendingInboundMessage): string {
+  const team = entry.message.content.team;
+  return `${team ? ` [Team: ${team}]` : ""} [contextId: ${contextId(entry)}]${entry.message.expectsReply ? ` [askId: ${askId(entry)}]` : ""}`;
+}
+
+/** Select from the receiver's own retained inbox, never from a mutable current team. */
+export function selectReplyContext(entries: PendingInboundMessage[], asks: PendingInboundMessage[], input: {
+  to?: string;
+  which?: ReplyWhich;
+  askId?: string;
+  contextId?: string;
+  team?: string;
+}): PendingInboundMessage {
+  if (input.askId && input.contextId) throw new Error("Specify askId or contextId, not both");
+  let target: PendingInboundMessage;
+  if (input.askId || input.contextId) {
+    const selected = input.askId
+      ? asks.find((entry) => askId(entry) === input.askId)
+      : entries.find((entry) => contextId(entry) === input.contextId);
+    if (!selected || (selected.message.expectsReply && !asks.includes(selected))) throw new Error("Unknown or resolved reply selector; call intercom_pending");
+    if (input.to && selected.from.id !== input.to && selected.from.name?.toLowerCase() !== input.to.toLowerCase()) {
+      throw new Error("Reply sender does not match the selected context");
+    }
+    if (input.which) throw new Error("Do not combine an exact reply selector with which");
+    target = selected;
+  } else {
+    const to = input.to;
+    const candidates = to ? asks.filter((entry) => entry.from.id === to || entry.from.name?.toLowerCase() === to.toLowerCase() || entry.from.id.startsWith(to)) : asks;
+    if (!input.which && new Set(candidates.map((entry) => entry.message.content.team)).size > 1) {
+      throw new Error("Multiple team contexts; specify askId or contextId");
+    }
+    target = selectPendingAsk(asks, input.to, input.which);
+  }
+  if (input.team !== undefined && input.team !== target.message.content.team) {
+    throw new Error("Reply team must match the original message; omit team to inherit it");
+  }
+  return target;
+}