@hienlh/ppm 0.17.15 → 0.17.17

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/api.ts

@@ -23,9 +23,11 @@ export type TerminalWsMessage =
 
 /** WebSocket message types (chat) */
 export type ChatWsClientMessage =
-  | { type: "message"; content: string; permissionMode?: string; priority?: 'now' | 'next' | 'later'; images?: Array<{ data: string; mediaType: string }>; model?: string }
+  | { type: "message"; content: string; permissionMode?: string; priority?: 'now' | 'next' | 'later'; images?: Array<{ data: string; mediaType: string }>; model?: string; effort?: string; thinking?: boolean }
   | { type: "cancel" }
   | { type: "set_model"; model: string }
+  | { type: "set_effort"; effort: string }
+  | { type: "set_thinking"; enabled: boolean }
   | { type: "approval_response"; requestId: string; approved: boolean; reason?: string; data?: unknown }
   | { type: "kill_background_shell"; shellId: string }
   | { type: "ready" };
@@ -57,7 +59,7 @@ export type ChatWsServerMessage =
   | { type: "error"; message: string }
   | { type: "account_info"; accountId: string; accountLabel: string }
   | { type: "phase_changed"; phase: SessionPhase; elapsed?: number }
-  | { type: "session_state"; sessionId: string; phase: SessionPhase; pendingApproval: { requestId: string; tool: string; input: unknown } | null; sessionTitle: string | null; model?: string }
+  | { type: "session_state"; sessionId: string; phase: SessionPhase; pendingApproval: { requestId: string; tool: string; input: unknown } | null; sessionTitle: string | null; model?: string; effort?: string; thinking?: boolean }
   | { type: "turn_events"; events: unknown[] }
   | { type: "title_updated"; title: string }
   | { type: "compact_status"; status: "compacting" | "done" }

package/src/types/chat.ts

@@ -4,8 +4,16 @@ export interface SendMessageOpts {
   images?: Array<{ data: string; mediaType: string }>;
   /** Per-session model override; falls back to provider config model when absent */
   model?: string;
+  /** Override the provider's 1M-context setting for this call (false = never add the
+   *  [1m] suffix). Used by lightweight calls (e.g. the group-chat router) whose small
+   *  model may not support a 1M window. Falls back to provider config when absent. */
+  oneMContext?: boolean;
   /** Per-query turn cap; falls back to provider config max_turns when absent */
   maxTurns?: number;
+  /** Per-session effort override (low|medium|high|xhigh|max); falls back to provider config */
+  effort?: string;
+  /** Per-session thinking budget → SDK maxThinkingTokens; falls back to provider config */
+  maxThinkingTokens?: number;
 }
 
 export interface AIProvider {

package/src/types/config.ts

@@ -67,7 +67,7 @@ export interface AIProviderConfig {
   api_key_env?: string;
   api_key?: string;
   base_url?: string;
-  effort?: "low" | "medium" | "high" | "max";
+  effort?: "low" | "medium" | "high" | "xhigh" | "max";
   max_turns?: number;
   max_budget_usd?: number;
   thinking_budget_tokens?: number;
@@ -97,7 +97,7 @@ export const DEFAULT_CONFIG: PpmConfig = {
       claude: {
         type: "agent-sdk",
         api_key_env: "ANTHROPIC_API_KEY",
-        model: "claude-opus-4-8",
+        model: "claude-opus-5",
         effort: "high",
         max_turns: 1000,
         permission_mode: "bypassPermissions",
@@ -120,8 +120,8 @@ export const DEFAULT_CONFIG: PpmConfig = {
 };
 
 const VALID_TYPES = ["agent-sdk", "cli", "mock"] as const;
-const VALID_EFFORTS = ["low", "medium", "high"] as const;
-const VALID_MODELS = ["claude-fable-5", "claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5"] as const;
+const VALID_EFFORTS = ["low", "medium", "high", "xhigh", "max"] as const;
+const VALID_MODELS = ["claude-opus-5", "claude-fable-5", "claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-5", "claude-sonnet-4-6", "claude-haiku-4-5"] as const;
 /** Allowed CLI commands for CLI providers (prevents command injection) */
 const VALID_CLI_COMMANDS = ["cursor-agent", "codex", "gemini"] as const;
 /** Only these values are allowed for default_provider in config */
@@ -241,12 +241,7 @@ export function sanitizeConfig(config: PpmConfig): boolean {
     dirty = true;
   }
 
-  // Downgrade "max" effort → "high" (not available for Claude.ai subscribers)
   for (const provider of Object.values(config.ai.providers)) {
-    if ((provider as any).effort === "max") {
-      provider.effort = "high";
-      dirty = true;
-    }
     // Fix invalid permission_mode
     if (provider.permission_mode != null && !["default", "acceptEdits", "plan", "bypassPermissions"].includes(provider.permission_mode)) {
       provider.permission_mode = "bypassPermissions";

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/chat/chat-tab.tsx

@@ -112,6 +112,10 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
     sessionTitle,
     model,
     setModel,
+    effort,
+    setEffort,
+    thinking,
+    setThinking,
     sendMessage,
     respondToApproval,
     cancelStreaming,
@@ -681,6 +685,10 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
             onProviderChange={!sessionId ? setProviderId : undefined}
             model={model}
             onModelChange={setModel}
+            effort={effort}
+            onEffortChange={setEffort}
+            thinking={thinking}
+            onThinkingChange={setThinking}
           />
         )}
       </div>

package/src/web/components/chat/message-input.tsx

@@ -7,7 +7,7 @@ import { isImageFile } from "@/lib/file-support";
 import { AttachmentChips } from "./attachment-chips";
 import { ModeSelector, getModeLabel, getModeIcon } from "./mode-selector";
 import { ProviderSelector } from "./provider-selector";
-import { ModelSelector } from "./model-selector";
+import { ModelThinkingSelector } from "./model-thinking-selector";
 import type { SlashItem } from "./slash-command-picker";
 import type { FileNode } from "../../../types/project";
 import { useFileStore } from "@/stores/file-store";
@@ -69,6 +69,14 @@ interface MessageInputProps {
   model?: string | null;
   /** Model change handler — undefined when no active session */
   onModelChange?: (model: string) => void;
+  /** Current per-session effort (null = provider default) */
+  effort?: string | null;
+  /** Effort change handler */
+  onEffortChange?: (effort: string) => void;
+  /** Current per-session thinking on/off */
+  thinking?: boolean;
+  /** Thinking toggle handler */
+  onThinkingChange?: (enabled: boolean) => void;
 }
 
 export const MessageInput = memo(function MessageInput({
@@ -96,6 +104,10 @@ export const MessageInput = memo(function MessageInput({
   onProviderChange,
   model,
   onModelChange,
+  effort,
+  onEffortChange,
+  thinking,
+  onThinkingChange,
 }: MessageInputProps) {
   // Uncontrolled textarea: value lives in DOM + ref, not React state.
   // Only `hasText` state triggers re-renders (empty↔non-empty for send button).
@@ -700,9 +712,13 @@ export const MessageInput = memo(function MessageInput({
             />
           )}
           {onModelChange && projectName && (
-            <ModelSelector
-              value={model ?? null}
-              onChange={onModelChange}
+            <ModelThinkingSelector
+              model={model ?? null}
+              effort={effort ?? null}
+              thinking={thinking ?? false}
+              onModelChange={onModelChange}
+              onEffortChange={onEffortChange ?? (() => {})}
+              onThinkingChange={onThinkingChange ?? (() => {})}
               projectName={projectName}
               providerId={providerId ?? "claude"}
               disabled={isStreaming}
@@ -795,9 +811,13 @@ export const MessageInput = memo(function MessageInput({
               />
             )}
             {onModelChange && projectName && (
-              <ModelSelector
-                value={model ?? null}
-                onChange={onModelChange}
+              <ModelThinkingSelector
+                model={model ?? null}
+                effort={effort ?? null}
+                thinking={thinking ?? false}
+                onModelChange={onModelChange}
+                onEffortChange={onEffortChange ?? (() => {})}
+                onThinkingChange={onThinkingChange ?? (() => {})}
                 projectName={projectName}
                 providerId={providerId ?? "claude"}
                 disabled={isStreaming}