@hienlh/ppm 0.17.16 → 0.17.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hienlh/ppm",
-  "version": "0.17.16",
+  "version": "0.17.18",
   "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "author": "hienlh",
   "license": "SEE LICENSE IN LICENSE",

package/spike-group-channel.mjs

@@ -0,0 +1,156 @@
+// Feasibility spike v2 — shared-channel group DISCUSSION (member<->member).
+// Throwaway diagnostic. Mirrors test-tool.mjs (direct provider, no DB/UI).
+//
+// Implements the agreed model:
+//   - shared broadcast channel (in-memory bus) — all agents see it
+//   - windowed context injection (last K messages) per turn
+//   - speaker selection: @mention-driven, leader as fallback facilitator
+//   - talk = sequential turns; termination = leader "DONE:" OR max-turns cap OR budget-ish (turn cap)
+//   - prints the full GROUP CHAT HISTORY at the end (what the user asked to see)
+//
+// Usage:  bun spike-group-channel.mjs [projectPath] [--turns N] [--keep]
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readdir, mkdir, copyFile, rm, stat } from "node:fs/promises";
+import { ClaudeAgentSdkProvider } from "./src/providers/claude-agent-sdk.ts";
+import { configService } from "./src/services/config.service.ts";
+
+configService.load();
+delete process.env.CLAUDECODE;
+
+const projectPath = process.argv.find((a, i) => i >= 2 && !a.startsWith("--")) || process.cwd();
+const KEEP = process.argv.includes("--keep");
+const turnsArg = process.argv.indexOf("--turns");
+const MAX_TURNS = turnsArg > -1 ? Number(process.argv[turnsArg + 1]) : 8;
+const WINDOW = 8; // inject last N channel messages
+const TIMEOUT_MS = 120_000;
+const CLAUDE_PROJECTS = join(homedir(), ".claude", "projects");
+const ARCHIVE_DIR = join(homedir(), ".ppm", "teams", "spike", "transcripts");
+
+const provider = new ClaudeAgentSdkProvider();
+const opts = { permissionMode: "bypassPermissions" };
+
+// The group. Leader is a normal participant that also facilitates + finalizes.
+const TEAM = [
+  { name: "lead", role: "the team LEAD. You kick off, keep discussion on track, and are the ONLY one who may finalize." },
+  { name: "alice", role: "a backend engineer who favors simple, minimal schemas (YAGNI)." },
+  { name: "bob", role: "a backend engineer who worries about query flexibility and future needs." },
+];
+
+const TASK =
+  "Agree on how to store the group-chat message bus in PPM: ONE single SQLite table, " +
+  "or SEPARATE tables per concern. Discuss briefly, then lead finalizes with the decision + 1 reason.";
+
+const sessions = {}; // name -> session
+const channel = []; // { from, to, text }
+
+function log(...a) { console.log(...a); }
+function hr(t) { log("\n" + "=".repeat(64) + "\n" + t + "\n" + "=".repeat(64)); }
+
+async function run(sessionId, prompt) {
+  const abort = new AbortController();
+  const timer = setTimeout(() => abort.abort(), TIMEOUT_MS);
+  let full = "", error = null;
+  try {
+    for await (const ev of provider.sendMessage(sessionId, prompt, { ...opts, signal: abort.signal })) {
+      if (abort.signal.aborted) break;
+      if (ev.type === "text") full += ev.content ?? "";
+      else if (ev.type === "error") error = ev.message;
+      else if (ev.type === "done") break;
+    }
+  } catch (e) { error = e instanceof Error ? e.message : String(e); }
+  clearTimeout(timer);
+  return { text: full.trim(), error };
+}
+
+function windowed() {
+  return channel.slice(-WINDOW)
+    .map((m) => `${m.from} -> ${m.to}: ${m.text}`)
+    .join("\n") || "(channel empty)";
+}
+
+function turnPrompt(member, isFinalForced) {
+  const others = TEAM.filter((t) => t.name !== member.name).map((t) => t.name).join(", ");
+  return (
+    `You are "${member.name}", ${member.role}\n` +
+    `Team task: ${TASK}\n\n` +
+    `TEAM CHANNEL (recent, others: ${others}):\n${windowed()}\n\n` +
+    `Reply as ${member.name} in MAX 2 sentences. Address a teammate with @name (e.g. @bob).\n` +
+    (member.name === "lead"
+      ? (isFinalForced
+          ? `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 lead finalizes.`)
+  );
+}
+
+// pick next speaker from an @mention in text; else fall back to lead.
+function nextSpeaker(text, current) {
+  const names = TEAM.map((t) => t.name);
+  const m = text.toLowerCase().match(/@(\w+)/);
+  if (m && names.includes(m[1]) && m[1] !== current) return m[1];
+  return current === "lead" ? "alice" : "lead"; // fallback keeps it moving
+}
+
+async function findJsonl(id) {
+  let dirs = [];
+  try { dirs = await readdir(CLAUDE_PROJECTS); } catch { return null; }
+  for (const d of dirs) {
+    const p = join(CLAUDE_PROJECTS, d, `${id}.jsonl`);
+    try { await stat(p); return p; } catch {}
+  }
+  return null;
+}
+async function archiveAndDelete(id) {
+  const src = await findJsonl(id);
+  if (!src) return;
+  await mkdir(ARCHIVE_DIR, { recursive: true });
+  await copyFile(src, join(ARCHIVE_DIR, `${id}.jsonl`));
+  await rm(src, { force: true });
+}
+
+// ---------------------------------------------------------------------------
+hr(`SPIKE v2: shared-channel group discussion | project=${projectPath} | maxTurns=${MAX_TURNS}`);
+
+for (const m of TEAM) {
+  sessions[m.name] = await provider.createSession({ title: `spike-${m.name}`, projectPath });
+  log(`  ${m.name} session: ${sessions[m.name].id}`);
+}
+
+let speaker = "lead";
+let done = false;
+for (let turn = 1; turn <= MAX_TURNS && !done; turn++) {
+  const member = TEAM.find((t) => t.name === speaker);
+  const forceFinal = turn === MAX_TURNS && speaker === "lead";
+  const { text, error } = await run(sessions[speaker].id, turnPrompt(member, forceFinal));
+  if (error) { log(`\n[turn ${turn}] ${speaker} ERROR: ${error}`); break; }
+
+  const isDone = speaker === "lead" && /^\s*DONE:/i.test(text);
+  const to = (text.match(/@(\w+)/) || [])[1] || "all";
+  channel.push({ from: speaker, to: isDone ? "all" : to, text });
+  log(`\n[turn ${turn}] ${speaker} -> ${isDone ? "all" : to}:\n  ${text.replace(/\n/g, "\n  ")}`);
+
+  if (isDone) { done = true; break; }
+
+  // If max-turns is about to hit and lead hasn't spoken, force lead next to finalize.
+  speaker = (turn === MAX_TURNS - 1) ? "lead" : nextSpeaker(text, speaker);
+}
+
+if (!done) log("\n(!) discussion hit turn cap without explicit DONE — see last lead message");
+
+// ---- what the user asked to see: the group chat history ----
+hr("GROUP CHAT HISTORY (channel transcript)");
+for (const m of channel) {
+  log(`[${m.from} -> ${m.to}] ${m.text}`);
+  log("");
+}
+
+// ---- Option A+ cleanup (proves clean-up path again) ----
+if (!KEEP) {
+  hr("Option A+ archive-and-delete");
+  for (const m of TEAM) { await archiveAndDelete(sessions[m.name].id); }
+  log(`archived to ${ARCHIVE_DIR}, raw JSONL removed from ~/.claude/projects`);
+}
+
+hr(`RESULT: ${done ? "CONVERGED with leader DONE" : "capped"} | ${channel.length} messages | member<->member exchange demonstrated`);

package/spike-group-chat.mjs

@@ -0,0 +1,181 @@
+// Feasibility spike for the native PPM group-chat engine.
+// Throwaway diagnostic — NOT production code. Mirrors test-tool.mjs (direct provider, no DB/UI).
+//
+// Proves, headless & real (no mocks):
+//   1. Parallel multi-agent: 1 leader + N member sessions on the SAME project cwd.
+//   2. Leader-driven task split -> dispatch to members -> collect (the orchestration loop).
+//   3. Summary-vs-full (#2): capture short summary for the feed + full text kept aside.
+//   4. Option A+ (#3): archive each member JSONL to ~/.ppm/teams/<group>/transcripts/,
+//      then delete the raw JSONL from ~/.claude/projects so CLI/VSCode stay clean.
+//   5. Synthesis: feed member summaries back to the leader for a final group answer.
+//
+// Usage:  bun spike-group-chat.mjs [projectPath] [--keep]
+//   --keep : skip the archive+delete step (leave raw JSONLs in place)
+
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { readdir, mkdir, copyFile, rm, stat } from "node:fs/promises";
+import { ClaudeAgentSdkProvider } from "./src/providers/claude-agent-sdk.ts";
+import { configService } from "./src/services/config.service.ts";
+
+configService.load();
+delete process.env.CLAUDECODE; // avoid nested-session error
+
+const projectPath = process.argv.find((a, i) => i >= 2 && !a.startsWith("--")) || process.cwd();
+const KEEP = process.argv.includes("--keep");
+const GROUP = "spike";
+const CLAUDE_PROJECTS = join(homedir(), ".claude", "projects");
+const ARCHIVE_DIR = join(homedir(), ".ppm", "teams", GROUP, "transcripts");
+const TIMEOUT_MS = 180_000;
+
+const provider = new ClaudeAgentSdkProvider();
+const opts = { permissionMode: "bypassPermissions" };
+const results = {}; // criterion -> boolean
+
+// The user's "task" given to the group.
+const TASK =
+  "Working from the CLAUDE.md in this project, report two facts: (a) the runtime used, " +
+  "(b) the command to run tests.";
+
+function log(...a) { console.log(...a); }
+function hr(t) { log("\n" + "=".repeat(64) + "\n" + t + "\n" + "=".repeat(64)); }
+
+// Run one prompt on a session, capture summary (last assistant text) + full text.
+async function run(sessionId, prompt) {
+  const abort = new AbortController();
+  const timer = setTimeout(() => abort.abort(), TIMEOUT_MS);
+  let full = "", last = "", error = null;
+  try {
+    for await (const ev of provider.sendMessage(sessionId, prompt, { ...opts, signal: abort.signal })) {
+      if (abort.signal.aborted) break;
+      if (ev.type === "text") { last = ev.content ?? ""; full += ev.content ?? ""; }
+      else if (ev.type === "error") { error = ev.message; }
+      else if (ev.type === "done") break;
+    }
+  } catch (e) { error = e instanceof Error ? e.message : String(e); }
+  clearTimeout(timer);
+  return { summary: (last || full).trim().slice(0, 400), full: full.trim(), error };
+}
+
+// Locate <sessionId>.jsonl anywhere under ~/.claude/projects (avoids slug guessing).
+async function findJsonl(sessionId) {
+  let dirs = [];
+  try { dirs = await readdir(CLAUDE_PROJECTS); } catch { return null; }
+  for (const d of dirs) {
+    const p = join(CLAUDE_PROJECTS, d, `${sessionId}.jsonl`);
+    try { await stat(p); return p; } catch { /* keep looking */ }
+  }
+  return null;
+}
+
+// Option A+: archive JSONL to PPM store, then delete the raw file.
+async function archiveAndDelete(sessionId) {
+  const src = await findJsonl(sessionId);
+  if (!src) return { archived: false, deleted: false, reason: "raw JSONL not found" };
+  await mkdir(ARCHIVE_DIR, { recursive: true });
+  const dest = join(ARCHIVE_DIR, `${sessionId}.jsonl`);
+  await copyFile(src, dest);
+  const archived = await stat(dest).then(() => true).catch(() => false);
+  await rm(src, { force: true });
+  const stillThere = await stat(src).then(() => true).catch(() => false);
+  return { archived, deleted: !stillThere, dest };
+}
+
+// ---------------------------------------------------------------------------
+hr(`SPIKE: native group-chat engine  |  project=${projectPath}  |  keep=${KEEP}`);
+
+// --- Criterion 1 + 2: leader session decides the work split -----------------
+hr("STEP 1 — Leader splits the task");
+const leader = await provider.createSession({ title: "spike-leader", projectPath });
+log(`leader session: ${leader.id}`);
+
+const splitPrompt =
+  `You are the LEADER of an agent team on this project. User task:\n"${TASK}"\n\n` +
+  `Split it into EXACTLY 2 independent subtasks. Reply with ONLY two lines, no preamble:\n` +
+  `M1: <subtask one>\nM2: <subtask two>`;
+const split = await run(leader.id, splitPrompt);
+log("leader raw:\n" + split.full);
+
+let subtasks = split.full
+  .split("\n")
+  .map((l) => l.replace(/^M\d+:\s*/i, "").trim())
+  .filter((l) => l && /subtask|report|find|read|runtime|test|command|CLAUDE/i.test(l))
+  .slice(0, 2);
+if (subtasks.length < 2) {
+  log("!! parse fallback — leader output not in expected format, using default split");
+  subtasks = [
+    "Read CLAUDE.md and report ONLY the runtime used. One sentence.",
+    "Read CLAUDE.md and report ONLY the command to run tests. One sentence.",
+  ];
+}
+results["1_leader_split"] = subtasks.length === 2;
+log("subtasks:", subtasks);
+
+// --- Criterion 1 (parallel) + 3 (summary/full): members work concurrently ---
+hr("STEP 2 — Members work in parallel (own sessions)");
+const members = await Promise.all(
+  subtasks.map((_, i) => provider.createSession({ title: `spike-m${i + 1}`, projectPath })),
+);
+members.forEach((m, i) => log(`member${i + 1} session: ${m.id}`));
+
+const memberRuns = await Promise.all(
+  subtasks.map((st, i) =>
+    run(members[i].id, `${st}\n\nReply with a 1-2 sentence summary only.`),
+  ),
+);
+
+results["2_parallel_members"] = memberRuns.every((r) => !r.error);
+results["3_summary_vs_full"] = memberRuns.every((r) => r.summary.length > 0 && r.full.length >= r.summary.length);
+memberRuns.forEach((r, i) => {
+  log(`\n--- member${i + 1} ---`);
+  if (r.error) log(`  ERROR: ${r.error}`);
+  log(`  FEED (summary): ${r.summary}`);
+  log(`  FULL kept aside: ${r.full.length} chars (hidden from feed)`);
+});
+
+// --- Criterion 4: Option A+ archive-and-delete ------------------------------
+hr("STEP 3 — Option A+ archive-and-delete member transcripts");
+let aPlusOk = true;
+if (KEEP) {
+  log("(--keep) skipping archive/delete");
+  aPlusOk = false;
+} else {
+  for (const m of members) {
+    const res = await archiveAndDelete(m.id);
+    log(`member ${m.id}: archived=${res.archived} deleted=${res.deleted}` + (res.reason ? ` (${res.reason})` : ""));
+    if (!res.archived || !res.deleted) aPlusOk = false;
+  }
+  log(`archive dir: ${ARCHIVE_DIR}`);
+}
+results["4_archive_delete"] = aPlusOk;
+
+// --- Criterion 5: leader synthesizes member summaries -----------------------
+hr("STEP 4 — Leader synthesizes final group answer");
+const synthPrompt =
+  `Your members reported:\n` +
+  memberRuns.map((r, i) => `- member${i + 1}: ${r.summary}`).join("\n") +
+  `\n\nSynthesize a short final answer to the user's task.`;
+const synth = await run(leader.id, synthPrompt);
+log("FINAL group answer:\n" + synth.summary);
+results["5_synthesis"] = !synth.error && synth.summary.length > 0;
+
+// Clean up leader too (it created a JSONL).
+if (!KEEP) { await archiveAndDelete(leader.id).catch(() => {}); }
+
+// --- Verdict ----------------------------------------------------------------
+hr("VERDICT");
+const labels = {
+  "1_leader_split": "Leader splits task into subtasks",
+  "2_parallel_members": "Members run in parallel (own sessions)",
+  "3_summary_vs_full": "Summary (feed) vs full (hidden) captured",
+  "4_archive_delete": "Option A+ archive-and-delete works",
+  "5_synthesis": "Leader synthesizes final answer",
+};
+let allPass = true;
+for (const [k, label] of Object.entries(labels)) {
+  const ok = results[k];
+  if (!ok && !(k === "4_archive_delete" && KEEP)) allPass = false;
+  log(`  ${ok ? "PASS" : (k === "4_archive_delete" && KEEP ? "SKIP" : "FAIL")}  ${label}`);
+}
+hr(allPass ? "FEASIBLE — core engine works end-to-end" : "NEEDS ATTENTION — see failures above");
+process.exit(allPass ? 0 : 1);

package/src/server/routes/group-chat.ts

@@ -6,15 +6,22 @@ import {
   listGroups,
   deleteGroup,
   addMember,
+  getMember,
+  updateMember,
+  removeMember,
   listMembers,
   readMessages,
+  setGroupMaxTurns,
 } from "../../services/group-chat/group-chat.store.ts";
 import { groupChatService } from "../../services/group-chat/group-chat.service.ts";
-import { readArchivedTranscript } from "../../services/group-chat/transcript-archive.ts";
-import type { AddMemberInput } from "../../types/group-chat.ts";
+import { resolveTranscriptPath } from "../../services/group-chat/transcript-archive.ts";
+import { parseJsonlTranscript, parseTranscriptConfig } from "../../services/jsonl-transcript-parser.ts";
+import type { AddMemberInput, UpdateMemberInput } from "../../types/group-chat.ts";
 
 /** Allowlist: group ids are UUIDs — alphanumeric + hyphens only. */
 const VALID_GROUP_ID = /^[a-zA-Z0-9-]+$/;
+/** Member ids are UUIDs too. */
+const VALID_MEMBER_ID = /^[a-zA-Z0-9-]+$/;
 /** Session refs are Claude session UUIDs. */
 const VALID_SESSION_REF = /^[a-zA-Z0-9-]+$/;
 
@@ -79,6 +86,101 @@ groupChatRoutes.get("/:id", (c) => {
   return c.json(ok({ ...group, members: listMembers(id) }));
 });
 
+// Group settings (reply-burst cap) -----------------------------------------
+groupChatRoutes.patch("/:id", async (c) => {
+  const id = c.req.param("id");
+  if (!VALID_GROUP_ID.test(id)) return c.json(err("Invalid group id"), 400);
+  if (!getGroup(id)) return c.json(err("Group not found"), 404);
+  let body: { maxTurns?: number };
+  try { body = await c.req.json(); } catch { return c.json(err("Invalid JSON body"), 400); }
+  if (body.maxTurns !== undefined) {
+    const n = Math.floor(Number(body.maxTurns));
+    if (!Number.isFinite(n) || n < 1 || n > 50) return c.json(err("maxTurns must be 1–50"), 400);
+    setGroupMaxTurns(id, n);
+  }
+  return c.json(ok({ ...getGroup(id)!, members: listMembers(id) }));
+});
+
+// Member management (add / update / remove) -------------------------------
+// Invariant: a group always has exactly one leader and at least one member.
+
+groupChatRoutes.post("/:id/members", async (c) => {
+  const id = c.req.param("id");
+  if (!VALID_GROUP_ID.test(id)) return c.json(err("Invalid group id"), 400);
+  if (!getGroup(id)) return c.json(err("Group not found"), 404);
+
+  let body: { role?: string; name?: string; persona?: string; model?: string; color?: string };
+  try { body = await c.req.json(); } catch { return c.json(err("Invalid JSON body"), 400); }
+  const name = body.name?.trim();
+  if (!name) return c.json(err("member name is required"), 400);
+  const role = body.role === "leader" ? "leader" : "member";
+
+  // Promoting a new leader demotes the current one (keep exactly one leader).
+  if (role === "leader") {
+    for (const m of listMembers(id)) {
+      if (m.role === "leader") updateMember(m.id, { role: "member" });
+    }
+  }
+  const input: AddMemberInput = {
+    groupId: id, role, name,
+    persona: body.persona ?? null, model: body.model ?? null, color: body.color ?? null,
+  };
+  return c.json(ok(addMember(input)));
+});
+
+groupChatRoutes.patch("/:id/members/:memberId", async (c) => {
+  const id = c.req.param("id");
+  const memberId = c.req.param("memberId");
+  if (!VALID_GROUP_ID.test(id) || !VALID_MEMBER_ID.test(memberId)) return c.json(err("Invalid id"), 400);
+  if (!getGroup(id)) return c.json(err("Group not found"), 404);
+  const member = getMember(memberId);
+  if (!member || member.groupId !== id) return c.json(err("Member not found"), 404);
+
+  let body: { role?: string; name?: string; persona?: string; model?: string; color?: string };
+  try { body = await c.req.json(); } catch { return c.json(err("Invalid JSON body"), 400); }
+
+  const patch: UpdateMemberInput = {};
+  if (body.name !== undefined) {
+    const n = body.name.trim();
+    if (!n) return c.json(err("member name cannot be empty"), 400);
+    patch.name = n;
+  }
+  if (body.persona !== undefined) patch.persona = body.persona || null;
+  if (body.model !== undefined) patch.model = body.model || null;
+  if (body.color !== undefined) patch.color = body.color || null;
+
+  if (body.role !== undefined) {
+    if (body.role !== "leader" && body.role !== "member") return c.json(err("invalid role"), 400);
+    if (body.role === "leader") {
+      // Demote the current leader(s) before promoting this member.
+      for (const m of listMembers(id)) {
+        if (m.role === "leader" && m.id !== memberId) updateMember(m.id, { role: "member" });
+      }
+      patch.role = "leader";
+    } else if (member.role === "leader") {
+      return c.json(err("promote another member to leader before demoting this one"), 400);
+    }
+  }
+  return c.json(ok(updateMember(memberId, patch)));
+});
+
+groupChatRoutes.delete("/:id/members/:memberId", async (c) => {
+  const id = c.req.param("id");
+  const memberId = c.req.param("memberId");
+  if (!VALID_GROUP_ID.test(id) || !VALID_MEMBER_ID.test(memberId)) return c.json(err("Invalid id"), 400);
+  const group = getGroup(id);
+  if (!group) return c.json(err("Group not found"), 404);
+  const member = getMember(memberId);
+  if (!member || member.groupId !== id) return c.json(err("Member not found"), 404);
+
+  const members = listMembers(id);
+  if (members.length <= 1) return c.json(err("a group needs at least one member"), 400);
+  if (member.role === "leader") return c.json(err("reassign the leader before removing this member"), 400);
+  await groupChatService.archiveMemberSession(group.name, member.sessionId);
+  removeMember(memberId);
+  return c.json(ok({ deleted: memberId }));
+});
+
 // Feed (windowed/paginated) ------------------------------------------------
 groupChatRoutes.get("/:id/feed", (c) => {
   const id = c.req.param("id");
@@ -93,8 +195,9 @@ groupChatRoutes.get("/:id/feed", (c) => {
   return c.json(ok({ messages }));
 });
 
-// Archived transcript for a member session (powers "view full") -----------
-groupChatRoutes.get("/:id/transcript", (c) => {
+// Archived transcript for a member session (powers "view full") — parsed into
+// chat-style messages (text/thinking/tool_use/tool_result) + input config.
+groupChatRoutes.get("/:id/transcript", async (c) => {
   const id = c.req.param("id");
   if (!VALID_GROUP_ID.test(id)) return c.json(err("Invalid group id"), 400);
   const group = getGroup(id);
@@ -104,9 +207,13 @@ groupChatRoutes.get("/:id/transcript", (c) => {
   if (!sessionRef || !VALID_SESSION_REF.test(sessionRef)) {
     return c.json(err("Invalid sessionRef"), 400);
   }
-  const content = readArchivedTranscript(sessionRef, group.name);
-  if (content === null) return c.json(err("Transcript not found"), 404);
-  return c.json(ok({ content }));
+  const path = await resolveTranscriptPath(sessionRef, group.name);
+  if (path === null) return c.json(err("Transcript not found"), 404);
+  const [messages, config] = await Promise.all([
+    parseJsonlTranscript(path),
+    parseTranscriptConfig(path),
+  ]);
+  return c.json(ok({ messages, config }));
 });
 
 // Send a message → starts / feeds the engine ------------------------------
@@ -150,11 +257,13 @@ groupChatRoutes.post("/:id/resume", async (c) => {
 });
 
 // Delete -------------------------------------------------------------------
-groupChatRoutes.delete("/:id", (c) => {
+groupChatRoutes.delete("/:id", async (c) => {
   const id = c.req.param("id");
   if (!VALID_GROUP_ID.test(id)) return c.json(err("Invalid group id"), 400);
   if (!getGroup(id)) return c.json(err("Group not found"), 404);
-  groupChatService.stop(id);
+  // Archive member sessions (keep-alive means they live until now) BEFORE the store
+  // cascade removes the member rows.
+  await groupChatService.archiveAndForget(id);
   deleteGroup(id);
   return c.json(ok({ deleted: id }));
 });

package/src/services/group-chat/agent-runner.ts

@@ -10,8 +10,8 @@ export interface ChatBackend {
     providerId: string,
     sessionId: string,
     prompt: string,
-    opts?: { permissionMode?: string; signal?: AbortSignal },
-  ): AsyncIterable<{ type: string; content?: string; costUsd?: number; usage?: { costUsd?: number } }>;
+    opts?: { permissionMode?: string; signal?: AbortSignal; model?: string; oneMContext?: boolean },
+  ): AsyncIterable<{ type: string; content?: string; message?: string; costUsd?: number; usage?: { costUsd?: number } }>;
 }
 
 export interface AgentRunResult {
@@ -38,12 +38,25 @@ export async function runAgentTurn(
 
   const events = backend.sendMessage(providerId, member.sessionId, prompt, {
     permissionMode: "bypassPermissions",
+    // Honor the member's configured model (e.g. haiku); falls back to the provider
+    // default when unset. Without this the turn always used the provider default.
+    model: member.model ?? undefined,
+    // Group turns are short/windowed — never request the 1M-context beta. If the user's
+    // config has context_1m on, the [1m] model suffix triggers "long context beta not
+    // available for this subscription" (HTTP 400). Opt out here (like the router).
+    oneMContext: false,
     signal: opts.signal,
   });
 
   for await (const ev of events) {
     if (opts.signal?.aborted) break;
     if (ev.type === "text") full += ev.content ?? "";
+    else if (ev.type === "error") {
+      // Provider errors (auth, rate limit, crash) are terminal for this turn.
+      // Throw so the turn loop aborts and surfaces the error to the UI instead
+      // of appending an empty message and looping to the turn cap.
+      throw new Error(ev.message || `agent turn failed for ${member.name}`);
+    }
     else if (ev.type === "done") {
       costUsd = ev.costUsd ?? ev.usage?.costUsd;
       break;

package/src/services/group-chat/context-window.ts

@@ -41,3 +41,18 @@ export function renderWindow(window: GroupMessage[]): string {
   if (window.length === 0) return "(channel empty)";
   return window.map(line).join("\n");
 }
+
+/** Full turn text stored on the bus (`data.full`), falling back to the short feed
+ *  summary for legacy rows that predate full-text storage. */
+export function fullText(m: GroupMessage): string {
+  const full = (m.data as { full?: string } | null)?.full;
+  return typeof full === "string" && full.length > 0 ? full : (m.summary ?? "");
+}
+
+/** Render messages using FULL text (not the 600-char feed clip) for prompt injection. */
+export function renderFull(messages: GroupMessage[]): string {
+  if (messages.length === 0) return "(channel empty)";
+  return messages
+    .map((m) => `${m.fromMember} -> ${m.toMember ?? "all"}: ${fullText(m)}`.trim())
+    .join("\n");
+}