@getmegabrain/cli 0.1.6 → 0.1.8

package/dist/science/agent/agent.js

@@ -0,0 +1,107 @@
+function codeOf(input) {
+    return typeof input.code === 'string' ? input.code : '';
+}
+export function pythonTool(bridge) {
+    return {
+        definition: {
+            name: 'run_python',
+            description: 'Execute Python in the shared local kernel on the user’s machine. State (variables, imports) persists across calls. Returns stdout and stderr. Prefer small, verifiable steps.',
+            input_schema: {
+                type: 'object',
+                properties: { code: { type: 'string', description: 'Python source to run' } },
+                required: ['code'],
+            },
+        },
+        describe: input => codeOf(input),
+        run: input => bridge.runCell(codeOf(input)),
+    };
+}
+const SYSTEM_PROMPT = `You are the MegaBrain Science research agent. You work in a live
+notebook, sharing one Python kernel with the user — variables and imports persist across
+cells and everything runs locally on the user's machine. Use run_python to write and run
+code and iterate on its output. Prefer small, verifiable steps. When you have the answer,
+stop calling tools and give a concise final summary of what you did and found.`;
+const MAX_TURNS = 16;
+export class AgentSession {
+    model;
+    emit;
+    agentContext;
+    cellCounter = 0;
+    tools;
+    messages;
+    constructor(model, tools, emit, agentContext = '', history = []) {
+        this.model = model;
+        this.emit = emit;
+        this.agentContext = agentContext;
+        this.tools = new Map(tools.map(t => [t.definition.name, t]));
+        this.messages = [...history];
+    }
+    /** The full model-visible message history (prior turns + this run) — persist to give the
+     *  session memory across sends. */
+    getMessages() {
+        return this.messages;
+    }
+    async run(prompt) {
+        const system = this.agentContext
+            ? `${SYSTEM_PROMPT}\n\nProject context: ${this.agentContext}`
+            : SYSTEM_PROMPT;
+        const messages = this.messages;
+        messages.push({ role: 'user', content: [{ type: 'text', text: prompt }] });
+        const toolDefs = [...this.tools.values()].map(t => t.definition);
+        try {
+            for (let turn = 0; turn < MAX_TURNS; turn += 1) {
+                const response = await this.model.complete({ system, messages, tools: toolDefs });
+                messages.push({ role: 'assistant', content: response.content });
+                for (const block of response.content) {
+                    if (block.type === 'text' && block.text.trim()) {
+                        this.emit({ type: 'agent-text', text: block.text });
+                    }
+                }
+                const toolUses = response.content.filter((b) => b.type === 'tool_use');
+                if (toolUses.length === 0) {
+                    this.emit({ type: 'agent-done', text: collectText(response.content) });
+                    return;
+                }
+                const results = [];
+                for (const toolUse of toolUses) {
+                    this.cellCounter += 1;
+                    const cellId = `agent-${this.cellCounter}`;
+                    const tool = this.tools.get(toolUse.name);
+                    if (!tool) {
+                        results.push({
+                            type: 'tool_result',
+                            tool_use_id: toolUse.id,
+                            content: `Unknown tool: ${toolUse.name}`,
+                        });
+                        continue;
+                    }
+                    this.emit({
+                        type: 'tool-call',
+                        cellId,
+                        tool: toolUse.name,
+                        code: tool.describe(toolUse.input),
+                    });
+                    const { stdout, stderr } = await tool.run(toolUse.input);
+                    this.emit({ type: 'tool-result', cellId, stdout, stderr });
+                    const content = [stdout, stderr && `[stderr]\n${stderr}`].filter(Boolean).join('\n') || '(no output)';
+                    results.push({ type: 'tool_result', tool_use_id: toolUse.id, content });
+                }
+                messages.push({ role: 'user', content: results });
+            }
+            this.emit({ type: 'agent-error', error: `Agent stopped after ${MAX_TURNS} turns.` });
+        }
+        catch (error) {
+            this.emit({
+                type: 'agent-error',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}
+function collectText(content) {
+    return content
+        .filter((b) => b.type === 'text')
+        .map(b => b.text)
+        .join('')
+        .trim();
+}

package/dist/science/agent/model.js

@@ -0,0 +1,46 @@
+/**
+ * Minimal model-client contract (Anthropic Messages / tool-use shape) + the MegaBrain
+ * Gateway client. Ported from the retired Electron app. The agent loop is written against
+ * `ModelClient` so the transport is swappable; in production it's the Gateway
+ * (`/api/gateway/v1/messages`) authenticated with the signed-in account token.
+ */
+export class GatewayModel {
+    url;
+    apiKey;
+    model;
+    maxTokens;
+    constructor(options) {
+        this.url =
+            options.url ??
+                process.env.MB_GATEWAY_URL ??
+                `${(process.env.MEGABRAIN_APP_URL ?? 'https://getmegabrain.com').replace(/\/+$/, '')}/api/gateway/v1/messages`;
+        this.apiKey = options.apiKey;
+        this.model = options.model ?? process.env.MB_SCIENCE_MODEL ?? 'claude-opus-4-8';
+        this.maxTokens = options.maxTokens ?? 4096;
+    }
+    async complete(request) {
+        if (!this.apiKey)
+            throw new Error('Sign in to MegaBrain to use the agent.');
+        const response = await fetch(this.url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${this.apiKey}`,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+                model: this.model,
+                max_tokens: this.maxTokens,
+                system: request.system,
+                messages: request.messages,
+                tools: request.tools,
+            }),
+        });
+        if (!response.ok) {
+            const detail = await response.text();
+            throw new Error(`Gateway request failed (${response.status}): ${detail.slice(0, 500)}`);
+        }
+        const data = (await response.json());
+        return { content: data.content ?? [], stopReason: data.stop_reason ?? 'end_turn' };
+    }
+}

package/dist/science/kernel.js

@@ -63,6 +63,48 @@ export class KernelBridge {
             this.start();
         this.child?.stdin.write(`${JSON.stringify(request)}\n`);
     }
+    /**
+     * Execute a cell and resolve with its collected output once the kernel returns to idle.
+     * Used by the agent's run_python tool (it needs the result to feed back to the model),
+     * while the same frames also stream live to the transcript.
+     */
+    runCell(code, timeoutMs = 120_000) {
+        if (!this.child)
+            this.start();
+        this.cellCounter += 1;
+        const cellId = `cell-${this.cellCounter}`;
+        return new Promise(resolve => {
+            let stdout = '';
+            let stderr = '';
+            let done = false;
+            const finish = (extraErr = '') => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                off();
+                resolve({ stdout, stderr: stderr + extraErr });
+            };
+            const off = this.onFrame(f => {
+                if (f.type === 'stream' && f.cellId === cellId) {
+                    if (f.kind === 'stderr')
+                        stderr += f.data;
+                    else
+                        stdout += f.data;
+                }
+                else if (f.type === 'status' &&
+                    f.cellId === cellId &&
+                    (f.state === 'idle' || f.state === 'error')) {
+                    finish(f.state === 'error' && f.error ? f.error : '');
+                }
+                else if (f.type === 'status' && f.state === 'error' && !f.cellId) {
+                    finish(f.error ? `\n${f.error}` : '\nkernel error');
+                }
+            });
+            const timer = setTimeout(() => finish('\n(timed out)'), timeoutMs);
+            this.send({ type: 'execute', cellId, code });
+        });
+    }
     restart() {
         this.stop();
         this.buffer = '';

package/dist/science/pages.js

@@ -253,43 +253,94 @@ export function startWizardPage(d) {
      </script>`);
 }
 /**
- * A working session with a live local-kernel REPL (#274/#277). The transcript + composer
- * (reused cloud-agent-next) replaces this markup later; the kernel SSE + execute contract it
- * exercises is the durable part — compute runs locally, streamed over Server-Sent Events.
+ * The working session — a full-window Claude-Science-like workspace (#271/#276/#277): a left
+ * sidebar of sessions, a chat transcript of the agent's steps, and an "Ask anything" composer
+ * that drives the agent (Gateway → local kernel). Full-page layout (not the centered card),
+ * with the client logic served as /session-client.js.
  */
 export function sessionPage(projectId, sessionId) {
-    const sid = JSON.stringify(sessionId);
-    return shell('Session — MegaBrain Science', `<div style="text-align:left">
-       <h1 id="title" style="font-size:18px">Session</h1>
-       <div class="status" id="kstate">kernel: starting…</div>
-       <div id="out" style="font:12px/1.5 ui-monospace,Menlo,monospace;white-space:pre-wrap;background:rgba(128,128,128,.08);border-radius:10px;padding:12px;min-height:80px;max-height:40vh;overflow:auto"></div>
-       <textarea id="code" rows="4" spellcheck="false" style="width:100%;margin-top:10px;font:12px/1.5 ui-monospace,Menlo,monospace" placeholder="print(6 * 7)"></textarea>
-       <div style="display:flex;gap:8px;margin-top:8px">
-         <button class="btn btn-primary" style="width:auto;padding:8px 16px;margin:0" id="run">Run ⌘⏎</button>
-         <button class="btn btn-ghost" style="width:auto;padding:8px 16px;margin:0" id="restart">Restart kernel</button>
-         <a class="btn btn-ghost" style="width:auto;padding:8px 16px;margin:0" href="/projects/${esc(projectId)}">← Project</a>
-       </div>
-     </div>
-     <script>
-       const sid = ${sid};
-       const out = document.getElementById('out');
-       fetch('/api/sessions/' + sid).then(r => r.json()).then(s => {
-         if (s && s.title) document.getElementById('title').textContent = s.title;
-       });
-       const es = new EventSource('/api/sessions/' + sid + '/kernel/stream');
-       es.onmessage = e => {
-         const f = JSON.parse(e.data);
-         if (f.type === 'status') document.getElementById('kstate').textContent = 'kernel: ' + f.state + (f.error ? ' — ' + f.error : '');
-         else if (f.type === 'stream') { out.textContent += f.data; out.scrollTop = out.scrollHeight; }
-       };
-       async function run() {
-         const code = document.getElementById('code').value;
-         if (!code.trim()) return;
-         out.textContent += '>>> ' + code + '\\n';
-         await fetch('/api/sessions/' + sid + '/kernel/execute', { method:'POST', headers:{'content-type':'application/json'}, body: JSON.stringify({ code }) });
-       }
-       document.getElementById('run').addEventListener('click', run);
-       document.getElementById('code').addEventListener('keydown', e => { if ((e.metaKey||e.ctrlKey) && e.key==='Enter') { e.preventDefault(); run(); } });
-       document.getElementById('restart').addEventListener('click', () => fetch('/api/sessions/' + sid + '/kernel/restart', { method:'POST' }));
-     </script>`);
+    const boot = JSON.stringify({ sid: sessionId, pid: projectId });
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Session — MegaBrain Science</title>
+    <style>
+      :root { color-scheme: light dark; --bg:#fff; --panel:#faf9f8; --border:#eceae7; --fg:#1a1a1a; --muted:#8a8a8a; --accent:#c8492a; }
+      @media (prefers-color-scheme: dark) { :root { --bg:#111; --panel:#161513; --border:#262626; --fg:#ededed; --muted:#8a8a8a; --accent:#e8623a; } }
+      * { box-sizing: border-box; }
+      html, body { margin:0; height:100%; }
+      body { display:flex; height:100vh; overflow:hidden; background:var(--bg); color:var(--fg);
+        font:15px/1.55 -apple-system,BlinkMacSystemFont,"Segoe UI",system-ui,sans-serif; }
+      /* Sidebar */
+      .sidebar { width:264px; flex-shrink:0; border-right:1px solid var(--border); background:var(--panel);
+        display:flex; flex-direction:column; padding:14px; gap:10px; }
+      .brand { display:flex; align-items:center; gap:8px; font-weight:600; font-size:14px; }
+      .mark { width:26px; height:26px; border-radius:7px; background:linear-gradient(135deg,#e8623a,#c8492a);
+        color:#fff; display:grid; place-items:center; font-size:12px; font-weight:700; }
+      .newbtn { border:1px solid var(--border); background:var(--bg); color:inherit; border-radius:10px;
+        padding:9px 12px; font:inherit; font-weight:600; cursor:pointer; text-align:left; }
+      .newbtn:hover { border-color:var(--accent); }
+      .proj { font-size:11px; text-transform:uppercase; letter-spacing:.06em; color:var(--muted); margin-top:6px; }
+      .sessions { display:flex; flex-direction:column; gap:2px; overflow:auto; flex:1; margin:0 -6px; }
+      .session { display:block; padding:8px 10px; border-radius:8px; color:inherit; text-decoration:none;
+        font-size:14px; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
+      .session:hover { background:var(--bg); }
+      .session.active { background:var(--bg); font-weight:600; }
+      .side-foot { display:flex; gap:12px; font-size:13px; }
+      .side-foot a { color:var(--muted); text-decoration:none; } .side-foot a:hover { color:var(--fg); }
+      /* Main */
+      .main { flex:1; display:flex; flex-direction:column; min-width:0; }
+      .topbar { height:52px; flex-shrink:0; border-bottom:1px solid var(--border); display:flex; align-items:center;
+        gap:10px; padding:0 20px; font-weight:600; }
+      .kstate { font-size:12px; color:var(--muted); font-weight:400; margin-left:auto; }
+      .transcript { flex:1; overflow:auto; padding:24px; display:flex; flex-direction:column; gap:16px; }
+      .wrap { width:100%; max-width:760px; margin:0 auto; display:flex; flex-direction:column; gap:16px; }
+      .msg.user { display:flex; justify-content:flex-end; }
+      .msg.user .bubble { background:var(--accent); color:#fff; border-radius:14px 14px 4px 14px; padding:9px 14px; max-width:80%; white-space:pre-wrap; }
+      .msg.agent .prose { white-space:pre-wrap; }
+      .step { border:1px solid var(--border); border-radius:12px; overflow:hidden; background:var(--panel); }
+      .step-head { display:flex; align-items:center; gap:8px; padding:9px 12px; font-size:13px; font-weight:600; }
+      .step-dot { width:7px; height:7px; border-radius:50%; background:var(--accent); }
+      .step .code, .step .out { margin:0; padding:10px 12px; font:12px/1.5 ui-monospace,Menlo,monospace;
+        white-space:pre-wrap; overflow-x:auto; border-top:1px solid var(--border); }
+      .step .out { color:var(--muted); background:var(--bg); }
+      .step .out.err { color:#c0392b; }
+      /* Composer */
+      .composer { flex-shrink:0; border-top:1px solid var(--border); padding:14px 20px; }
+      .composer-inner { max-width:760px; margin:0 auto; display:flex; gap:10px; align-items:flex-end;
+        border:1px solid var(--border); border-radius:16px; padding:10px 12px; background:var(--panel); }
+      .composer-inner:focus-within { border-color:var(--accent); }
+      textarea#composer { flex:1; border:0; background:transparent; resize:none; color:inherit; font:inherit;
+        outline:none; max-height:160px; }
+      .model { font-size:12px; color:var(--muted); align-self:center; white-space:nowrap; }
+      #send { border:0; border-radius:10px; background:var(--accent); color:#fff; font:inherit; font-weight:600;
+        padding:8px 16px; cursor:pointer; }
+      #send:disabled { opacity:.5; cursor:default; }
+    </style>
+  </head>
+  <body>
+    <aside class="sidebar">
+      <div class="brand"><span class="mark">MB</span> MegaBrain Science</div>
+      <button class="newbtn" id="new-session">+ New session</button>
+      <div class="proj" id="project-name">Project</div>
+      <nav class="sessions" id="session-list"></nav>
+      <div class="side-foot"><a href="/">Home</a><a href="/projects/${esc(projectId)}">Project</a></div>
+    </aside>
+    <main class="main">
+      <div class="topbar"><span id="session-title">Session</span><span class="kstate" id="kstate">kernel: idle</span></div>
+      <div class="transcript"><div class="wrap" id="transcript"></div></div>
+      <div class="composer">
+        <div class="composer-inner">
+          <textarea id="composer" rows="1" placeholder="Ask anything — the agent runs code locally…"></textarea>
+          <span class="model">Opus 4.8</span>
+          <button id="send">Send</button>
+        </div>
+      </div>
+    </main>
+    <script>window.__MB__ = ${boot};</script>
+    <script src="/session-client.js"></script>
+  </body>
+</html>`;
 }

package/dist/science/server.js

@@ -1,11 +1,15 @@
 import { randomBytes } from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import { createServer } from 'node:http';
+import { fileURLToPath } from 'node:url';
 import { readCredentials, writeCredentials, clearCredentials } from '../credentials.js';
 import { startDeviceAuth } from '../device-auth.js';
 import { NonceStore } from './nonce.js';
 import { homePage, loginPage, nonceInvalidPage, nonceLandingPage, projectPage, sessionPage, startWizardPage, } from './pages.js';
 import { FEATURED_CONNECTORS, NETWORK_CATEGORIES, WorkspaceStore } from './store.js';
 import { KernelManager } from './kernel.js';
+import { AgentSession, pythonTool } from './agent/agent.js';
+import { GatewayModel } from './agent/model.js';
 /**
  * The `megabrain science` local daemon's HTTP server. Serves the sign-in hand-off on
  * localhost (docs/megabrain-science/reference/claude-science-flow.md §1.1) and, once signed
@@ -15,12 +19,25 @@ import { KernelManager } from './kernel.js';
  */
 const COOKIE = 'mb_sci';
 const PREFERRED_PORT = 8765;
+const SESSION_CLIENT = fileURLToPath(new URL('./session-client.js', import.meta.url));
 export async function startScienceServer(host = '127.0.0.1') {
     const nonces = new NonceStore();
     const trusted = new Set();
     const store = new WorkspaceStore();
     const kernels = new KernelManager();
     let pending = null;
+    // Per-session Server-Sent-Events fan-out. Kernel frames + agent transcript events both
+    // flow to every browser watching a session, tagged with a `channel`.
+    const sseClients = new Map();
+    const kernelHooked = new Set();
+    const fanout = (sid, channel, payload) => {
+        const set = sseClients.get(sid);
+        if (!set)
+            return;
+        const line = `data: ${JSON.stringify({ channel, payload })}\n\n`;
+        for (const r of set)
+            r.write(line);
+    };
     const isSignedIn = () => readCredentials() !== null;
     const readBody = (req) => new Promise(resolve => {
         let raw = '';
@@ -70,6 +87,15 @@ export async function startScienceServer(host = '127.0.0.1') {
         const path = url.pathname;
         const method = req.method ?? 'GET';
         const seg = path.split('/').filter(Boolean);
+        // Static workspace client (referenced by the session page).
+        if (path === '/session-client.js' && method === 'GET') {
+            res.writeHead(200, {
+                'content-type': 'text/javascript; charset=utf-8',
+                'cache-control': 'no-cache',
+            });
+            res.end(readFileSync(SESSION_CLIENT, 'utf8'));
+            return;
+        }
         // ── Sign-in hand-off ───────────────────────────────────────────────
         if (path === '/' && url.searchParams.has('nonce')) {
             const result = nonces.claim(url.searchParams.get('nonce') ?? '');
@@ -191,33 +217,59 @@ export async function startScienceServer(host = '127.0.0.1') {
             });
             return json(res, { projectId: project.id, sessionId: session?.id ?? null }, 201);
         }
-        // ── Local kernel (#274). Per-session Python process; SSE for live frames. ──
-        if (seg[0] === 'api' && seg[1] === 'sessions' && seg[2] && seg[3] === 'kernel') {
-            if (!isSignedIn())
+        // ── Session event stream + agent (#274/#276/#277). Signed-in only. ──
+        // One SSE per session carries two channels: `kernel` (raw kernel status/output frames)
+        // and `agent` (the agent loop's transcript events). The agent's model runs in the cloud
+        // (Gateway) but drives the local kernel — compute stays on the machine.
+        if (seg[0] === 'api' &&
+            seg[1] === 'sessions' &&
+            seg[2] &&
+            (seg[3] === 'events' || seg[3] === 'agent' || seg[3] === 'kernel' || seg[3] === 'transcript')) {
+            const creds = readCredentials();
+            if (!creds)
                 return json(res, { error: 'signed-out' }, 401);
             const sid = seg[2];
-            if (seg[4] === 'stream' && method === 'GET') {
+            if (seg[3] === 'transcript' && method === 'GET') {
+                return json(res, store.getMessages(sid));
+            }
+            if (seg[3] === 'events' && method === 'GET') {
                 res.writeHead(200, {
                     'content-type': 'text/event-stream',
                     'cache-control': 'no-cache',
                     connection: 'keep-alive',
                 });
-                const off = kernels
-                    .get(sid)
-                    .onFrame(frame => res.write(`data: ${JSON.stringify(frame)}\n\n`));
-                req.on('close', off);
+                let set = sseClients.get(sid);
+                if (!set) {
+                    set = new Set();
+                    sseClients.set(sid, set);
+                }
+                set.add(res);
+                if (!kernelHooked.has(sid)) {
+                    kernelHooked.add(sid);
+                    kernels.get(sid).onFrame(frame => fanout(sid, 'kernel', frame));
+                }
+                req.on('close', () => sseClients.get(sid)?.delete(res));
                 return;
             }
-            if (seg[4] === 'execute' && method === 'POST') {
-                const b = await readBody(req);
-                const cellId = kernels.get(sid).execute(str(b.code) ?? '');
-                store.touchSession(sid);
-                return json(res, { cellId });
-            }
-            if (seg[4] === 'restart' && method === 'POST') {
+            if (seg[3] === 'kernel' && seg[4] === 'restart' && method === 'POST') {
                 kernels.restart(sid);
                 return json(res, { ok: true });
             }
+            if (seg[3] === 'agent' && method === 'POST') {
+                const b = await readBody(req);
+                const prompt = str(b.prompt)?.trim() ?? '';
+                if (!prompt)
+                    return json(res, { error: 'prompt-required' }, 400);
+                const session = store.getSession(sid);
+                const project = session ? store.getProject(session.projectId) : null;
+                store.touchSession(sid, session && !session.summary ? { summary: prompt } : undefined);
+                fanout(sid, 'agent', { type: 'user', text: prompt });
+                const agent = new AgentSession(new GatewayModel({ apiKey: creds.token }), [pythonTool(kernels.get(sid))], evt => fanout(sid, 'agent', evt), project?.agentContext ?? '', store.getMessages(sid));
+                // Persist the full history when the turn ends, so the session remembers it and the
+                // transcript survives a refresh.
+                void agent.run(prompt).finally(() => store.setMessages(sid, agent.getMessages()));
+                return json(res, { ok: true });
+            }
         }
         // ── Workspace API (projects/sessions, #270/#271). Signed-in only. ────
         if (path.startsWith('/api/projects') || path.startsWith('/api/sessions')) {

package/dist/science/session-client.js

@@ -0,0 +1,191 @@
+// Workspace client for a MegaBrain Science session (#271/#276/#277). Renders the sidebar
+// (sessions), the transcript (agent steps), and the composer; streams agent + kernel events
+// over SSE. Shipped as a static asset (see copy-assets) so it needs no build-time escaping.
+(function () {
+  var MB = window.__MB__ || {};
+  var sid = MB.sid,
+    pid = MB.pid;
+
+  var $ = function (id) {
+    return document.getElementById(id);
+  };
+  var transcript = $('transcript');
+  var scroller = document.querySelector('.transcript');
+  var composer = $('composer');
+  var sendBtn = $('send');
+  var kstate = $('kstate');
+  var lastCard = null;
+
+  function el(tag, cls, text) {
+    var e = document.createElement(tag);
+    if (cls) e.className = cls;
+    if (text != null) e.textContent = text;
+    return e;
+  }
+
+  function scroll() {
+    scroller.scrollTop = scroller.scrollHeight;
+  }
+
+  function addUser(text) {
+    var row = el('div', 'msg user');
+    row.appendChild(el('div', 'bubble', text));
+    transcript.appendChild(row);
+    scroll();
+  }
+  function addAgentText(text) {
+    var row = el('div', 'msg agent');
+    row.appendChild(el('div', 'prose', text));
+    transcript.appendChild(row);
+    scroll();
+  }
+  function addToolCall(tool, code) {
+    var card = el('div', 'step');
+    var head = el('div', 'step-head');
+    head.appendChild(el('span', 'step-dot'));
+    head.appendChild(el('span', 'step-title', tool === 'run_python' ? 'Ran Python' : tool));
+    card.appendChild(head);
+    var pre = el('pre', 'code');
+    pre.textContent = code;
+    card.appendChild(pre);
+    var out = el('pre', 'out');
+    out.hidden = true;
+    card.appendChild(out);
+    transcript.appendChild(card);
+    lastCard = card;
+    scroll();
+  }
+  function addToolResult(stdout, stderr) {
+    if (!lastCard) return;
+    var out = lastCard.querySelector('.out');
+    var text = (stdout || '') + (stderr ? (stdout ? '\n' : '') + stderr : '');
+    out.textContent = text || '(no output)';
+    out.hidden = false;
+    if (stderr) out.classList.add('err');
+    scroll();
+  }
+
+  function setRunning(on) {
+    sendBtn.disabled = on;
+    sendBtn.textContent = on ? 'Running…' : 'Send';
+  }
+
+  // Replay a persisted conversation (model messages) into the transcript on load.
+  function renderHistory(messages) {
+    messages.forEach(function (m) {
+      (m.content || []).forEach(function (b) {
+        if (m.role === 'user') {
+          if (b.type === 'text') addUser(b.text);
+          else if (b.type === 'tool_result') addToolResult(b.content, '');
+        } else {
+          if (b.type === 'text') addAgentText(b.text);
+          else if (b.type === 'tool_use') addToolCall(b.name, (b.input && b.input.code) || '');
+        }
+      });
+    });
+  }
+
+  // ── Sidebar: this project's sessions ────────────────────────────────
+  function loadSidebar() {
+    if (!pid) return;
+    fetch('/api/projects/' + pid)
+      .then(function (r) {
+        return r.json();
+      })
+      .then(function (p) {
+        if (p.project) $('project-name').textContent = p.project.name;
+        var list = $('session-list');
+        list.textContent = '';
+        (p.sessions || []).forEach(function (s) {
+          var a = el('a', 'session' + (s.id === sid ? ' active' : ''), s.title);
+          a.href = '/projects/' + pid + '/frames/' + s.id;
+          list.appendChild(a);
+        });
+      });
+  }
+
+  // ── Live event stream ───────────────────────────────────────────────
+  function connect() {
+    var es = new EventSource('/api/sessions/' + sid + '/events');
+    es.onmessage = function (e) {
+      var m = JSON.parse(e.data);
+      if (m.channel === 'kernel') {
+        var f = m.payload;
+        if (f.type === 'status') kstate.textContent = f.state === 'busy' ? 'running' : f.state;
+        return;
+      }
+      var p = m.payload;
+      if (p.type === 'user') addUser(p.text);
+      else if (p.type === 'agent-text') addAgentText(p.text);
+      else if (p.type === 'tool-call') addToolCall(p.tool, p.code);
+      else if (p.type === 'tool-result') addToolResult(p.stdout, p.stderr);
+      else if (p.type === 'agent-done') setRunning(false);
+      else if (p.type === 'agent-error') {
+        addAgentText('⚠ ' + p.error);
+        setRunning(false);
+      }
+    };
+    es.onerror = function () {
+      kstate.textContent = 'reconnecting…';
+    };
+  }
+
+  function send() {
+    var text = composer.value.trim();
+    if (!text || sendBtn.disabled) return;
+    composer.value = '';
+    setRunning(true);
+    fetch('/api/sessions/' + sid + '/agent', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ prompt: text }),
+    }).catch(function () {
+      setRunning(false);
+    });
+  }
+
+  sendBtn.addEventListener('click', send);
+  composer.addEventListener('keydown', function (e) {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault();
+      send();
+    }
+  });
+  $('new-session').addEventListener('click', function () {
+    fetch('/api/projects/' + pid + '/sessions', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ title: 'New session' }),
+    })
+      .then(function (r) {
+        return r.json();
+      })
+      .then(function (s) {
+        location.href = '/projects/' + pid + '/frames/' + s.id;
+      });
+  });
+
+  fetch('/api/sessions/' + sid + '/transcript')
+    .then(function (r) {
+      return r.json();
+    })
+    .then(function (msgs) {
+      var has = Array.isArray(msgs) && msgs.length > 0;
+      if (has) renderHistory(msgs);
+      return fetch('/api/sessions/' + sid)
+        .then(function (r) {
+          return r.json();
+        })
+        .then(function (s) {
+          if (s && s.title) $('session-title').textContent = s.title;
+          // Prefill the composer with the seeded first task only for a fresh session.
+          if (!has && s && (s.summary || s.title) && !composer.value)
+            composer.value = s.summary || s.title;
+        });
+    })
+    .catch(function () {})
+    .then(function () {
+      loadSidebar();
+      connect();
+    });
+})();

package/dist/science/store.js

@@ -28,6 +28,8 @@ function defaultSettings() {
         profile: '',
     };
 }
+const MAX_MESSAGES = 60;
+const MAX_TOOL_RESULT_CHARS = 4000;
 const STORE_FILE = path.join(MEGABRAIN_CONFIG_DIR, 'science-workspace.json');
 function id(prefix) {
     return `${prefix}_${randomBytes(8).toString('hex')}`;
@@ -48,6 +50,7 @@ export class WorkspaceStore {
                 projects: parsed.projects ?? [],
                 sessions: parsed.sessions ?? [],
                 settings: parsed.settings,
+                transcripts: parsed.transcripts ?? {},
             };
         }
         catch {
@@ -157,4 +160,19 @@ export class WorkspaceStore {
         this.save();
         return next;
     }
+    // ── Per-session conversation history (agent memory + transcript replay) ──
+    getMessages(sessionId) {
+        return this.data.transcripts?.[sessionId] ?? [];
+    }
+    setMessages(sessionId, messages) {
+        // Cap history length and truncate large tool outputs so the on-disk workspace stays small.
+        const capped = messages.slice(-MAX_MESSAGES).map(m => ({
+            role: m.role,
+            content: m.content.map(b => b.type === 'tool_result' && b.content.length > MAX_TOOL_RESULT_CHARS
+                ? { ...b, content: `${b.content.slice(0, MAX_TOOL_RESULT_CHARS)}\n…(truncated)` }
+                : b),
+        }));
+        (this.data.transcripts ??= {})[sessionId] = capped;
+        this.save();
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmegabrain/cli",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "MegaBrain CLI — sign in once, then code from your terminal via OpenCode wired to the MegaBrain Gateway, or run `megabrain science` for the local research workbench.",
   "license": "MIT",
   "type": "module",