@getmegabrain/cli 0.1.12 → 0.1.14

package/dist/science/agent/agent.js

@@ -22,7 +22,18 @@ cells and everything runs locally on the user's machine. Use run_python to write
 code and iterate on its output, and search_literature to find and cite real papers (arXiv,
 OpenAlex, PubMed) when the task calls for surveying prior work. Prefer small, verifiable
 steps. When you have the answer, stop calling tools and give a concise final summary of
-what you did and found.`;
+what you did and found.
+
+Be proactive — act, don't stall. When a request is broad (e.g. "map the recent literature
+of your subfield"), do NOT reply by asking the user to narrow it down. Infer a reasonable
+scope from the project context below and immediately call search_literature (run several
+focused queries if useful), then present what you found. Only ask a clarifying question
+when you genuinely cannot proceed at all. "Your subfield", "your project", and similar
+phrases refer to the project context below — not to you as an AI; you have no personal
+research field, so interpret them as the project's topic.
+
+You retain this session's full message history, so you DO remember earlier turns in this
+conversation — never claim you have no memory of what was said earlier in the session.`;
 const MAX_TURNS = 16;
 export class AgentSession {
     model;

package/dist/science/agent/context.js

@@ -0,0 +1,21 @@
+/**
+ * Builds the project-grounding context string injected into the agent's system prompt.
+ * Grounding broad tasks ("map the recent literature of your subfield") in the project's
+ * name/description and the researcher profile is what lets the agent resolve "your subfield"
+ * to a concrete topic instead of stalling to ask the user.
+ */
+export function buildAgentContext(input) {
+    const clean = (v) => (v ?? '').trim();
+    const name = clean(input.projectName);
+    const description = clean(input.projectDescription);
+    const context = clean(input.agentContext);
+    const profile = clean(input.profile);
+    return [
+        name ? `Project: ${name}` : '',
+        description ? `Project description: ${description}` : '',
+        context,
+        profile ? `Researcher profile: ${profile}` : '',
+    ]
+        .filter(Boolean)
+        .join('\n');
+}

package/dist/science/queue.js

@@ -0,0 +1,23 @@
+/**
+ * A per-key serial task queue. Tasks enqueued under the same key run strictly one after
+ * another (in enqueue order); tasks under different keys run independently.
+ *
+ * The Science daemon uses this to serialize agent turns per session: without it, sending
+ * several messages in quick succession spawns overlapping AgentSessions that share one
+ * kernel and race on the persisted transcript — so turns clobber each other and messages
+ * appear "unseen". Serializing means each turn starts only after the previous finished and
+ * therefore reads the prior turn's saved history.
+ */
+export function createKeyedQueue() {
+    const tails = new Map();
+    return function enqueue(key, task) {
+        const prev = tails.get(key) ?? Promise.resolve();
+        // Run `task` after the previous one settles — on both fulfill and reject, so a failed
+        // turn never blocks the queue.
+        const result = prev.then(task, task);
+        // The tail we chain the *next* task onto must never reject (that would skip the catch
+        // handler on subsequent tasks); swallow it here. Callers still see `result`'s outcome.
+        tails.set(key, result.catch(() => undefined));
+        return result;
+    };
+}

package/dist/science/server.js

@@ -9,11 +9,13 @@ import { homePage, loginPage, nonceInvalidPage, nonceLandingPage, projectPage, s
 import { FEATURED_CONNECTORS, NETWORK_CATEGORIES, WorkspaceStore } from './store.js';
 import { KernelManager } from './kernel.js';
 import { AgentSession, pythonTool } from './agent/agent.js';
+import { buildAgentContext } from './agent/context.js';
 import { ArxivClient, literatureTool, MultiSourceClient } from './agent/literature.js';
 import { OpenAlexClient } from './agent/openalex.js';
 import { PubMedClient } from './agent/pubmed.js';
 import { GatewayModel } from './agent/model.js';
 import { DEFAULT_MODEL, fetchPickerModels } from './agent/models.js';
+import { createKeyedQueue } from './queue.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
@@ -34,6 +36,9 @@ export async function startScienceServer(host = '127.0.0.1') {
     // flow to every browser watching a session, tagged with a `channel`.
     const sseClients = new Map();
     const kernelHooked = new Set();
+    // Serialize agent turns per session so rapid messages are handled in order (each seeing the
+    // previous turn's history) instead of racing on the shared kernel and transcript.
+    const agentQueue = createKeyedQueue();
     const fanout = (sid, channel, payload) => {
         const set = sseClients.get(sid);
         if (!set)
@@ -273,17 +278,36 @@ export async function startScienceServer(host = '127.0.0.1') {
                 if (!prompt)
                     return json(res, { error: 'prompt-required' }, 400);
                 const model = str(b.model)?.trim() || DEFAULT_MODEL;
-                const session = store.getSession(sid);
-                const project = session ? store.getProject(session.projectId) : null;
-                store.touchSession(sid, session && !session.summary ? { summary: prompt } : undefined);
+                const token = creds.token;
+                // Echo the user's message immediately so it shows up in order, then run the turn on the
+                // per-session queue. The turn reads history *at run time* so it includes any turn that
+                // was still in flight when this message arrived.
                 fanout(sid, 'agent', { type: 'user', text: prompt });
-                const agent = new AgentSession(new GatewayModel({ apiKey: creds.token, model }), [
-                    pythonTool(kernels.get(sid)),
-                    literatureTool(new MultiSourceClient([new ArxivClient(), new OpenAlexClient(), new PubMedClient()])),
-                ], 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()));
+                void agentQueue(sid, async () => {
+                    const session = store.getSession(sid);
+                    const project = session ? store.getProject(session.projectId) : null;
+                    store.touchSession(sid, session && !session.summary ? { summary: prompt } : undefined);
+                    // Ground the agent in the project + researcher profile so broad tasks like
+                    // "map the recent literature of your subfield" resolve to a concrete topic.
+                    const agentContext = buildAgentContext({
+                        projectName: project?.name,
+                        projectDescription: project?.description,
+                        agentContext: project?.agentContext,
+                        profile: store.getSettings().profile,
+                    });
+                    const agent = new AgentSession(new GatewayModel({ apiKey: token, model }), [
+                        pythonTool(kernels.get(sid)),
+                        literatureTool(new MultiSourceClient([new ArxivClient(), new OpenAlexClient(), new PubMedClient()])),
+                    ], evt => fanout(sid, 'agent', evt), agentContext, store.getMessages(sid));
+                    try {
+                        await agent.run(prompt);
+                    }
+                    finally {
+                        // Persist the full history so the session remembers it and the transcript survives
+                        // a refresh — and so the next queued turn reads it as its starting point.
+                        store.setMessages(sid, agent.getMessages());
+                    }
+                });
                 return json(res, { ok: true });
             }
         }

package/dist/science/session-client.js

@@ -79,9 +79,13 @@
     scroll();
   }
 
+  // Track how many turns are in flight. The send button stays enabled so you can queue
+  // follow-up messages while the agent works — the server runs them in order per session.
+  var pending = 0;
   function setRunning(on) {
-    sendBtn.disabled = on;
-    sendBtn.textContent = on ? 'Running…' : 'Send';
+    pending += on ? 1 : -1;
+    if (pending < 0) pending = 0;
+    sendBtn.textContent = pending > 0 ? 'Working…' : 'Send';
   }
 
   // Replay a persisted conversation (model messages) into the transcript on load.
@@ -183,7 +187,7 @@
 
   function send() {
     var text = composer.value.trim();
-    if (!text || sendBtn.disabled) return;
+    if (!text) return;
     composer.value = '';
     setRunning(true);
     fetch('/api/sessions/' + sid + '/agent', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmegabrain/cli",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "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",