thebird 1.2.90 → 1.2.91

package/CHANGELOG.md

@@ -1,4 +1,12 @@
 
+## [unreleased] 2026-04-21 chat observability — rich ACP/kilo/opencode event stream
+- feat: kilo-http-stream emits status, model-info, reasoning-delta, tool-event, file-event, step-start/finish, file-mirrored, unknown-part
+- feat: PART_HANDLERS dispatch table replaces part-type branching (kilo + opencode unified)
+- feat: agent-chat forwards full event stream via onEvent callback; window.__debug.agent.events rolling log (300 cap)
+- feat: agent stats strip in chat UI — provider·model·duration·txt·rsn·tool·file·step counters, live 4Hz
+- feat: inline event badges in stream ([i] status/model/unknown, [t] tool, [f] file, [s] step)
+- refactor: extracted PROVIDERS + fetchModels + renderEvent + formatStats to docs/chat-providers.js (app.js 229→166)
+
 ## [unreleased] 2026-04-21 node parity pass 12 — internal listen infrastructure
 - feat: busnet — in-browser TCP-like listen/connect via BroadcastChannel cross-tab fabric
 - feat: net.createServer now uses busnet — apps listen on ports other in-browser apps can connect to

package/docs/agent-chat.js

@@ -98,22 +98,39 @@ function buildStream(provider) {
   return streamOpenAI({ url, apiKey: provider.apiKey, messages: provider.messages, model: provider.model, tools: TOOLS, maxOutputTokens: 8192 });
 }
 
-export async function agentGenerate(provider, messages, onChunk, onTool) {
-  Object.assign(window.__debug = window.__debug || {}, {
-    agent: { provider: provider.type, model: provider.model, active: true, lastTool: null, lastError: null },
-  });
+const EVENT_LOG_MAX = 300;
+
+export async function agentGenerate(provider, messages, onChunk, onTool, onEvent) {
+  const agentState = {
+    provider: provider.type, model: provider.model, active: true,
+    startedAt: Date.now(), lastTool: null, lastError: null,
+    events: [], textChars: 0, reasoningChars: 0, toolCalls: 0, files: 0, steps: 0,
+    modelActual: null, providerActual: null,
+  };
+  Object.assign(window.__debug = window.__debug || {}, { agent: agentState });
   try {
     for await (const ev of buildStream({ ...provider, messages })) {
-      if (ev.type === 'text-delta') onChunk(ev.textDelta);
-      else if (ev.type === 'tool-call') {
-        window.__debug.agent.lastTool = { name: ev.toolName, args: ev.args };
-        onTool(ev.toolName, ev.args);
-      } else if (ev.type === 'error') throw ev.error;
+      const rec = { ...ev, t: Date.now() };
+      agentState.events.push(rec);
+      if (agentState.events.length > EVENT_LOG_MAX) agentState.events.splice(0, agentState.events.length - EVENT_LOG_MAX);
+      onEvent?.(ev);
+      if (ev.type === 'text-delta') { agentState.textChars += ev.textDelta.length; onChunk(ev.textDelta); }
+      else if (ev.type === 'reasoning-delta') { agentState.reasoningChars += ev.textDelta.length; }
+      else if (ev.type === 'tool-call' || ev.type === 'tool-event') {
+        agentState.toolCalls++;
+        agentState.lastTool = { name: ev.toolName, args: ev.args || ev.input, status: ev.status };
+        onTool(ev.toolName, ev.args || ev.input || {});
+      } else if (ev.type === 'file-event' || ev.type === 'file-mirrored') { agentState.files++; }
+      else if (ev.type === 'start-step' || ev.type === 'step-start') { agentState.steps++; }
+      else if (ev.type === 'model-info') { agentState.modelActual = ev.modelID; agentState.providerActual = ev.providerID; }
+      else if (ev.type === 'error') throw ev.error;
     }
   } catch (e) {
-    window.__debug.agent.lastError = { message: e.message, stack: e.stack, timestamp: Date.now() };
+    agentState.lastError = { message: e.message, stack: e.stack, timestamp: Date.now() };
     throw e;
   } finally {
-    window.__debug.agent.active = false;
+    agentState.active = false;
+    agentState.finishedAt = Date.now();
+    agentState.durationMs = agentState.finishedAt - agentState.startedAt;
   }
 }

package/docs/app.js

@@ -1,48 +1,9 @@
 import { createElement, applyDiff, htm } from './vendor/ui-libs.js';
 import { agentGenerate } from './agent-chat.js';
+import { PROVIDERS, fetchModels, renderEvent, formatStats } from './chat-providers.js';
 
 const html = htm.bind(createElement);
 
-const PROVIDERS = {
-  gemini:   { label: 'Google Gemini',   baseUrl: 'https://generativelanguage.googleapis.com/v1beta', keyPlaceholder: 'GEMINI_API_KEY', models: [] },
-  openai:   { label: 'OpenAI',          baseUrl: 'https://api.openai.com/v1',                        keyPlaceholder: 'OPENAI_API_KEY', models: ['gpt-4.1', 'gpt-4o', 'gpt-4o-mini', 'o3', 'o4-mini'] },
-  xai:      { label: 'xAI Grok',        baseUrl: 'https://api.x.ai/v1',                              keyPlaceholder: 'XAI_API_KEY',    models: ['grok-3', 'grok-3-mini', 'grok-3-fast'] },
-  groq:     { label: 'Groq',            baseUrl: 'https://api.groq.com/openai/v1',                   keyPlaceholder: 'GROQ_API_KEY',   models: ['llama-3.3-70b-versatile', 'llama-3.1-8b-instant', 'mixtral-8x7b-32768'] },
-  mistral:  { label: 'Mistral',         baseUrl: 'https://api.mistral.ai/v1',                        keyPlaceholder: 'MISTRAL_API_KEY', models: ['mistral-large-latest', 'mistral-small-latest', 'codestral-latest'] },
-  deepseek: { label: 'DeepSeek',        baseUrl: 'https://api.deepseek.com/v1',                      keyPlaceholder: 'DEEPSEEK_API_KEY', models: ['deepseek-chat', 'deepseek-reasoner'] },
-  cerebras: { label: 'Cerebras',        baseUrl: 'https://api.cerebras.ai/v1',                      keyPlaceholder: 'CEREBRAS_API_KEY', models: ['gpt-oss-120b', 'llama3.1-8b'] },
-  kilo:     { label: 'Kilo Code',              baseUrl: 'http://localhost:4780',                     keyPlaceholder: '(no key needed)', models: ['x-ai/grok-code-fast-1:optimized:free', 'kilo-auto/free', 'openrouter/free', 'stepfun/step-3.5-flash:free', 'nvidia/nemotron-3-super-120b-a12b:free', 'bytedance-seed/dola-seed-2.0-pro:free'] },
-  opencode: { label: 'opencode (zen)',         baseUrl: 'http://localhost:4790',                     keyPlaceholder: '(needs opencode auth login)', models: ['minimax-m2.5-free', 'nemotron-3-super-free'] },
-  custom:   { label: 'Custom (OpenAI-compat)', baseUrl: '',                                          keyPlaceholder: 'API_KEY',        models: [] },
-};
-
-async function fetchGeminiModels(apiKey) {
-  const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
-  if (!res.ok) throw new Error(`Models API ${res.status}`);
-  const { models = [] } = await res.json();
-  return models
-    .filter(m => m.supportedGenerationMethods?.includes('generateContent'))
-    .map(m => ({ id: m.name.replace('models/', ''), label: m.displayName || m.name }));
-}
-
-async function fetchOpenAIModels(baseUrl, apiKey) {
-  const url = baseUrl.replace(/\/$/, '') + '/models';
-  const res = await fetch(url, { headers: { 'Authorization': `Bearer ${apiKey}` } });
-  if (!res.ok) throw new Error(`Models API ${res.status}`);
-  const { data = [] } = await res.json();
-  return data.map(m => ({ id: m.id, label: m.id })).sort((a, b) => a.id.localeCompare(b.id));
-}
-
-async function fetchModels(providerType, baseUrl, apiKey) {
-  if (providerType === 'gemini') return fetchGeminiModels(apiKey);
-  const staticModels = PROVIDERS[providerType]?.models || [];
-  try {
-    return await fetchOpenAIModels(baseUrl, apiKey);
-  } catch {
-    return staticModels.map(id => ({ id, label: id }));
-  }
-}
-
 class BirdChat extends HTMLElement {
   constructor() {
     super();
@@ -69,6 +30,13 @@ class BirdChat extends HTMLElement {
     this.render();
     Object.assign(window.__debug, { acp: { baseUrl: this.state.baseUrl, provider: this.state.providerType } });
     if (this.state.apiKey) this.loadModels();
+    this.statsTimer = setInterval(() => this.updateStats(), 250);
+  }
+  disconnectedCallback() { if (this.statsTimer) clearInterval(this.statsTimer); }
+  updateStats() {
+    const el = this.querySelector('#agent-stats');
+    if (!el) return;
+    el.textContent = formatStats(window.__debug?.agent);
   }
 
   setState(patch) { Object.assign(this.state, patch); this.render(); }
@@ -133,6 +101,8 @@ class BirdChat extends HTMLElement {
           <button class="tui-btn" onclick=${() => this.setState({ messages: [], status: '' })}>[clear]</button>
         </div>
 
+        <div id="agent-stats" class="tui-agent-stats"></div>
+
         <div id="msg-list" class="tui-msglist">
           ${messages.map((m, i) => html`
             <div key=${i} class=${'tui-msg ' + m.role}>${typeof m.content === 'string' ? m.content : (m.content || []).filter(b => b.type === 'text').map(b => b.text).join('')}</div>`)}
@@ -178,14 +148,15 @@ class BirdChat extends HTMLElement {
       wrap.appendChild(cursor);
       const list = this.querySelector('#msg-list');
       if (list) list.appendChild(wrap);
+      const scroll = () => { const l = this.querySelector('#msg-list'); if (l) l.scrollTop = l.scrollHeight; };
       await agentGenerate(provider, normalizedMessages,
-        chunk => { full += chunk; streamEl.textContent = full; const l = this.querySelector('#msg-list'); if (l) l.scrollTop = l.scrollHeight; },
-        (name, args) => { full += `\n[tool: ${name}(${JSON.stringify(args)})]\n`; streamEl.textContent = full; }
+        chunk => { full += chunk; streamEl.textContent = full; scroll(); },
+        () => {},
+        ev => { const rendered = renderEvent(ev); if (rendered) { full += rendered; streamEl.textContent = full; scroll(); } }
       );
       wrap.remove();
       this.setState({ messages: [...normalizedMessages, { role: 'assistant', content: [{ type: 'text', text: full || '(empty)' }] }], streaming: false, streamingText: '' });
-      const l2 = this.querySelector('#msg-list');
-      if (l2) l2.scrollTop = l2.scrollHeight;
+      scroll();
     } catch (err) {
       this.setState({ streaming: false, streamingText: '', status: 'Error: ' + (err?.message || String(err)) });
     }

package/docs/chat-providers.js

@@ -0,0 +1,65 @@
+export const PROVIDERS = {
+  gemini:   { label: 'Google Gemini',   baseUrl: 'https://generativelanguage.googleapis.com/v1beta', keyPlaceholder: 'GEMINI_API_KEY', models: [] },
+  openai:   { label: 'OpenAI',          baseUrl: 'https://api.openai.com/v1',                        keyPlaceholder: 'OPENAI_API_KEY', models: ['gpt-4.1', 'gpt-4o', 'gpt-4o-mini', 'o3', 'o4-mini'] },
+  xai:      { label: 'xAI Grok',        baseUrl: 'https://api.x.ai/v1',                              keyPlaceholder: 'XAI_API_KEY',    models: ['grok-3', 'grok-3-mini', 'grok-3-fast'] },
+  groq:     { label: 'Groq',            baseUrl: 'https://api.groq.com/openai/v1',                   keyPlaceholder: 'GROQ_API_KEY',   models: ['llama-3.3-70b-versatile', 'llama-3.1-8b-instant', 'mixtral-8x7b-32768'] },
+  mistral:  { label: 'Mistral',         baseUrl: 'https://api.mistral.ai/v1',                        keyPlaceholder: 'MISTRAL_API_KEY', models: ['mistral-large-latest', 'mistral-small-latest', 'codestral-latest'] },
+  deepseek: { label: 'DeepSeek',        baseUrl: 'https://api.deepseek.com/v1',                      keyPlaceholder: 'DEEPSEEK_API_KEY', models: ['deepseek-chat', 'deepseek-reasoner'] },
+  cerebras: { label: 'Cerebras',        baseUrl: 'https://api.cerebras.ai/v1',                      keyPlaceholder: 'CEREBRAS_API_KEY', models: ['gpt-oss-120b', 'llama3.1-8b'] },
+  kilo:     { label: 'Kilo Code',              baseUrl: 'http://localhost:4780',                     keyPlaceholder: '(no key needed)', models: ['x-ai/grok-code-fast-1:optimized:free', 'kilo-auto/free', 'openrouter/free', 'stepfun/step-3.5-flash:free', 'nvidia/nemotron-3-super-120b-a12b:free', 'bytedance-seed/dola-seed-2.0-pro:free'] },
+  opencode: { label: 'opencode (zen)',         baseUrl: 'http://localhost:4790',                     keyPlaceholder: '(needs opencode auth login)', models: ['minimax-m2.5-free', 'nemotron-3-super-free'] },
+  custom:   { label: 'Custom (OpenAI-compat)', baseUrl: '',                                          keyPlaceholder: 'API_KEY',        models: [] },
+};
+
+async function fetchGeminiModels(apiKey) {
+  const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
+  if (!res.ok) throw new Error(`Models API ${res.status}`);
+  const { models = [] } = await res.json();
+  return models.filter(m => m.supportedGenerationMethods?.includes('generateContent'))
+    .map(m => ({ id: m.name.replace('models/', ''), label: m.displayName || m.name }));
+}
+
+async function fetchOpenAIModels(baseUrl, apiKey) {
+  const url = baseUrl.replace(/\/$/, '') + '/models';
+  const res = await fetch(url, { headers: { 'Authorization': `Bearer ${apiKey}` } });
+  if (!res.ok) throw new Error(`Models API ${res.status}`);
+  const { data = [] } = await res.json();
+  return data.map(m => ({ id: m.id, label: m.id })).sort((a, b) => a.id.localeCompare(b.id));
+}
+
+export async function fetchModels(providerType, baseUrl, apiKey) {
+  if (providerType === 'gemini') return fetchGeminiModels(apiKey);
+  const staticModels = PROVIDERS[providerType]?.models || [];
+  try { return await fetchOpenAIModels(baseUrl, apiKey); }
+  catch { return staticModels.map(id => ({ id, label: id })); }
+}
+
+const fmtArgs = a => { try { const s = JSON.stringify(a); return s.length > 140 ? s.slice(0, 137) + '...' : s; } catch { return '?'; } };
+const badge = (label, cls) => `\n\n[${cls}] ${label}\n`;
+
+const RENDERERS = {
+  status: ev => badge('status: ' + ev.message, 'i'),
+  'model-info': ev => badge('model: ' + (ev.providerID || '') + '/' + ev.modelID, 'i'),
+  'tool-event': ev => badge('tool ' + (ev.status || '') + ': ' + ev.toolName + ' ' + fmtArgs(ev.input), 't'),
+  'tool-call': ev => badge('tool: ' + ev.toolName + ' ' + fmtArgs(ev.args), 't'),
+  'file-event': ev => badge('file: ' + (ev.filename || ev.url || '?'), 'f'),
+  'file-mirrored': ev => badge('wrote: ' + ev.path, 'f'),
+  'reasoning-delta': ev => ev.textDelta,
+  'step-start': () => badge('step start', 's'),
+  'step-finish': ev => badge('step finish' + (ev.tokens ? ' tokens=' + JSON.stringify(ev.tokens) : ''), 's'),
+  'unknown-part': ev => badge('?part ' + ev.partType, 'i'),
+};
+
+export function renderEvent(ev) { const r = RENDERERS[ev.type]; return r ? r(ev) : ''; }
+
+export function formatStats(a) {
+  if (!a) return '';
+  const dur = a.active ? ((Date.now() - a.startedAt) / 1000).toFixed(1) : ((a.durationMs || 0) / 1000).toFixed(1);
+  const parts = [a.active ? '●' : '○', a.provider, a.modelActual || a.model, dur + 's', 'txt=' + a.textChars];
+  if (a.reasoningChars) parts.push('rsn=' + a.reasoningChars);
+  if (a.toolCalls) parts.push('tool=' + a.toolCalls);
+  if (a.files) parts.push('file=' + a.files);
+  if (a.steps) parts.push('step=' + a.steps);
+  if (a.lastError) parts.push('ERR:' + a.lastError.message.slice(0, 40));
+  return parts.join(' · ');
+}

package/docs/kilo-http-stream.js

@@ -1,17 +1,53 @@
 import { mirrorFromSandbox } from './kilo-fs-mirror.js';
 
+const PART_HANDLERS = {
+  text: (part, st, emit) => {
+    const prior = st.textByPart.get(part.id) || '';
+    const txt = part.text || '';
+    if (txt.length > prior.length) {
+      emit({ type: 'text-delta', textDelta: txt.slice(prior.length) });
+      st.textByPart.set(part.id, txt);
+    }
+  },
+  reasoning: (part, st, emit) => {
+    const prior = st.reasonByPart.get(part.id) || '';
+    const txt = part.text || '';
+    if (txt.length > prior.length) {
+      emit({ type: 'reasoning-delta', textDelta: txt.slice(prior.length) });
+      st.reasonByPart.set(part.id, txt);
+    }
+  },
+  tool: (part, st, emit) => {
+    const key = part.id + ':' + (part.state?.status || '');
+    if (st.seenTool.has(key)) return;
+    st.seenTool.add(key);
+    emit({ type: 'tool-event', toolName: part.tool || part.state?.tool, status: part.state?.status, input: part.state?.input, output: part.state?.output, error: part.state?.error, id: part.id });
+  },
+  file: (part, st, emit) => {
+    if (st.seenFile.has(part.id)) return;
+    st.seenFile.add(part.id);
+    emit({ type: 'file-event', filename: part.filename || part.path, mime: part.mime, url: part.url, id: part.id });
+  },
+  'step-start': (part, st, emit) => { if (!st.seenStep.has(part.id+':start')) { st.seenStep.add(part.id+':start'); emit({ type: 'step-start', id: part.id }); } },
+  'step-finish': (part, st, emit) => { if (!st.seenStep.has(part.id+':finish')) { st.seenStep.add(part.id+':finish'); emit({ type: 'step-finish', id: part.id, tokens: part.tokens, cost: part.cost }); st.stepFinished = true; } },
+};
+
+function makeState() { return { textByPart: new Map(), reasonByPart: new Map(), seenTool: new Set(), seenFile: new Set(), seenStep: new Set(), stepFinished: false }; }
+
 export async function* streamKiloHTTP({ url, model, messages, providerType, agent }) {
   yield { type: 'start-step' };
   const base = (url || 'http://localhost:4780').replace(/\/$/, '');
   const fsBase = base.replace(/:\d+$/, ':4781');
   const isOpencode = providerType === 'opencode';
   const dbgKey = isOpencode ? 'opencode' : 'kilo';
+  yield { type: 'status', message: 'connecting ' + base };
   let sessRes;
   try { sessRes = await fetch(base + '/session', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}' }); }
   catch (e) { throw new Error(dbgKey + ' serve not reachable at ' + base + ' — start it with: node start-kilo.js --origin ' + location.origin); }
   if (!sessRes.ok) throw new Error('/session ' + sessRes.status + ': ' + await sessRes.text());
   const { id: sessionId } = await sessRes.json();
-  Object.assign(window.__debug = window.__debug || {}, { [dbgKey]: { sessionId, url: base, fsBase, lastStatus: null } });
+  Object.assign(window.__debug = window.__debug || {}, { [dbgKey]: { sessionId, url: base, fsBase, lastStatus: null, events: [] } });
+  yield { type: 'status', message: 'session ' + sessionId.slice(0, 8) };
 
   const userText = messages.filter(m => m.role === 'user').map(m =>
     typeof m.content === 'string' ? m.content : (m.content || []).filter(b => b.type === 'text').map(b => b.text).join('')
@@ -23,55 +59,69 @@ export async function* streamKiloHTTP({ url, model, messages, providerType, agen
   if (isOpencode) body.model = { providerID: 'opencode', modelID: modelId };
   else { body.providerID = 'kilo'; body.modelID = modelId; }
 
-  let text = '';
+  const st = makeState();
+  const emit = ev => { (window.__debug[dbgKey].events ||= []).push({ ...ev, t: Date.now() }); };
+
   if (isOpencode) {
     const es = new EventSource(base + '/event');
-    const textByPart = new Map();
     const assistantMsgs = new Set();
-    let stepFinished = false;
     const pending = [];
     let resolveNext = null;
     const wake = () => { if (resolveNext) { const r = resolveNext; resolveNext = null; r(); } };
+    const push = ev => { emit(ev); pending.push(ev); wake(); };
     es.onmessage = e => {
       try {
         const m = JSON.parse(e.data);
         if (m.type === 'message.updated') {
           const info = m.properties?.info;
-          if (info?.sessionID === sessionId && info.role === 'assistant') assistantMsgs.add(info.id);
+          if (info?.sessionID === sessionId && info.role === 'assistant') { assistantMsgs.add(info.id); if (info.modelID) push({ type: 'model-info', modelID: info.modelID, providerID: info.providerID }); }
         } else if (m.type === 'message.part.updated') {
           const part = m.properties?.part;
           if (part?.sessionID !== sessionId || !assistantMsgs.has(part.messageID)) return;
-          if (part.type === 'text') {
-            const prior = textByPart.get(part.id) || '';
-            const txt = part.text || '';
-            if (txt.length > prior.length) { pending.push({ type:'text-delta', textDelta: txt.slice(prior.length) }); textByPart.set(part.id, txt); wake(); }
-          } else if (part.type === 'step-finish') { stepFinished = true; wake(); }
+          const h = PART_HANDLERS[part.type];
+          if (h) h(part, st, push);
+          else push({ type: 'unknown-part', partType: part.type, id: part.id });
         }
       } catch (_) {}
     };
+    yield { type: 'status', message: 'POST /message' };
     const msgRes = await fetch(base + '/session/' + sessionId + '/message', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
     window.__debug[dbgKey].lastStatus = msgRes.status;
+    yield { type: 'status', message: 'msg ' + msgRes.status };
     if (!msgRes.ok) { es.close(); throw new Error('message ' + msgRes.status + ': ' + await msgRes.text()); }
     const deadline = Date.now() + 180000;
     let graceUntil = 0;
     while (true) {
-      if (pending.length) { const ev = pending.shift(); text += ev.textDelta; yield ev; continue; }
-      if (stepFinished) { if (!graceUntil) graceUntil = Date.now() + 1500; if (Date.now() > graceUntil) break; }
+      if (pending.length) { yield pending.shift(); continue; }
+      if (st.stepFinished) { if (!graceUntil) graceUntil = Date.now() + 1500; if (Date.now() > graceUntil) break; }
       if (Date.now() > deadline) break;
       await new Promise(r => { resolveNext = r; setTimeout(r, 500); });
     }
     es.close();
   } else {
+    yield { type: 'status', message: 'POST /message' };
     const msgRes = await fetch(base + '/session/' + sessionId + '/message', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
     window.__debug[dbgKey].lastStatus = msgRes.status;
+    yield { type: 'status', message: 'msg ' + msgRes.status };
     if (!msgRes.ok) throw new Error('message ' + msgRes.status + ': ' + await msgRes.text());
     const result = await msgRes.json();
     window.__debug[dbgKey].lastResult = result;
-    for (const tp of (result.parts || []).filter(p => p.type === 'text')) { text += tp.text; yield { type: 'text-delta', textDelta: tp.text }; }
+    const info = result.info || {};
+    if (info.modelID) { const ev = { type: 'model-info', modelID: info.modelID, providerID: info.providerID }; emit(ev); yield ev; }
+    for (const part of (result.parts || [])) {
+      const h = PART_HANDLERS[part.type];
+      const pending = [];
+      const pushLocal = ev => { emit(ev); pending.push(ev); };
+      if (h) h(part, st, pushLocal);
+      else pushLocal({ type: 'unknown-part', partType: part.type, id: part.id });
+      for (const ev of pending) yield ev;
+    }
   }
+  yield { type: 'status', message: 'mirror sandbox' };
   const mirrored = await mirrorFromSandbox(fsBase);
   if (mirrored.length) {
     window.__debug[dbgKey].writes = mirrored;
+    for (const path of mirrored) yield { type: 'file-mirrored', path };
     window.showPreview?.();
     window.refreshPreview?.();
   }

package/docs/tui.css

@@ -123,6 +123,21 @@ html, body { background: var(--paper); color: var(--ink); height: 100%; margin:
   font-size: 12px;
 }
 .tui-toolbar label { color: var(--ink-dim); font-size: 10px; text-transform: uppercase; letter-spacing: 0.1em; font-weight: 600; }
+.tui-agent-stats {
+  padding: 4px 2ch;
+  border-bottom: 1px solid var(--ink-hair);
+  background: var(--surface);
+  font-size: 10px;
+  color: var(--ink-dim);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  min-height: 18px;
+  font-family: var(--ff-mono);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.tui-agent-stats:empty { display: none; }
 .tui-msglist {
   flex: 1;
   overflow-y: auto;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thebird",
-  "version": "1.2.90",
+  "version": "1.2.91",
   "description": "Anthropic SDK to Gemini streaming bridge — drop-in proxy that translates Anthropic message format and tool calls to Google Gemini",
   "scripts": {
     "start": "node serve.js"