tmux-ide 2.9.0-beta.48 → 2.9.0-beta.49

package/packages/daemon/src/pane-team.ts

@@ -0,0 +1,42 @@
+import { execFileSync } from "node:child_process";
+import { isAbsolute } from "node:path";
+import { runtimeTmuxArgs } from "./lib/runtime-namespace.ts";
+import { manualPaneTeamStamp, PANE_TEAM_OPTION } from "./terminal/attachments/manual-pane-team.ts";
+
+/** Explicit membership only. Never launches, stops, or messages an agent. */
+export function assignPaneTeam(
+  options: {
+    paneId: string;
+    name: string | null;
+    socketPath?: string;
+    socketName?: string;
+  },
+  run: (args: string[]) => string = (args) =>
+    execFileSync("tmux", args, { encoding: "utf8", timeout: 5000 }),
+) {
+  if (!/^%\d+$/u.test(options.paneId)) throw new Error("Use an exact pane ID such as %3");
+  if (options.socketPath && options.socketName) throw new Error("Choose one tmux socket selector");
+  if (options.socketPath && !isAbsolute(options.socketPath))
+    throw new Error("Socket path must be absolute");
+  if (options.socketName && !/^[a-zA-Z0-9_.-]+$/u.test(options.socketName))
+    throw new Error("Invalid socket name");
+  const args = (command: string[]) =>
+    options.socketPath
+      ? ["-S", options.socketPath, ...command]
+      : options.socketName
+        ? ["-L", options.socketName, ...command]
+        : runtimeTmuxArgs(command);
+  const pid = Number(
+    run(args(["display-message", "-p", "-t", options.paneId, "#{pane_pid}"])).trim(),
+  );
+  if (!Number.isSafeInteger(pid) || pid < 1) throw new Error("Pane is no longer available");
+  const stamp = options.name === null ? null : manualPaneTeamStamp(options.name, pid);
+  run(
+    args(
+      stamp === null
+        ? ["set-option", "-p", "-u", "-t", options.paneId, PANE_TEAM_OPTION]
+        : ["set-option", "-p", "-t", options.paneId, PANE_TEAM_OPTION, stamp],
+    ),
+  );
+  return { paneId: options.paneId, team: options.name, source: stamp === null ? null : "manual" };
+}

package/packages/daemon/src/terminal/attachments/agent-status-probe.ts

@@ -1,3 +1,6 @@
+import { readManualPaneTeam } from "./manual-pane-team.ts";
+import type { PaneTeamMembership } from "@tmux-ide/contracts";
+import type { ClaudeTeamMembershipReader } from "./claude-team-names.ts";
 import type { ClaudeTeamNameReader } from "./claude-team-names.ts";
 import type { NativePaneIdentity } from "@tmux-ide/contracts";
 /**
@@ -44,6 +47,7 @@ import {
 /** The per-pane facts the pure projector consumes (see `ApplicationShellPanePresentationFacts`). */
 export interface AgentStatusPaneFacts {
   readonly teamMemberName?: string;
+  readonly team?: PaneTeamMembership;
   /** Stable manifest id resolved from the pane hint, command, or process tree. */
   readonly agentKind: string | null;
   /** Raw `@agent_state` (`"<state>:<epoch>"`), or null when unset. */
@@ -95,6 +99,7 @@ const AGENT_OPTIONS_FORMAT = [
   "#{@agent_display_name}",
   "#{@agent_hint}",
   "#{pane_pid}",
+  "#{@tmux_ide_team}",
   AGENT_LINE_SENTINEL,
 ].join(AGENT_FIELD_SEPARATOR);
 
@@ -119,6 +124,7 @@ export const SCRAPE_CAPTURE_BUDGET = 4;
 const SCRAPE_CACHE_MAX_ENTRIES = 1024;
 
 interface RawPaneOptions {
+  readonly team?: PaneTeamMembership;
   readonly stateRaw: string | null;
   readonly statusTextRaw: string | null;
   readonly displayNameRaw: string | null;
@@ -153,12 +159,13 @@ function parseAgentOptions(stdout: string): ReadonlyMap<string, RawPaneOptions>
     if (line.length === 0) continue;
     const fields = line.split(AGENT_FIELD_SEPARATOR);
     // paneId, state, statusText, displayName, hint, pid, sentinel
-    if (fields.length !== 7 || fields[6] !== AGENT_LINE_SENTINEL) continue;
+    if (![7, 8].includes(fields.length) || fields.at(-1) !== AGENT_LINE_SENTINEL) continue;
     const runtimePaneId = fields[0]!;
     if (!RUNTIME_PANE_ID.test(runtimePaneId)) continue;
     const pidText = fields[5]!;
     const pid = /^[0-9]+$/u.test(pidText) ? Number(pidText) : null;
     result.set(runtimePaneId, {
+      team: fields.length === 8 ? readManualPaneTeam(fields[6], pid) : undefined,
       stateRaw: emptyToNull(fields[1]!),
       statusTextRaw: emptyToNull(fields[2]!),
       displayNameRaw: emptyToNull(fields[3]!),
@@ -171,6 +178,7 @@ function parseAgentOptions(stdout: string): ReadonlyMap<string, RawPaneOptions>
 
 export interface TmuxAgentStatusProbeDeps {
   readonly readTeamNames?: ClaudeTeamNameReader;
+  readonly readTeamMemberships?: ClaudeTeamMembershipReader;
   /** null proves no native dispatch; failures must never retry through stock capture. */
   readonly captureNative?: (
     pane: AgentStatusProbePane,
@@ -305,6 +313,7 @@ export function createTmuxAgentStatusProbe(deps: TmuxAgentStatusProbeDeps): Agen
       agentKind: string | null,
     ): void => {
       facts.set(pane.runtimePaneId, {
+        ...(raw?.team ? { team: raw.team } : {}),
         agentKind,
         agentStateRaw: raw?.stateRaw ?? null,
         agentStatusTextRaw: raw?.statusTextRaw ?? null,
@@ -432,6 +441,25 @@ export function createTmuxAgentStatusProbe(deps: TmuxAgentStatusProbeDeps): Agen
       emit(pane, raw, verdict, manifest.id);
     }
 
+    if (deps.readTeamMemberships) {
+      const memberships = await deps.readTeamMemberships(
+        input.panes.flatMap((pane) => {
+          const pid = options.get(pane.runtimePaneId)?.pid;
+          return pid ? [{ runtimePaneId: pane.runtimePaneId, pid }] : [];
+        }),
+      );
+      throwIfAborted(signal);
+      for (const [paneId, member] of memberships) {
+        const fact = facts.get(paneId);
+        if (fact)
+          facts.set(paneId, {
+            ...fact,
+            teamMemberName: member.name,
+            team: fact.team ?? member.team,
+          });
+      }
+    }
+
     if (deps.readTeamNames) {
       const names = await deps.readTeamNames(
         input.panes.flatMap((pane) => {

package/packages/daemon/src/terminal/attachments/claude-team-names.ts

@@ -1,3 +1,5 @@
+import { createHash } from "node:crypto";
+import type { PaneTeamMembership } from "@tmux-ide/contracts";
 /** Read-only compatibility adapter for Claude Code's runtime team metadata.
  * Names are presentation evidence, never agent identity or permission authority.
  */
@@ -75,19 +77,35 @@ function matchesProcess(command: string, member: ClaudeTeamMember): boolean {
   return true;
 }
 
-export function resolveClaudeTeamName(
+export function resolveClaudeTeamMember(
   pane: TeamPaneProcess,
   members: readonly ClaudeTeamMember[],
   processes: ProcEntry[],
-): string | null {
+): ClaudeTeamMember | null {
   // A native pane id alone cannot bind a team: different servers reuse %N.
   // Its live shell PID scopes the match to this host and this pane's subtree.
   const subtree = subtreeEntries(processes, pane.pid);
   const matches = members.filter(
     (m) => m.paneId === pane.runtimePaneId && subtree.some((p) => matchesProcess(p.command, m)),
   );
-  return matches.length === 1 ? matches[0]!.name : null;
+  return matches.length === 1 ? matches[0]! : null;
+}
+
+export function resolveClaudeTeamName(
+  pane: TeamPaneProcess,
+  members: readonly ClaudeTeamMember[],
+  processes: ProcEntry[],
+): string | null {
+  return resolveClaudeTeamMember(pane, members, processes)?.name ?? null;
+}
+
+export interface ClaudePaneTeam {
+  readonly name: string;
+  readonly team: PaneTeamMembership;
 }
+export type ClaudeTeamMembershipReader = (
+  panes: readonly TeamPaneProcess[],
+) => Promise<ReadonlyMap<string, ClaudePaneTeam>>;
 
 async function readMembers(directory: string): Promise<ClaudeTeamMember[]> {
   try {
@@ -126,14 +144,14 @@ export type ClaudeTeamNameReader = (
   panes: readonly TeamPaneProcess[],
 ) => Promise<ReadonlyMap<string, string>>;
 
-export function createClaudeTeamNameReader(
+export function createClaudeTeamMembershipReader(
   directory: string,
   deps: {
     readMembers?: () => Promise<ClaudeTeamMember[]>;
     readProcesses?: () => Promise<ProcEntry[]>;
     now?: () => number;
   } = {},
-): ClaudeTeamNameReader {
+): ClaudeTeamMembershipReader {
   const now = deps.now ?? Date.now;
   let snapshot: { at: number; members: ClaudeTeamMember[]; processes: ProcEntry[] } | null = null;
   let pending: Promise<void> | null = null;
@@ -156,11 +174,28 @@ export function createClaudeTeamNameReader(
       await pending;
     }
     const current = snapshot!;
-    const names = new Map<string, string>();
+    const names = new Map<string, ClaudePaneTeam>();
     for (const pane of panes) {
-      const name = resolveClaudeTeamName(pane, current.members, current.processes);
-      if (name) names.set(pane.runtimePaneId, name);
+      const member = resolveClaudeTeamMember(pane, current.members, current.processes);
+      if (member)
+        names.set(pane.runtimePaneId, {
+          name: member.name,
+          team: {
+            id: `team.${createHash("sha256").update(member.team).digest("hex").slice(0, 32)}`,
+            name: member.team.slice(0, 80),
+            source: "claude-code",
+          },
+        });
     }
     return names;
   };
 }
+
+/** Compatibility API for callers interested only in the shared display name. */
+export function createClaudeTeamNameReader(
+  directory: string,
+  deps: Parameters<typeof createClaudeTeamMembershipReader>[1] = {},
+): ClaudeTeamNameReader {
+  const read = createClaudeTeamMembershipReader(directory, deps);
+  return async (panes) => new Map([...(await read(panes))].map(([id, value]) => [id, value.name]));
+}

package/packages/daemon/src/terminal/attachments/manual-pane-team.ts

@@ -0,0 +1,31 @@
+import { createHash } from "node:crypto";
+import { PaneTeamMembershipSchemaZ, type PaneTeamMembership } from "@tmux-ide/contracts";
+
+export const PANE_TEAM_OPTION = "@tmux_ide_team";
+
+/** Pane-local metadata survives layout moves, but never a replacement process. */
+export function manualPaneTeamStamp(name: string, pid: number): string {
+  if (!Number.isSafeInteger(pid) || pid < 1) throw new Error("Invalid pane process");
+  const team = PaneTeamMembershipSchemaZ.parse({
+    id: `team.${createHash("sha256").update(name).digest("hex").slice(0, 32)}`,
+    name,
+    source: "manual",
+  });
+  return `v1.${Buffer.from(JSON.stringify({ version: 1, pid, team })).toString("base64url")}`;
+}
+
+export function readManualPaneTeam(
+  raw: string | null | undefined,
+  pid: number | null,
+): PaneTeamMembership | undefined {
+  if (!raw || raw.length > 2048 || !pid) return undefined;
+  try {
+    if (!/^v1\.[A-Za-z0-9_-]+$/u.test(raw)) return undefined;
+    const value = JSON.parse(Buffer.from(raw.slice(3), "base64url").toString("utf8"));
+    if (value.version !== 1 || value.pid !== pid) return undefined;
+    const parsed = PaneTeamMembershipSchemaZ.safeParse(value.team);
+    return parsed.success && parsed.data.source === "manual" ? parsed.data : undefined;
+  } catch {
+    return undefined;
+  }
+}

package/packages/daemon/src/tui/mirror/runtime/application-home-agent-roster.tsx

@@ -336,6 +336,7 @@ export function HomeAgentRoster(props: HomeAgentRosterProps) {
                     theme={props.theme}
                     id={`home-agent:${key}`}
                     name={row().name}
+                    team={row().team}
                     context={[row().machineLabel, row().serverLabel, row().sessionName]
                       .filter(Boolean)
                       .join(" · ")}

package/packages/daemon/src/tui/mirror/runtime/application-home-agents.ts

@@ -1,3 +1,4 @@
+import type { PaneTeamMembership } from "@tmux-ide/contracts";
 import type { NativePaneIdentity } from "@tmux-ide/contracts";
 import type {
   AgentActivity,
@@ -10,6 +11,7 @@ import type { ApplicationHomeCatalogSession } from "./application-home-catalog.t
 import { terminalAgentStatusLabel } from "./application-terminal-workspace-policy.ts";
 
 export interface HomeAgentRow {
+  readonly team?: PaneTeamMembership;
   readonly nativeIdentity: NativePaneIdentity | null;
   readonly interactionEndpoint: Extract<InteractionPaneEndpoint, { kind: "pane" }> | null;
   readonly key: string;
@@ -97,6 +99,7 @@ export function projectHomeAgentRows(
           resource.attachability.semanticPaneId === agent.paneId,
       )?.windowResourceId ?? null,
     name: agent.name,
+    ...(agent.team ? { team: agent.team } : {}),
     harness: agent.harness,
     activity: agent.activity,
     attention: agent.attention,

package/packages/daemon/src/tui/mirror/runtime/application-home-fleet.ts

@@ -1,3 +1,4 @@
+import { groupApplicationTeamRows } from "./application-team-groups.ts";
 import { createEffect, createMemo, createSignal, onCleanup } from "solid-js";
 import type {
   ApplicationMachineAgent,
@@ -84,6 +85,7 @@ export function projectHomeFleet(
     ? rows.filter((row) =>
         [
           row.name,
+          row.team?.name,
           row.harness,
           row.projectName,
           row.sessionName,
@@ -100,7 +102,7 @@ export function projectHomeFleet(
           ? "loading"
           : "unavailable"
       : "live",
-    rows: matching,
+    rows: groupApplicationTeamRows(matching),
     observedSessions,
     totalSessions,
     loadingSessions,

package/packages/daemon/src/tui/mirror/runtime/application-machine-sidebar.tsx

@@ -1,3 +1,5 @@
+import { groupApplicationTeamRows } from "./application-team-groups.ts";
+import type { PaneTeamMembership } from "@tmux-ide/contracts";
 import type { NativePaneIdentity } from "@tmux-ide/contracts";
 import type { PaneInteractionEndpoint } from "../ui/pane-interaction-presentation.ts";
 import type { InteractionPaneEndpoint } from "@tmux-ide/contracts";
@@ -31,6 +33,7 @@ import { Surface } from "../ui/surface.tsx";
 import { useKeyboardRoute } from "../ui/keyboard-router.tsx";
 
 export interface ApplicationMachineAgent {
+  readonly team?: PaneTeamMembership;
   readonly nativeIdentity: NativePaneIdentity | null;
   readonly interactionEndpoint: Extract<InteractionPaneEndpoint, { kind: "pane" }> | null;
   readonly daemonInstanceId?: string;
@@ -168,7 +171,7 @@ export function ApplicationMachineSidebar(props: {
   const preferenceKey = (group: ApplicationMachineGroup) => group.environmentId ?? group.id;
   const rows = createMemo<readonly Row[]>(() => [
     ...props.model.groups().flatMap((group) =>
-      (group.agents ?? []).map((agent) => ({
+      groupApplicationTeamRows(group.agents ?? []).map((agent) => ({
         key: JSON.stringify([
           group.id,
           "agent",
@@ -583,6 +586,7 @@ export function ApplicationMachineSidebar(props: {
                       theme={props.theme}
                       id={`machine:${row.key}`}
                       name={agent().name}
+                      team={agent().team}
                       context={[
                         row.group.label,
                         row.group.sessions.find(

package/packages/daemon/src/tui/mirror/runtime/application-team-groups.ts

@@ -0,0 +1,40 @@
+import {
+  paneTeamGroupKey,
+  type PaneTeamMembership,
+  type TmuxServerScope,
+} from "@tmux-ide/contracts";
+
+interface TeamRow {
+  readonly team?: PaneTeamMembership;
+  readonly machineId?: string;
+  readonly server?: TmuxServerScope;
+  readonly daemonInstanceId?: string;
+}
+
+export function applicationTeamKey(row: TeamRow): string | null {
+  return row.team
+    ? paneTeamGroupKey(
+        row.team,
+        row.machineId ?? "local",
+        row.server?.serverId ?? "default",
+        row.server?.generation ?? row.daemonInstanceId ?? "",
+      )
+    : null;
+}
+
+/** Group by membership, never by name, activity, or current tmux window. Stable within groups. */
+export function groupApplicationTeamRows<T extends TeamRow>(rows: readonly T[]): T[] {
+  const groups = new Map<string, T[]>();
+  const ungrouped: T[] = [];
+  for (const row of rows) {
+    const key = applicationTeamKey(row);
+    if (key === null) {
+      ungrouped.push(row);
+      continue;
+    }
+    const group = groups.get(key) ?? [];
+    group.push(row);
+    groups.set(key, group);
+  }
+  return [...groups.values()].flat().concat(ungrouped);
+}

package/packages/daemon/src/tui/mirror/ui/agent-row.tsx

@@ -5,7 +5,7 @@ import {
   type PaneInteractionEvent,
 } from "./pane-interaction-presentation.ts";
 /* @jsxImportSource @opentui/solid */
-import type { AgentActivity } from "@tmux-ide/contracts";
+import type { AgentActivity, PaneTeamMembership } from "@tmux-ide/contracts";
 import { Show } from "solid-js";
 import type { SemanticThemeSnapshot } from "../theme.ts";
 import { clipTerminal } from "../terminal-text.ts";
@@ -19,6 +19,7 @@ export function AgentRow(props: {
   theme: SemanticThemeSnapshot;
   id: string;
   name: string;
+  team?: PaneTeamMembership;
   context: string;
   activity: AgentActivity;
   interaction?: PaneInteractionEvent;
@@ -83,7 +84,7 @@ export function AgentRow(props: {
         theme={props.theme}
         id={props.id}
         width={props.width}
-        label={props.name}
+        label={props.compact && props.team ? `${props.team.name} / ${props.name}` : props.name}
         marker={
           receipt()
             ? receiptMarker()
@@ -113,7 +114,10 @@ export function AgentRow(props: {
           width={props.width}
           fg={props.selected ? palette().foreground : props.theme.roles.text.muted}
         >
-          {clipTerminal(`  ${props.context}`, props.width)}
+          {clipTerminal(
+            `  ${[props.team?.name, props.context].filter(Boolean).join(" · ")}`,
+            props.width,
+          )}
         </text>
       </Show>
     </box>