@hienlh/ppm 0.17.16 → 0.17.18

package/src/services/group-chat/turn-engine.ts

@@ -1,17 +1,22 @@
 import {
   type Group,
   type GroupMember,
-  type GroupMessage,
+  type BurstResult,
+  type BurstEndReason,
   type TurnEngineDeps,
-  type TurnLoopResult,
-  type TerminationReason,
 } from "../../types/group-chat.ts";
-import { buildContextWindow, renderWindow, DEFAULT_WINDOW } from "./context-window.ts";
-
-const DONE_RE = /^\s*DONE:/i;
-const MENTION_RE = /@(\w+)/;
-/** Feed summary cap — the bus stores a short summary; full text is retrievable
- *  via the member session (fullSessionRef → archived transcript). */
+import { buildContextWindow, renderFull, DEFAULT_WINDOW } from "./context-window.ts";
+import { dispatchParallel } from "./agent-runner.ts";
+
+/** Max AI turns triggered by a single user message before yielding back to the user.
+ *  Headroom for delegate → members report → leader wrap-up; the router ends earlier
+ *  (returns none) when there's nothing left to add. */
+export const REPLY_BURST_CAP = 10;
+
+/** Matches @name mentions; unicode-aware so non-ASCII member names (e.g. "Bình") work. */
+const MENTION_RE = /@([\p{L}\p{N}_]+)/u;
+const MENTION_RE_G = /@([\p{L}\p{N}_]+)/gu;
+/** Feed summary cap — the bus stores a short summary; full text lives in the member session. */
 const SUMMARY_CAP = 600;
 
 /** Cap a turn's text for the feed: first paragraph, bounded to SUMMARY_CAP. */
@@ -31,134 +36,207 @@ function leaderOf(members: GroupMember[]): GroupMember {
   return leader;
 }
 
-/** Pick the next speaker from an @mention in `text`; else fall back:
- *  leader → first non-leader member; member → leader (keeps discussion moving). */
-export function selectNextSpeaker(text: string, current: string, members: GroupMember[]): string {
-  const m = text.toLowerCase().match(MENTION_RE);
-  const target = m?.[1];
-  if (target && target !== current && findMember(members, target)) return target;
-  const leader = leaderOf(members);
-  if (current === leader.name) {
-    const other = members.find((x) => x.role !== "leader");
-    return other?.name ?? leader.name;
+/** Explicit @mentions of known members in the user's message (in order, deduped). */
+export function parseMentions(userText: string, members: GroupMember[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const m of userText.matchAll(MENTION_RE_G)) {
+    const name = m[1]!;
+    if (!seen.has(name) && findMember(members, name)) { out.push(name); seen.add(name); }
   }
-  return leader.name;
+  return out;
+}
+
+/** Who replies to a user message (legacy mention-following mode): each @mentioned member;
+ *  if none mentioned, the leader answers. */
+export function selectInitialResponders(userText: string, members: GroupMember[]): string[] {
+  const mentions = parseMentions(userText, members);
+  return mentions.length > 0 ? mentions : [leaderOf(members).name];
+}
+
+/** Next teammate to pull in from a reply's @mention, or null when the reply has no
+ *  valid teammate mention (i.e. it was addressed to the user → end the burst). */
+export function selectNextSpeaker(text: string, current: string, members: GroupMember[]): string | null {
+  const target = text.match(MENTION_RE)?.[1];
+  if (target && target !== current && findMember(members, target)) return target;
+  return null;
 }
 
-/** Build the per-turn prompt for `speaker`: task + windowed channel + rolling
- *  summary + role instructions. Only the leader may finalize with "DONE:". */
+/** Build the per-turn prompt for `speaker`. Keep-alive sessions retain the member's own
+ *  past turns natively, so inject only the shared-channel DELTA since it last spoke (full
+ *  text). First turn ever → the recent window (+ rolling summary) as a cold start. No
+ *  task/DONE language; the member must not hand off (a coordinator picks the next speaker). */
 export function buildTurnContext(
   group: Group,
   speaker: GroupMember,
   members: GroupMember[],
-  task: string,
   deps: TurnEngineDeps,
-  opts: { window?: number; forceFinal?: boolean } = {},
+  opts: { window?: number } = {},
 ): string {
   const window = opts.window ?? DEFAULT_WINDOW;
   const prior = deps.readMessages(group.id);
-  const { window: recent, rollingSummary } = buildContextWindow(prior, window);
   const others = members.filter((m) => m.name !== speaker.name).map((m) => m.name).join(", ");
-  const isLeader = speaker.role === "leader";
   const persona = speaker.persona ? `, ${speaker.persona}` : "";
 
+  // Last turn index this member itself produced (native memory covers ≤ this).
+  const lastSeen = prior.reduce(
+    (mx, m) => (m.fromMember === speaker.name && m.turnIndex > mx ? m.turnIndex : mx),
+    -1,
+  );
+
+  let contextBlock: string;
+  if (lastSeen >= 0) {
+    const delta = prior.filter((m) => m.turnIndex > lastSeen);
+    contextBlock = `\nNEW SINCE YOU LAST SPOKE:\n${delta.length ? renderFull(delta) : "(nothing new)"}`;
+  } else {
+    const { window: recent, rollingSummary } = buildContextWindow(prior, window);
+    contextBlock =
+      (rollingSummary ? `\nEARLIER (summary):\n${rollingSummary}` : "") +
+      `\nGROUP CHAT (recent):\n${renderFull(recent)}`;
+  }
+
   const parts = [
-    `You are "${speaker.name}"${persona}.`,
-    `Team task: ${task}`,
-    rollingSummary ? `\nEARLIER (summary):\n${rollingSummary}` : "",
-    `\nTEAM CHANNEL (recent, teammates: ${others}):\n${renderWindow(recent)}`,
-    `\nReply in MAX 2 sentences. Address a teammate with @name (e.g. @${others.split(", ")[0] || "alice"}).`,
-    isLeader
-      ? (opts.forceFinal
-          ? `You MUST finalize now: start your message with "DONE:" then the decision + 1 reason.`
-          : `If the team has converged, start with "DONE:" then the decision + 1 reason. Otherwise steer the discussion and @ someone.`)
-      : `Do NOT write "DONE:" — only the leader finalizes.`,
+    `You are "${speaker.name}"${persona}. You're chatting in a group with the user and your teammates: ${others}.`,
+    contextBlock,
+    `\nReply directly to the user, as yourself, in MAX 2 sentences — like a person in a group chat.`,
+    `Just give YOUR answer. Do NOT @mention teammates or hand off turns ("@X your turn", "over to you") — a coordinator decides who speaks next; handing off only creates loops.`,
+    `Do not narrate actions and never write "DONE".`,
   ];
   return parts.filter(Boolean).join("\n");
 }
 
-/** Run the shared-channel turn loop until one of four termination conditions:
- *  leader DONE · max_turns · budget cap · external stop. Always emits exactly
- *  one `final` message and always terminates (cap guarantees). */
-export async function runGroupTurnLoop(
+/** Run a bounded reply burst for the latest user message. When `deps.routeNextSpeaker`
+ *  is provided, an LLM router picks the next speaker each turn (history-driven, allows
+ *  AI↔AI silence, leader as fallback/moderator); otherwise it falls back to mention-
+ *  following. Either way: user @mention is an absolute override, a user message always
+ *  gets ≥1 reply, and total AI turns are capped. Emits only `kind:"chat"` messages. */
+export async function runReplyBurst(
   group: Group,
   members: GroupMember[],
   deps: TurnEngineDeps,
-  task: string,
-): Promise<TurnLoopResult> {
-  const leader = leaderOf(members);
-  let speaker = leader.name;
+  opts: { cap?: number; window?: number } = {},
+): Promise<BurstResult> {
+  return deps.routeNextSpeakers
+    ? runRoutedBurst(group, members, deps, opts)
+    : runMentionBurst(group, members, deps, opts);
+}
+
+/** Shared per-turn side effects: run the agent, persist + emit the message. */
+async function runTurn(
+  group: Group, members: GroupMember[], deps: TurnEngineDeps,
+  name: string, turnIndex: number, window?: number,
+): Promise<{ text: string; costUsd: number }> {
+  const member = findMember(members, name) ?? leaderOf(members);
+  const prompt = buildTurnContext(group, member, members, deps, { window });
+  deps.onTyping?.(name);
+  const result = await deps.runAgent(member, prompt);
+  const text = result.text ?? "";
+  const pull = selectNextSpeaker(text, name, members);
+  const msg = deps.appendMessage({
+    groupId: group.id,
+    fromMember: name,
+    toMember: pull,
+    kind: "chat",
+    summary: feedSummary(text),
+    // Full text for cross-member context injection (feed UI still shows `summary`).
+    data: { full: text },
+    fullSessionRef: member.sessionId,
+    turnIndex,
+  });
+  deps.onMessage?.(msg);
+  return { text, costUsd: result.usage?.costUsd ?? 0 };
+}
+
+/** Dedupe names, keeping order, dropping unknown members. */
+function knownUnique(names: string[], members: GroupMember[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const n of names) {
+    if (!seen.has(n) && findMember(members, n)) { out.push(n); seen.add(n); }
+  }
+  return out;
+}
+
+/** Router-driven turn-taking with PARALLEL batches: `deps.routeNextSpeakers` returns 0-N
+ *  members to run concurrently this turn. User @mentions run first (absolute, in parallel);
+ *  the first user-reply turn is forced to ≥1 (leader fallback); AI↔AI turns may end (empty →
+ *  silence). Each batch member counts toward the cap; batches are bounded to the remaining cap. */
+async function runRoutedBurst(
+  group: Group, members: GroupMember[], deps: TurnEngineDeps,
+  opts: { cap?: number; window?: number },
+): Promise<BurstResult> {
+  const cap = opts.cap ?? REPLY_BURST_CAP;
+  const prior = deps.readMessages(group.id);
+  const lastUser = [...prior].reverse().find((m) => m.fromMember === "user");
+  let mentionQueue = parseMentions(lastUser?.summary ?? "", members);
+  let nextTurnIndex = (prior[prior.length - 1]?.turnIndex ?? -1) + 1;
+
   let turns = 0;
+  let assistantTurns = 0;
   let costUsd = 0;
-  let reason: TerminationReason | null = null;
-  let finalText = "";
+  let reason: BurstEndReason = "no_more_mentions";
 
-  for (let turnIndex = 0; turnIndex < group.maxTurns; turnIndex++) {
+  while (true) {
     if (deps.shouldStop?.()) { reason = "stopped"; break; }
-
-    const member = findMember(members, speaker) ?? leader;
-    const isLastTurn = turnIndex === group.maxTurns - 1;
-    // Force the leader to finalize on the final allowed turn.
-    const forceFinal = isLastTurn && member.role === "leader";
-    const prompt = buildTurnContext(group, member, members, task, deps, { forceFinal });
-
-    const result = await deps.runAgent(member, prompt);
-    turns++;
-    costUsd += result.usage?.costUsd ?? 0;
-    const text = result.text ?? "";
-
-    const isDone = member.role === "leader" && DONE_RE.test(text);
-    const mention = text.match(MENTION_RE)?.[1] ?? null;
-
-    const msg = deps.appendMessage({
-      groupId: group.id,
-      fromMember: member.name,
-      toMember: isDone ? "all" : mention,
-      kind: isDone ? "final" : "chat",
-      summary: feedSummary(text),
-      fullSessionRef: member.sessionId,
-      turnIndex,
-    });
-    deps.onMessage?.(msg);
-
-    if (isDone) { reason = "leader_done"; return { reason, turns, costUsd }; }
-
-    if (costUsd >= group.maxCostUsd) { reason = "budget"; finalText = text; break; }
-
-    // If the next turn is the last, steer to the leader so it can finalize.
-    if (turnIndex >= group.maxTurns - 2) {
-      speaker = leader.name;
+    if (turns >= cap) { reason = "cap_reached"; break; }
+
+    const isUserTurn = assistantTurns === 0;
+    let names: string[];
+    if (mentionQueue.length > 0) {
+      // Explicit user @mentions → all of them reply in parallel (absolute override).
+      names = mentionQueue;
+      mentionQueue = [];
     } else {
-      speaker = selectNextSpeaker(text, speaker, members);
+      const history = deps.readMessages(group.id);
+      names = knownUnique(await deps.routeNextSpeakers!({ history, members, isUserTurn }), members);
+      if (names.length === 0) {
+        if (isUserTurn) names = [leaderOf(members).name]; // a user message always gets ≥1 reply
+        else break; // AI↔AI: nothing more to add → silence
+      }
     }
-  }
 
-  if (reason === null) reason = "max_turns";
-
-  // Ensure exactly one `final` message when the loop ended without a leader DONE.
-  const finalMsg = deps.appendMessage({
-    groupId: group.id,
-    fromMember: leader.name,
-    toMember: "all",
-    kind: "final",
-    summary: buildFinalSummary(reason, finalText),
-    fullSessionRef: leader.sessionId,
-    turnIndex: turns,
-  });
-  deps.onMessage?.(finalMsg);
+    // Bound the parallel batch to the remaining cap.
+    names = names.slice(0, cap - turns);
+    // Pre-assign turn indices so concurrent appends stay ordered/collision-free.
+    const batch = names.map((name) => ({ name, turnIndex: nextTurnIndex++ }));
+    const results = await dispatchParallel(
+      batch.map((b) => () => runTurn(group, members, deps, b.name, b.turnIndex, opts.window)),
+      cap, // concurrency ≤ cap (≤ remaining) — bounded fan-out, rate-limit guard
+    );
+    turns += batch.length;
+    assistantTurns += batch.length;
+    for (const r of results) costUsd += r.costUsd;
+  }
 
   return { reason, turns, costUsd };
 }
 
-function buildFinalSummary(reason: TerminationReason, lastText: string): string {
-  switch (reason) {
-    case "max_turns":
-      return `DONE: discussion reached the turn cap. ${lastText}`.trim();
-    case "budget":
-      return `DONE: discussion reached the budget cap. ${lastText}`.trim();
-    case "stopped":
-      return `DONE: discussion stopped by request.`;
-    default:
-      return `DONE: ${lastText}`.trim();
+/** Legacy conversational mode (no router): mentions → those members, else the leader;
+ *  repliers may @pull teammates; stop when a reply addresses the user (no mention). */
+async function runMentionBurst(
+  group: Group, members: GroupMember[], deps: TurnEngineDeps,
+  opts: { cap?: number; window?: number },
+): Promise<BurstResult> {
+  const cap = opts.cap ?? REPLY_BURST_CAP;
+  const prior = deps.readMessages(group.id);
+  const lastUser = [...prior].reverse().find((m) => m.fromMember === "user");
+  const queue = selectInitialResponders(lastUser?.summary ?? "", members);
+  let nextTurnIndex = (prior[prior.length - 1]?.turnIndex ?? -1) + 1;
+  let turns = 0;
+  let costUsd = 0;
+  let reason: BurstEndReason = "no_more_mentions";
+
+  while (queue.length > 0) {
+    if (deps.shouldStop?.()) { reason = "stopped"; break; }
+    if (turns >= cap) { reason = "cap_reached"; break; }
+
+    const name = queue.shift()!;
+    const { text, costUsd: c } = await runTurn(group, members, deps, name, nextTurnIndex++, opts.window);
+    turns++;
+    costUsd += c;
+    const pull = selectNextSpeaker(text, name, members);
+    if (pull) queue.push(pull);
   }
+
+  return { reason, turns, costUsd };
 }

package/src/services/jsonl-transcript-parser.ts

@@ -82,6 +82,8 @@ export function parseSessionMessage(
         if (role === "assistant" && cleaned) {
           events.push({ type: "text", content: cleaned, ...(parentId && { parentToolUseId: parentId }) });
         }
+      } else if (block.type === "thinking" && typeof block.thinking === "string") {
+        events.push({ type: "thinking", content: block.thinking as string, ...(parentId && { parentToolUseId: parentId }) });
       } else if (block.type === "tool_use") {
         events.push({
           type: "tool_use",
@@ -238,3 +240,37 @@ export async function parseJsonlTranscript(
     (msg) => msg.content.trim().length > 0 || (msg.events && msg.events.length > 0),
   );
 }
+
+/** Session input config surfaced in a transcript view. Fields are best-effort — the SDK
+ *  scatters them across user/assistant records rather than a single init line. */
+export interface TranscriptConfig {
+  model?: string;
+  cwd?: string;
+  gitBranch?: string;
+  version?: string;
+  permissionMode?: string;
+}
+
+/** Scan a transcript's records for the first-seen input-config values. Returns null when
+ *  nothing recognizable is found. Defensive: never throws, ignores malformed lines. */
+export async function parseTranscriptConfig(filePath: string): Promise<TranscriptConfig | null> {
+  let text: string;
+  try { text = await Bun.file(filePath).text(); } catch { return null; }
+  const cfg: TranscriptConfig = {};
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let e: Record<string, unknown>;
+    try { e = JSON.parse(trimmed); } catch { continue; }
+    if (cfg.cwd === undefined && typeof e.cwd === "string") cfg.cwd = e.cwd;
+    if (cfg.gitBranch === undefined && typeof e.gitBranch === "string") cfg.gitBranch = e.gitBranch;
+    if (cfg.version === undefined && typeof e.version === "string") cfg.version = e.version;
+    if (cfg.permissionMode === undefined && typeof e.permissionMode === "string") cfg.permissionMode = e.permissionMode as string;
+    if (cfg.model === undefined) {
+      const model = (e.message as Record<string, unknown> | undefined)?.model ?? e.model;
+      if (typeof model === "string" && model !== "<synthetic>") cfg.model = model;
+    }
+    if (cfg.model && cfg.cwd && cfg.gitBranch && cfg.version && cfg.permissionMode) break;
+  }
+  return Object.keys(cfg).length > 0 ? cfg : null;
+}

package/src/types/group-chat-ws.ts

@@ -1,4 +1,4 @@
-import type { GroupMessage, GroupStatus, MemberStatus, TerminationReason } from "./group-chat.ts";
+import type { GroupMessage, GroupStatus, MemberStatus, BurstEndReason } from "./group-chat.ts";
 
 /** Server → client group-chat WS events. */
 export type GroupChatServerMessage =
@@ -7,7 +7,7 @@ export type GroupChatServerMessage =
   | { type: "member_status"; memberId: string; status: MemberStatus }
   | { type: "typing"; member: string }
   | { type: "turn_done"; turnIndex: number }
-  | { type: "group_done"; reason: TerminationReason; turns: number; costUsd: number }
+  | { type: "group_done"; reason: BurstEndReason; turns: number; costUsd: number }
   | { type: "error"; message: string }
   | { type: "ping" };
 

package/src/types/group-chat.ts

@@ -6,7 +6,9 @@ export type MemberRole = "leader" | "member";
 export type MemberStatus = "idle" | "working" | "done" | "error";
 export type MessageKind = "task" | "chat" | "status" | "completion" | "final";
 
-export const DEFAULT_MAX_TURNS = 40;
+/** Per-group cap on AI turns per user message (the "reply burst" ceiling). Configurable
+ *  per team; the router usually ends earlier by returning nobody. */
+export const DEFAULT_MAX_TURNS = 10;
 export const DEFAULT_MAX_COST_USD = 5.0;
 
 export interface Group {
@@ -66,6 +68,16 @@ export interface AddMemberInput {
   color?: string | null;
 }
 
+/** Partial member update — only provided fields change. */
+export interface UpdateMemberInput {
+  role?: MemberRole;
+  name?: string;
+  persona?: string | null;
+  agentType?: string | null;
+  model?: string | null;
+  color?: string | null;
+}
+
 export interface AppendMessageInput {
   groupId: string;
   fromMember: string;
@@ -101,14 +113,31 @@ export interface TurnEngineDeps {
   readMessages: (groupId: string, opts?: ReadMessagesOptions) => GroupMessage[];
   /** Emit a turn to live listeners (WS broadcast). Optional. */
   onMessage?: (message: GroupMessage) => void;
+  /** Signal that `member` is composing a reply (drives the typing indicator). Optional. */
+  onTyping?: (member: string) => void;
+  /** Pick who speaks NEXT given recent context; returns 0-N member names to run **in
+   *  parallel** this turn. Empty = end the burst (no one else replies). `isUserTurn` is true
+   *  only for the first reply to a fresh user message — on that turn the engine forces the
+   *  leader if the router returns none (a user message always gets ≥1 reply). Members that
+   *  must build on each other → return just one (sequential). When this dep is absent the
+   *  engine falls back to mention-following (conversational mode). Optional. */
+  routeNextSpeakers?: (ctx: {
+    history: GroupMessage[];
+    members: GroupMember[];
+    isUserTurn: boolean;
+  }) => Promise<string[]>;
   /** External stop signal (user Stop / abort). Checked before each turn. */
   shouldStop?: () => boolean;
 }
 
-export type TerminationReason = "leader_done" | "max_turns" | "budget" | "stopped";
+/** Why a conversational reply burst ended.
+ *  - no_more_mentions: last reply addressed the user (no teammate @mention) → wait for user
+ *  - cap_reached: hit the per-message AI-turn cap
+ *  - stopped: external Stop / abort */
+export type BurstEndReason = "no_more_mentions" | "cap_reached" | "stopped";
 
-export interface TurnLoopResult {
-  reason: TerminationReason;
+export interface BurstResult {
+  reason: BurstEndReason;
   turns: number;
   costUsd: number;
 }

package/src/web/components/group-chat/group-chat-tab.tsx

@@ -5,11 +5,14 @@ import { useProjectStore } from "@/stores/project-store";
 import { useIsMobile } from "@/hooks/use-is-mobile";
 import { useGroupChat } from "@/hooks/use-group-chat";
 import { Button } from "@/components/ui/button";
+import { BottomSheet } from "@/components/ui/mobile-bottom-sheet";
 import { cn } from "@/lib/utils";
 import { GroupMessageItem } from "./group-message-item";
 import { GroupMemberRoster } from "./group-member-roster";
+import { GroupMemberEditDialog, type MemberFormValues } from "./group-member-edit-dialog";
 import { GroupFullTranscriptView } from "./group-full-transcript-view";
-import type { GroupMessage } from "../../../types/group-chat";
+import { getGroup, addGroupMember, updateGroupMember, removeGroupMember, updateGroupSettings } from "@/lib/api-group-chat";
+import type { GroupMessage, GroupMember } from "../../../types/group-chat";
 
 interface GroupChatTabProps {
   metadata?: Record<string, unknown>;
@@ -31,20 +34,64 @@ export function GroupChatTab({ metadata }: GroupChatTabProps) {
   const [rosterOpen, setRosterOpen] = useState(false);
   const feedEndRef = useRef<HTMLDivElement>(null);
 
+  // Full roster (with persona/model) for management — the WS `members` only carry
+  // live status/color, so we fetch the editable detail separately and refetch on change.
+  const [roster, setRoster] = useState<GroupMember[]>([]);
+  const [cap, setCap] = useState<number | null>(null); // per-group reply-burst cap
+  const [rosterBusy, setRosterBusy] = useState(false);
+  const [rosterError, setRosterError] = useState<string | null>(null);
+  // `null` = dialog closed; `{ member: null }` = add; `{ member }` = edit.
+  const [editing, setEditing] = useState<{ member: GroupMember | null } | null>(null);
+
+  const reloadRoster = useCallback(async () => {
+    if (!groupId) return;
+    try { const g = await getGroup(groupId); setRoster(g.members); setCap(g.maxTurns); } catch { /* keep last */ }
+  }, [groupId]);
+
+  const handleCapChange = useCallback(async (n: number) => {
+    if (!groupId) return;
+    const clamped = Math.max(1, Math.min(50, Math.floor(n) || 1));
+    setCap(clamped);
+    try { await updateGroupSettings(groupId, { maxTurns: clamped }); }
+    catch { void reloadRoster(); }
+  }, [groupId, reloadRoster]);
+
+  useEffect(() => { setRoster([]); void reloadRoster(); }, [groupId, reloadRoster]);
+
   // Stick to bottom on new messages.
   useEffect(() => {
     feedEndRef.current?.scrollIntoView({ block: "end" });
   }, [messages.length, typing]);
 
+  // memberId → live status from the running burst (overlays the fetched roster).
+  const liveStatus = useMemo(() => new Map(members.map((m) => [m.id, m.status] as const)), [members]);
+
+  // Prefer the fetched roster (fresh after edits); fall back to WS members before load.
+  const metaSource = roster.length ? roster : members;
   const colorFor = useMemo(() => {
-    const map = new Map(members.map((m) => [m.name, m.color]));
+    const map = new Map(metaSource.map((m) => [m.name, m.color]));
     return (name: string) => map.get(name) ?? null;
-  }, [members]);
+  }, [metaSource]);
 
   const isLeader = useMemo(() => {
-    const leaders = new Set(members.filter((m) => m.role === "leader").map((m) => m.name));
+    const leaders = new Set(metaSource.filter((m) => m.role === "leader").map((m) => m.name));
     return (name: string) => leaders.has(name);
-  }, [members]);
+  }, [metaSource]);
+
+  const handleSubmitMember = useCallback(async (values: MemberFormValues) => {
+    if (!groupId) return;
+    if (editing?.member) await updateGroupMember(groupId, editing.member.id, values);
+    else await addGroupMember(groupId, values);
+    await reloadRoster();
+  }, [groupId, editing, reloadRoster]);
+
+  const handleRemoveMember = useCallback(async (m: GroupMember) => {
+    if (!groupId) return;
+    setRosterBusy(true); setRosterError(null);
+    try { await removeGroupMember(groupId, m.id); await reloadRoster(); }
+    catch (e) { setRosterError(e instanceof Error ? e.message : "Failed to remove member"); }
+    finally { setRosterBusy(false); }
+  }, [groupId, reloadRoster]);
 
   const handleSend = useCallback(() => {
     const content = draft.trim();
@@ -156,17 +203,65 @@ export function GroupChatTab({ metadata }: GroupChatTabProps) {
         </div>
       </div>
 
-      {/* Roster — sidebar on desktop, drawer toggle on mobile */}
-      {rosterOpen && (
-        <div className={cn(
-          "shrink-0 border-l border-border bg-panel",
-          isMobile ? "absolute inset-y-0 right-0 z-20 w-64 shadow-xl" : "w-60",
-        )}>
-          <div className="flex h-11 items-center border-b border-border px-3 text-sm font-medium text-foreground">
+      {/* Roster — inline sidebar on desktop; bottom sheet on mobile (tap backdrop
+          or swipe down to dismiss, since the header toggle sits under an overlay). */}
+      {isMobile ? (
+        <BottomSheet open={rosterOpen} onClose={() => setRosterOpen(false)} className="flex max-h-[72vh] flex-col">
+          <div className="flex h-11 shrink-0 items-center px-4 text-sm font-medium text-foreground">
             Members
           </div>
-          <GroupMemberRoster members={members} typing={typing} />
-        </div>
+          <div className="min-h-0 overflow-y-auto">
+            {cap !== null && (
+              <label className="flex items-center gap-2 px-4 py-2 text-xs text-text-secondary">
+                <span>Reply cap</span>
+                <input type="number" min={1} max={50} value={cap}
+                  onChange={(e) => handleCapChange(Number(e.target.value))}
+                  className="w-14 rounded border border-border bg-background px-1.5 py-1 text-xs text-foreground" />
+                <span className="text-text-subtle">turns/msg</span>
+              </label>
+            )}
+            {rosterError && <p className="px-3 py-1 text-xs text-destructive">{rosterError}</p>}
+            <GroupMemberRoster
+              members={roster} liveStatus={liveStatus} typing={typing} busy={rosterBusy}
+              onAdd={() => setEditing({ member: null })} onEdit={(m) => setEditing({ member: m })} onRemove={handleRemoveMember}
+            />
+          </div>
+        </BottomSheet>
+      ) : (
+        rosterOpen && (
+          <div className="flex w-60 shrink-0 flex-col border-l border-border bg-panel">
+            <div className="flex h-11 shrink-0 items-center border-b border-border px-3 text-sm font-medium text-foreground">
+              Members
+            </div>
+            <div className="min-h-0 flex-1 overflow-y-auto">
+              {cap !== null && (
+                <label className="flex items-center gap-2 px-3 py-2 text-xs text-text-secondary">
+                  <span>Reply cap</span>
+                  <input type="number" min={1} max={50} value={cap}
+                    onChange={(e) => handleCapChange(Number(e.target.value))}
+                    className="w-14 rounded border border-border bg-background px-1.5 py-1 text-xs text-foreground" />
+                  <span className="text-text-subtle">turns/msg</span>
+                </label>
+              )}
+              {rosterError && <p className="px-3 py-1 text-xs text-destructive">{rosterError}</p>}
+              <GroupMemberRoster
+                members={roster} liveStatus={liveStatus} typing={typing} busy={rosterBusy}
+                onAdd={() => setEditing({ member: null })} onEdit={(m) => setEditing({ member: m })} onRemove={handleRemoveMember}
+              />
+            </div>
+          </div>
+        )
+      )}
+
+      {editing && (
+        <GroupMemberEditDialog
+          key={editing.member?.id ?? "add"}
+          open
+          member={editing.member}
+          projectName={projectName}
+          onSubmit={handleSubmitMember}
+          onClose={() => setEditing(null)}
+        />
       )}
 
       <GroupFullTranscriptView groupId={groupId} message={transcriptMsg} onClose={() => setTranscriptMsg(null)} />