@harborgroup/my-team 0.3.0 → 0.4.1

package/README.md

@@ -50,6 +50,14 @@ Every raw request sent to the Claude Agent SDK (including the exact system promp
 
 When Iris (or your CEO) wants a structured answer rather than free text, it asks via a real inline widget — text input, single-select, or multi-select (with an automatic "Other" option) — instead of plain prose. This is a text convention the model follows (a fenced `question-widget` block the frontend parses out of the stream and replaces with an interactive card), not an MCP tool call: a real custom-tool + elicitation round trip was tested directly against the installed SDK and confirmed not to work yet (Claude Code's MCP-client role doesn't currently declare elicitation capability), so this achieves the same UX without that dependency. The main composer is disabled while a widget is awaiting an answer.
 
+## Chat history
+
+The visible conversation — not just Claude's own session context — is persisted to `.my-team/chat-history.jsonl` and replayed on load, so both a page reload and a full server restart show prior messages instead of starting over. A widget that was already answered replays locked to that answer; a widget left unanswered when the server stopped (e.g. it was killed mid-conversation) replays as a genuinely live, answerable widget, composer gating included, picking up exactly where things left off. Unlike `profile.json`, this file is gitignored automatically (it can contain arbitrary conversation content) — `init` sets this up, and a plain `npm run team` self-heals the `.gitignore` too, so upgrading an existing install doesn't require re-running `init`.
+
+## Staying out of its own way
+
+This dashboard is itself an ordinary Node process running inside the repo it manages. If your CEO ever needs to restart a dev server, broadly killing every node process (`taskkill /F /IM node.exe`, `killall node`) would take the dashboard down with it — so the system prompt explicitly warns against that and points at `.my-team/server.pid` (also gitignored) to identify and exclude the dashboard's own process. The server also logs and continues past uncaught exceptions rather than crashing the whole session.
+
 ## Status
 
-v1.5: CLI-auth onboarding + conversational company/CEO-persona onboarding + Slack-style chat shell with real streaming + per-message model/effort selection + update checker + structured logging + inline clarifying-question widgets. No persisted chat history across restarts, no multi-user support, no `#general` backend (sidebar placeholder only).
+v1.6: CLI-auth onboarding + conversational company/CEO-persona onboarding + Slack-style chat shell with real streaming + per-message model/effort selection + update checker + structured logging + inline clarifying-question widgets + persisted chat history + dev-server-restart safety guardrail. No multi-user support, no `#general` backend (sidebar placeholder only).

package/dist/init.js

@@ -16,6 +16,23 @@ function addTeamScript(repoPackageJsonPath) {
     writeFileSync(repoPackageJsonPath, JSON.stringify(pkg, null, 2) + '\n');
     console.log('Added "npm run team" script to package.json.');
 }
+// Only these two files are ignored — .my-team/profile.json is deliberately
+// committed (see README: it's shared, non-sensitive team config, the same
+// category as CLAUDE.md). Chat history can contain arbitrary conversation
+// content and server.pid is per-machine-run ephemeral state; neither
+// belongs in git.
+const GITIGNORE_ENTRIES = ['.my-team/chat-history.jsonl', '.my-team/server.pid'];
+export function ensureGitignore(cwd) {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    const existing = existsSync(gitignorePath) ? readFileSync(gitignorePath, 'utf-8') : '';
+    const existingLines = new Set(existing.split('\n').map((l) => l.trim()));
+    const missing = GITIGNORE_ENTRIES.filter((entry) => !existingLines.has(entry));
+    if (!missing.length)
+        return;
+    const separator = existing && !existing.endsWith('\n') ? '\n' : '';
+    writeFileSync(gitignorePath, existing + separator + missing.join('\n') + '\n');
+    console.log(`Added ${missing.join(', ')} to .gitignore.`);
+}
 export async function runInit(cwd) {
     const repoPackageJsonPath = path.join(cwd, 'package.json');
     if (!existsSync(repoPackageJsonPath)) {
@@ -30,5 +47,6 @@ export async function runInit(cwd) {
         return;
     }
     addTeamScript(repoPackageJsonPath);
+    ensureGitignore(cwd);
     console.log('Done — run "npm run team" to launch.');
 }

package/dist/server/chat-history.js

@@ -0,0 +1,39 @@
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { getProfileDir } from './profile.js';
+function getHistoryPath(cwd) {
+    return path.join(getProfileDir(cwd), 'chat-history.jsonl');
+}
+export async function appendHistory(cwd, entry) {
+    const dir = getProfileDir(cwd);
+    try {
+        await mkdir(dir, { recursive: true });
+        await appendFile(getHistoryPath(cwd), JSON.stringify(entry) + '\n', 'utf-8');
+    }
+    catch {
+        // History is a nice-to-have replay, not a source of truth — never let a
+        // disk error here interrupt the actual conversation.
+    }
+}
+export async function readHistory(cwd) {
+    let raw;
+    try {
+        raw = await readFile(getHistoryPath(cwd), 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            entries.push(JSON.parse(line));
+        }
+        catch {
+            // Skip a corrupted line (e.g. a torn write from a crash) rather than
+            // discarding the entire history.
+        }
+    }
+    return entries;
+}

package/dist/server/chat-session.js

@@ -1,11 +1,14 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
+import { appendHistory } from './chat-history.js';
 import { sanitizeEnv } from './env.js';
 import { forLog } from './logger.js';
 import { formatProfileForSystemPrompt, getOnboardingSystemPrompt, readProfile } from './profile.js';
 /**
- * One ongoing SDK session per running server process. Conversation history
- * lives only in the CLI's own session store (resumed via session_id) — no
- * disk persistence of our own, lost on server restart (acceptable for v1).
+ * One ongoing SDK session per running server process. Claude's own
+ * conversation context survives via `resume`; the *visible* transcript is
+ * additionally persisted to chat-history.jsonl (see chat-history.ts) so a
+ * page reload or a full server restart both show prior messages instead of
+ * an empty thread.
  */
 export class ChatSession {
     logger;
@@ -23,11 +26,16 @@ export class ChatSession {
             return;
         }
         this.turnInFlight = true;
+        const ts = new Date().toISOString();
+        await appendHistory(cwd, { kind: overrides.isWidgetAnswer ? 'widget-answer' : 'user', text: message, ts });
+        let assistantText = '';
+        let resultModel = '';
+        let resultEffort = '';
         try {
             const profile = await readProfile(cwd);
             const onboarded = profile?.onboardingComplete === true;
             const systemPromptAppend = onboarded
-                ? formatProfileForSystemPrompt(profile)
+                ? formatProfileForSystemPrompt(profile, cwd)
                 : getOnboardingSystemPrompt(cwd);
             // Per-message override wins, then the CEO's configured default, then no
             // override at all (Claude Code picks its own default).
@@ -54,11 +62,14 @@ export class ChatSession {
                     // report what we requested (the UI only ever offers effort levels
                     // the chosen model's own supportedEffortLevels confirms are valid,
                     // so a silent downgrade in practice shouldn't occur).
+                    resultModel = msg.model;
+                    resultEffort = effort ?? '';
                     yield { type: 'meta', sessionId: msg.session_id, model: msg.model, effort: effort ?? '' };
                 }
                 else if (msg.type === 'stream_event') {
                     const event = msg.event;
                     if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
+                        assistantText += event.delta.text;
                         yield { type: 'text-delta', text: event.delta.text };
                     }
                 }
@@ -67,20 +78,32 @@ export class ChatSession {
                     // calls are new information here (tool inputs don't render usefully).
                     for (const block of msg.message.content) {
                         if (block.type === 'tool_use') {
+                            await appendHistory(cwd, { kind: 'tool', name: block.name, ts: new Date().toISOString() });
                             yield { type: 'tool-use', name: block.name };
                         }
                     }
                 }
                 else if (msg.type === 'result') {
                     if (msg.subtype !== 'success') {
+                        await appendHistory(cwd, { kind: 'error', message: msg.subtype, ts: new Date().toISOString() });
                         yield { type: 'error', message: msg.subtype };
                     }
                     yield { type: 'done' };
                 }
             }
+            if (assistantText) {
+                await appendHistory(cwd, {
+                    kind: 'assistant',
+                    text: assistantText,
+                    model: resultModel,
+                    effort: resultEffort,
+                    ts: new Date().toISOString(),
+                });
+            }
         }
         catch (err) {
             this.logger.log({ type: 'chat-error', error: String(err?.message ?? err), stack: err?.stack });
+            await appendHistory(cwd, { kind: 'error', message: String(err?.message ?? err), ts: new Date().toISOString() });
             yield { type: 'error', message: String(err?.message ?? err) };
         }
         finally {

package/dist/server/http-server.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'node:url';
 import { OWN_PACKAGE_NAME } from '../own-package.js';
 import { npmInstall } from '../npm-install.js';
 import { checkAuth } from './auth-check.js';
+import { readHistory } from './chat-history.js';
 import { ChatSession } from './chat-session.js';
 import { readProfile, validateProfileInput, writeProfile } from './profile.js';
 import { tokensMatch } from './token.js';
@@ -78,6 +79,11 @@ export function createServer(options) {
             res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify({ ok }));
             return;
         }
+        if (req.method === 'GET' && url.pathname === '/api/chat/history') {
+            const history = await readHistory(cwd);
+            res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify({ history }));
+            return;
+        }
         if (req.method === 'GET' && url.pathname === '/api/profile') {
             const profile = await readProfile(cwd);
             res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify({ profile }));
@@ -109,11 +115,13 @@ export function createServer(options) {
             let message;
             let model;
             let effort;
+            let isWidgetAnswer;
             try {
                 const body = await readJsonBody(req);
                 message = String(body.message ?? '');
                 model = typeof body.model === 'string' && body.model ? body.model : undefined;
                 effort = typeof body.effort === 'string' && body.effort ? body.effort : undefined;
+                isWidgetAnswer = body.isWidgetAnswer === true;
             }
             catch {
                 res.writeHead(400, { 'Content-Type': 'application/json' }).end(JSON.stringify({ error: 'invalid body' }));
@@ -128,7 +136,7 @@ export function createServer(options) {
                 'Cache-Control': 'no-cache',
                 Connection: 'keep-alive',
             });
-            for await (const event of chatSession.sendTurn(message, cwd, { model, effort })) {
+            for await (const event of chatSession.sendTurn(message, cwd, { model, effort, isWidgetAnswer })) {
                 res.write(`data: ${JSON.stringify(event)}\n\n`);
             }
             res.end();

package/dist/server/profile.js

@@ -115,6 +115,17 @@ const QUESTION_WIDGET_INSTRUCTIONS = `When you want to ask a clarifying question
 {"type": "single_select", "question": "Which best fits?", "options": ["Option A", "Option B"]}
 \`\`\`
 Use "text" for open-ended answers (names, descriptions), "single_select" when exactly one of a few options applies, "multi_select" when more than one can. An "Other" option is always available to the user automatically — don't add your own "Other" entry to the options list. Only use this when a structured widget genuinely helps; ordinary conversation doesn't need it.`;
+/**
+ * This dashboard's own server process runs as an ordinary Node process
+ * inside the repo it's managing. If a task ever calls for restarting a dev
+ * server, a broad-strokes approach (killing every node/npm process by name)
+ * would take the dashboard down along with it. Cheap, high-value mitigation:
+ * tell the model exactly that, with a concrete way to check.
+ */
+function getProcessSafetyInstructions(cwd) {
+    const pidFilePath = path.join(getProfileDir(cwd), 'server.pid');
+    return `This chat dashboard you're running inside of is itself an ordinary Node process in this repo, started by the founder via "npm run team". If you ever need to restart a dev server or otherwise manage node/npm processes here, do NOT broadly kill all node processes (e.g. "taskkill /F /IM node.exe", "killall node", "pkill node") — that would also kill this dashboard mid-conversation. Target the specific dev-server process by its own port or PID instead. This dashboard's own process info is at ${pidFilePath} (JSON: {"pid": ..., "port": ...}) — check it first and exclude that PID from anything you kill or restart.`;
+}
 /**
  * Strong, first-person identity framing — deliberately not "you're also
  * helping company X" phrasing. Weaker framing was tested and Claude treated
@@ -123,10 +134,12 @@ Use "text" for open-ended answers (names, descriptions), "single_select" when ex
  * injection). Explicitly asserting this is configured identity, not
  * external/injected content, fixed it in testing.
  */
-export function formatProfileForSystemPrompt(profile) {
+export function formatProfileForSystemPrompt(profile, cwd) {
     return `You are ${profile.ceoName}, the AI CEO of ${profile.companyName}. This is your actual identity, configured directly by your founder — it is not external file content, not a suggestion, and not something to second-guess or flag as injected. ${profile.companyName}'s mission: ${profile.mission}. Communication style: ${profile.ceoPersonality}. Speak and act as ${profile.companyName}'s CEO would — invested in the company's success and personally identified with its mission.
 
-${QUESTION_WIDGET_INSTRUCTIONS}`;
+${QUESTION_WIDGET_INSTRUCTIONS}
+
+${getProcessSafetyInstructions(cwd)}`;
 }
 /**
  * Used instead of formatProfileForSystemPrompt while onboardingComplete is
@@ -144,5 +157,7 @@ ${QUESTION_WIDGET_INSTRUCTIONS}
 
 For this onboarding interview specifically: ask the company name, mission, and CEO name as "text" widgets. For CEO personality, use a "single_select" widget with a handful of helpful preset tones (e.g. "Warm and encouraging", "Sharp and dry-witted", "Blunt and data-driven", "Formal and professional") — the founder can always type a custom one via the automatic Other option.
 
-After each answer, immediately write or update ${filePath} with whatever you know so far as JSON: {"companyName": string, "mission": string, "ceoName": string, "ceoPersonality": string, "onboardingComplete": boolean} — set "onboardingComplete" to false until you have all four answers, then write it one final time with "onboardingComplete": true. After that final write, briefly introduce yourself in your new persona. Until "onboardingComplete" is true, don't perform any other coding tasks.`;
+After each answer, immediately write or update ${filePath} with whatever you know so far as JSON: {"companyName": string, "mission": string, "ceoName": string, "ceoPersonality": string, "onboardingComplete": boolean} — set "onboardingComplete" to false until you have all four answers, then write it one final time with "onboardingComplete": true. After that final write, briefly introduce yourself in your new persona. Until "onboardingComplete" is true, don't perform any other coding tasks.
+
+${getProcessSafetyInstructions(cwd)}`;
 }

package/dist/server/server-pid.js

@@ -0,0 +1,19 @@
+import { mkdir, unlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { getProfileDir } from './profile.js';
+/**
+ * Lets Claude (or the user) identify the dashboard's own process before
+ * doing anything that might broadly restart or kill node processes in this
+ * repo (e.g. restarting a dev server) — see the system-prompt guardrail in
+ * profile.ts. Written at startup, removed on graceful shutdown.
+ */
+export function getServerPidPath(cwd) {
+    return path.join(getProfileDir(cwd), 'server.pid');
+}
+export async function writeServerPid(cwd, port) {
+    await mkdir(getProfileDir(cwd), { recursive: true });
+    await writeFile(getServerPidPath(cwd), JSON.stringify({ pid: process.pid, port }, null, 2) + '\n', 'utf-8');
+}
+export async function removeServerPid(cwd) {
+    await unlink(getServerPidPath(cwd)).catch(() => { });
+}

package/dist/server/start.js

@@ -1,7 +1,9 @@
 import { spawn } from 'node:child_process';
+import { ensureGitignore } from '../init.js';
 import { OWN_PACKAGE_NAME, OWN_PACKAGE_VERSION } from '../own-package.js';
 import { createServer } from './http-server.js';
 import { createLogger } from './logger.js';
+import { removeServerPid, writeServerPid } from './server-pid.js';
 import { generateToken } from './token.js';
 import { checkForUpdate } from './update-check.js';
 function openBrowser(url) {
@@ -21,10 +23,28 @@ function openBrowser(url) {
         // Fall through — the URL is printed to the terminal regardless.
     }
 }
+function installResilienceHandlers(logger) {
+    // A local dev dashboard staying up through an unexpected error is more
+    // useful than crashing the whole session over it — log and continue
+    // rather than let Node's default "exit on uncaught exception" behavior
+    // take down the UI mid-conversation.
+    process.on('uncaughtException', (err) => {
+        logger.log({ type: 'uncaught-exception', error: String(err?.message ?? err), stack: err?.stack });
+        console.error('my-team: uncaught exception (continuing):', err);
+    });
+    process.on('unhandledRejection', (reason) => {
+        logger.log({ type: 'unhandled-rejection', reason: String(reason) });
+        console.error('my-team: unhandled rejection (continuing):', reason);
+    });
+}
 export async function startServer(cwd) {
     const token = generateToken();
     const portRef = { port: 0 };
     const logger = createLogger(cwd);
+    installResilienceHandlers(logger);
+    // Idempotent — also fixes up repos that ran `init` before this existed,
+    // not just fresh ones, without needing them to re-run init.
+    ensureGitignore(cwd);
     // Fire-and-forget: never block startup on a network round-trip. /api/meta
     // just returns null until this resolves.
     const updateInfoRef = { current: null };
@@ -40,6 +60,12 @@ export async function startServer(cwd) {
             console.log(`my-team is running for ${cwd}`);
             console.log(`Open: ${url}`);
             console.log(`Logging raw requests/responses to: ${logger.filePath}`);
+            writeServerPid(cwd, portRef.port);
+            const shutdown = () => {
+                removeServerPid(cwd).finally(() => process.exit(0));
+            };
+            process.on('SIGINT', shutdown);
+            process.on('SIGTERM', shutdown);
             openBrowser(url);
             resolve();
         });

package/dist/web/app.js

@@ -295,7 +295,12 @@ async function checkStatus() {
     selectPage('messages');
     checkForUpdateBanner(1);
 
-    if (!lastProfile?.onboardingComplete && !onboardingKickedOff) {
+    const hasHistory = await loadHistory();
+    // Only auto-kick off onboarding on a genuinely blank slate — if history
+    // replay already left an open, answerable widget (the conversation
+    // stopped mid-question last time), let the user respond to that instead
+    // of firing a second, duplicate kickoff on top of it.
+    if (!lastProfile?.onboardingComplete && !onboardingKickedOff && !hasHistory) {
       onboardingKickedOff = true;
       kickoffOnboarding();
     }
@@ -367,7 +372,7 @@ function renderMarkdown(text) {
   return html;
 }
 
-function appendMessageRow(kind, name, avatarText, text) {
+function appendMessageRow(kind, name, avatarText, text, tsOverride) {
   const row = document.createElement('div');
   row.className = `msg-row ${kind}`;
 
@@ -383,7 +388,8 @@ function appendMessageRow(kind, name, avatarText, text) {
   meta.textContent = name;
   const time = document.createElement('span');
   time.className = 'msg-time';
-  time.textContent = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+  const d = tsOverride ? new Date(tsOverride) : new Date();
+  time.textContent = d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
   meta.appendChild(time);
 
   const textEl = document.createElement('div');
@@ -399,8 +405,8 @@ function appendMessageRow(kind, name, avatarText, text) {
   return { row, textEl };
 }
 
-function appendUserMessage(text) {
-  appendMessageRow('user', 'You', 'Y', text);
+function appendUserMessage(text, ts) {
+  appendMessageRow('user', 'You', 'Y', text, ts);
 }
 
 let pendingWidgetCount = 0;
@@ -510,7 +516,7 @@ class AssistantContentRenderer {
       if (answered) return;
       answered = true;
       setPendingWidget(-1);
-      streamChat(messageText, { showUserBubble: false });
+      streamChat(messageText, { showUserBubble: false, isWidgetAnswer: true });
     });
     this.widgetPlaceholderEl.replaceWith(widgetEl);
     this.widgetPlaceholderEl = null;
@@ -539,7 +545,11 @@ class AssistantContentRenderer {
   }
 }
 
-function createQuestionWidget(data, onAnswer) {
+// lockedAnswer renders the widget immediately in its answered state with no
+// interactive controls — used when replaying history, since the underlying
+// SDK session has already moved past that turn and re-answering it live
+// would be meaningless (or worse, confusing) rather than just cosmetic.
+function createQuestionWidget(data, onAnswer, lockedAnswer) {
   const card = document.createElement('div');
   card.className = 'question-widget';
 
@@ -559,7 +569,12 @@ function createQuestionWidget(data, onAnswer) {
     answerEl.className = 'question-widget-answer';
     answerEl.textContent = displayText;
     body.appendChild(answerEl);
-    onAnswer(messageText ?? displayText);
+    if (onAnswer) onAnswer(messageText ?? displayText);
+  }
+
+  if (lockedAnswer != null) {
+    submit(lockedAnswer, lockedAnswer);
+    return card;
   }
 
   function buildOtherRow(placeholder) {
@@ -650,12 +665,127 @@ function appendAssistantRow(turnMeta) {
   return result;
 }
 
-function appendToolMessage(name) {
-  appendMessageRow('tool', 'System', '⚙', `Using tool: ${name}`);
+function appendToolMessage(name, ts) {
+  appendMessageRow('tool', 'System', '⚙', `Using tool: ${name}`, ts);
+}
+
+function appendErrorMessage(message, ts) {
+  appendMessageRow('error', 'Error', '!', message, ts);
+}
+
+// One-shot counterpart to AssistantContentRenderer for replaying a
+// message whose full text is already known (history) rather than
+// streaming in — a single regex pass is fine here since there's no
+// "flash of raw JSON" or "wipe answered state" risk on a fully-formed string.
+// liveOnAnswer is only passed for a trailing, never-answered widget at the
+// very end of history (the conversation was interrupted — e.g. server
+// restarted — before the founder responded). That one genuinely needs to
+// keep working exactly like a live pending widget, composer gating
+// included, rather than being either dead-looking (locked) or clickable but
+// silently doing nothing (no answer handler).
+function renderStaticAssistantText(container, fullText, lockedAnswer, liveOnAnswer) {
+  const re = /```question-widget\s*\n([\s\S]*?)\n```/;
+  const match = fullText.match(re);
+  if (!match) {
+    const seg = document.createElement('div');
+    seg.className = 'msg-text-segment';
+    seg.innerHTML = renderMarkdown(fullText);
+    container.appendChild(seg);
+    return;
+  }
+
+  const before = fullText.slice(0, match.index);
+  const after = fullText.slice(match.index + match[0].length);
+
+  if (before.trim()) {
+    const seg = document.createElement('div');
+    seg.className = 'msg-text-segment';
+    seg.innerHTML = renderMarkdown(before);
+    container.appendChild(seg);
+  }
+
+  let data = null;
+  try {
+    data = JSON.parse(match[1]);
+  } catch {
+    const seg = document.createElement('div');
+    seg.className = 'msg-text-segment';
+    seg.textContent = match[1].trim();
+    container.appendChild(seg);
+  }
+  if (data) {
+    if (lockedAnswer != null) {
+      container.appendChild(createQuestionWidget(data, null, lockedAnswer));
+    } else if (liveOnAnswer) {
+      setPendingWidget(1);
+      let answered = false;
+      const widgetEl = createQuestionWidget(data, (messageText) => {
+        if (answered) return;
+        answered = true;
+        setPendingWidget(-1);
+        liveOnAnswer(messageText);
+      });
+      container.appendChild(widgetEl);
+    } else {
+      // Shouldn't normally happen (an unanswered widget anywhere but the
+      // last entry would mean the conversation continued without it ever
+      // being answered) — render inert rather than a dead-looking control.
+      container.appendChild(createQuestionWidget(data, null, '(not answered)'));
+    }
+  }
+
+  if (after.trim()) {
+    const seg = document.createElement('div');
+    seg.className = 'msg-text-segment';
+    seg.innerHTML = renderMarkdown(after);
+    container.appendChild(seg);
+  }
 }
 
-function appendErrorMessage(message) {
-  appendMessageRow('error', 'Error', '!', message);
+async function loadHistory() {
+  const res = await api('/api/chat/history');
+  const { history } = await res.json();
+
+  for (let i = 0; i < history.length; i++) {
+    const entry = history[i];
+    if (entry.kind === 'user') {
+      appendUserMessage(entry.text, entry.ts);
+    } else if (entry.kind === 'widget-answer') {
+      // Consumed by the preceding assistant entry's widget below — a live
+      // widget answer never gets its own bubble either.
+      continue;
+    } else if (entry.kind === 'tool') {
+      appendToolMessage(entry.name, entry.ts);
+    } else if (entry.kind === 'error') {
+      appendErrorMessage(entry.message, entry.ts);
+    } else if (entry.kind === 'assistant') {
+      const { row, textEl } = appendMessageRow(
+        'assistant',
+        lastProfile?.ceoName || 'your AI CEO',
+        getCeoInitial(),
+        '',
+        entry.ts,
+      );
+      if (entry.model) {
+        const badge = document.createElement('span');
+        badge.className = 'msg-model-badge';
+        const modelLabel = modelDisplayName(entry.model);
+        badge.textContent = entry.effort ? `${modelLabel} · ${entry.effort}` : modelLabel;
+        row.querySelector('.msg-meta').appendChild(badge);
+      }
+      const next = history[i + 1];
+      const lockedAnswer = next?.kind === 'widget-answer' ? next.text : null;
+      const isTrailingUnanswered = i === history.length - 1 && !lockedAnswer;
+      renderStaticAssistantText(
+        textEl,
+        entry.text,
+        lockedAnswer,
+        isTrailingUnanswered ? (messageText) => streamChat(messageText, { showUserBubble: false, isWidgetAnswer: true }) : null,
+      );
+    }
+  }
+
+  return history.length > 0;
 }
 
 function showTypingIndicator() {
@@ -668,7 +798,7 @@ function hideTypingIndicator() {
   el.typingIndicator.hidden = true;
 }
 
-async function streamChat(message, { showUserBubble }) {
+async function streamChat(message, { showUserBubble, isWidgetAnswer }) {
   if (showUserBubble) appendUserMessage(message);
   showTypingIndicator();
   setStatus('typing');
@@ -680,7 +810,12 @@ async function streamChat(message, { showUserBubble }) {
   const res = await api('/api/chat', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ message, model: el.chatModelSelect.value, effort: el.chatEffortSelect.value }),
+    body: JSON.stringify({
+      message,
+      model: el.chatModelSelect.value,
+      effort: el.chatEffortSelect.value,
+      isWidgetAnswer: isWidgetAnswer === true,
+    }),
   });
 
   if (!res.ok || !res.body) {

package/dist/web/index.html

@@ -6,21 +6,28 @@
   <link rel="stylesheet" href="/style.css" />
 </head>
 <body>
-  <p id="loading">Checking Claude Code status&hellip;</p>
+  <div id="loading" class="splash">
+    <div class="splash-logo"></div>
+    <div class="splash-spinner"></div>
+    <p class="splash-text">Checking Claude Code status&hellip;</p>
+  </div>
 
-  <section id="onboarding" hidden>
-    <h1>Set up Claude Code</h1>
-    <div id="onboarding-cli-missing" hidden>
-      <p>The Claude Code CLI binary couldn't be found or run.</p>
-      <p>Try installing it globally, then reload this page:</p>
-      <pre>npm install -g @anthropic-ai/claude-code</pre>
-    </div>
-    <div id="onboarding-not-authenticated" hidden>
-      <p>Claude Code isn't logged in yet. In a terminal, run:</p>
-      <pre>claude login</pre>
-      <p>Then come back here.</p>
+  <section id="onboarding" class="splash" hidden>
+    <div class="splash-logo"></div>
+    <div class="splash-card">
+      <h1>Set up Claude Code</h1>
+      <div id="onboarding-cli-missing" hidden>
+        <p>The Claude Code CLI binary couldn't be found or run.</p>
+        <p>Try installing it globally, then reload this page:</p>
+        <pre>npm install -g @anthropic-ai/claude-code</pre>
+      </div>
+      <div id="onboarding-not-authenticated" hidden>
+        <p>Claude Code isn't logged in yet. In a terminal, run:</p>
+        <pre>claude login</pre>
+        <p>Then come back here.</p>
+      </div>
+      <button id="check-again">Check again</button>
     </div>
-    <button id="check-again">Check again</button>
   </section>
 
   <div id="app-shell" hidden>

package/dist/web/style.css

@@ -65,20 +65,80 @@ body {
   display: none !important;
 }
 
-#loading,
-#onboarding {
-  max-width: 480px;
-  margin: 4rem auto;
-  padding: 0 1rem;
+.splash {
+  position: fixed;
+  inset: 0;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 1.1rem;
+  padding: 1.5rem;
+  background: radial-gradient(circle at 50% 35%, #241f3d 0%, #131120 65%, #0d0c17 100%);
+  color: #eceafc;
+  text-align: center;
+}
+
+.splash-logo {
+  width: 56px;
+  height: 56px;
+  border-radius: 16px;
+  background: linear-gradient(135deg, var(--accent), #b45cff);
+  box-shadow: 0 8px 32px rgba(124, 116, 255, 0.35);
+}
+
+.splash-spinner {
+  width: 26px;
+  height: 26px;
+  border-radius: 50%;
+  border: 3px solid rgba(255, 255, 255, 0.15);
+  border-top-color: #b8b2ff;
+  animation: splash-spin 0.8s linear infinite;
+}
+
+@keyframes splash-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+.splash-text {
+  margin: 0;
+  color: #a9a5cf;
+  font-size: 0.92rem;
+}
+
+.splash-card {
+  width: 100%;
+  max-width: 440px;
+  background: var(--bg);
+  color: var(--fg);
+  border-radius: 14px;
+  padding: 1.75rem;
+  box-shadow: 0 20px 60px rgba(0, 0, 0, 0.4);
+  text-align: left;
+}
+
+.splash-card h1 {
+  margin: 0 0 0.9rem;
+  font-size: 1.15rem;
   text-align: center;
 }
 
-#onboarding pre {
+.splash-card p {
+  line-height: 1.5;
+}
+
+.splash-card pre {
   background: var(--bg-subtle);
   padding: 0.75rem 1rem;
   border-radius: 8px;
   overflow-x: auto;
-  text-align: left;
+}
+
+.splash-card button {
+  width: 100%;
+  margin-top: 0.4rem;
 }
 
 /* ---------- App shell ---------- */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harborgroup/my-team",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Chat with your local Claude Code subscription from a web dashboard, scoped to the current repo. Dev-only.",
   "type": "module",
   "bin": {