spectoflow 0.27.2 → 0.29.0

package/lib/brain.js

@@ -0,0 +1,257 @@
+'use strict';
+/*
+ * The second brain — what spectoflow has learned about the user, shared by all their projects.
+ * One markdown file, ~/.spectoflow/brain.md (never inside a project, never copied), read and written
+ * by the dashboard page, the `spectoflow mcp` server and the `::spectoflow learn` run line. Zero
+ * dependency.
+ *
+ *   # Second brain
+ *   ## Profile
+ *   - Scrum master and full-stack developer <!-- id:b7k2 by:agent at:2026-09-16 -->
+ *   ## To confirm
+ *   - [preferences] Prefers pnpm over npm <!-- id:b7k6 by:agent at:2026-09-16 -->
+ *
+ * The file is the user's too: every line spectoflow doesn't change is written back byte for byte —
+ * titles, blank lines, comments, code blocks, unknown sections and their order, hand-written entries.
+ * Writers in different processes (hub, MCP servers, runs) take a lock file, then write-then-rename.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const globalConfig = require('./global-config');
+
+const CATEGORIES = ['profile', 'preferences', 'workflow', 'avoid'];
+const HEADINGS = { profile: 'Profile', preferences: 'Preferences', workflow: 'Working style', avoid: 'Avoid' };
+const PENDING = 'To confirm';
+const MAX_TEXT = 500;
+const FALLBACK_CATEGORY = 'preferences';
+
+function brainPath() { return path.join(globalConfig.homeDir(), 'brain.md'); }
+
+const normCategory = (c) => (CATEGORIES.includes(String(c || '').trim().toLowerCase()) ? String(c).trim().toLowerCase() : FALLBACK_CATEGORY);
+// One line, no HTML-comment delimiters (they would break the metadata), capped.
+function cleanText(t) {
+  return String(t == null ? '' : t).replace(/<!--|-->/g, '').replace(/\s+/g, ' ').trim().slice(0, MAX_TEXT);
+}
+const newId = () => 'b' + Date.now().toString(36) + crypto.randomBytes(3).toString('hex');
+// A hand-written line has no id: derive a stable one. `n` tells identical lines of a category apart.
+const derivedId = (category, text, n) => 'h' + crypto.createHash('sha1').update(`${category}\n${text}\n${n}`).digest('hex').slice(0, 10);
+const today = () => new Date().toISOString().slice(0, 10);
+const isBlank = (it) => it.raw !== undefined && !it.raw.trim();
+
+function headingKind(title) {
+  const t = title.trim().toLowerCase();
+  if (t === PENDING.toLowerCase()) return { kind: 'pending' };
+  const cat = CATEGORIES.find((c) => c === t || HEADINGS[c].toLowerCase() === t);
+  return cat ? { kind: 'category', id: cat } : { kind: 'unknown' };
+}
+
+const ENTRY_RE = /^-\s+(?:\[([\w-]+)\]\s+)?(.*?)\s*(?:<!--\s*(.*?)\s*-->)?\s*$/;
+function parseMeta(s) {
+  const out = {};
+  for (const m of String(s || '').matchAll(/(\w+):(\S+)/g)) out[m[1]] = m[2];
+  return out;
+}
+
+// → { title, blocks: [{ kind: preamble|category|pending|unknown, id?, heading?, items: [...] }] }
+// item = { raw } (a line kept verbatim) or an entry { id, category, text, by, at, status, line }.
+function parse(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
+  const model = { title: null, eol: /\r\n/.test(String(text || '')) ? '\r\n' : '\n', blocks: [{ kind: 'preamble', items: [] }] };
+  let block = model.blocks[0], inFence = false;
+  const seen = new Map();
+  for (const line of lines) {
+    if (/^\s*(```|~~~)/.test(line)) { inFence = !inFence; block.items.push({ raw: line }); continue; }
+    if (inFence) { block.items.push({ raw: line }); continue; }
+    if (model.title === null && model.blocks.length === 1 && block.items.every(isBlank) && /^#\s+/.test(line)) { model.title = line; continue; }
+    const h = line.match(/^##\s+(.*)$/);
+    if (h) {
+      block = { ...headingKind(h[1]), heading: line, items: [] };
+      model.blocks.push(block);
+      continue;
+    }
+    const m = (block.kind === 'category' || block.kind === 'pending') && line.match(ENTRY_RE);
+    const meta = m ? parseMeta(m[3]) : null;
+    // A trailing comment is never part of the fact (a user's own comment stays hidden: the line itself is
+    // written back verbatim while the entry is untouched; editing the entry replaces the line).
+    const body = m ? m[2] : '';
+    if (m && cleanText(body)) {
+      const pending = block.kind === 'pending';
+      const category = pending ? normCategory(m[1]) : block.id;
+      const entryText = cleanText(pending || !m[1] ? body : `[${m[1]}] ${body}`);
+      let id = meta.id;
+      if (!id) { const k = `${category}\n${entryText}`; const n = seen.get(k) || 0; seen.set(k, n + 1); id = derivedId(category, entryText, n); }
+      block.items.push({ id, category, text: entryText, by: meta.by || 'user', at: meta.at || null, status: pending ? 'pending' : 'confirmed', line });
+    } else {
+      block.items.push({ raw: line });
+    }
+  }
+  return model;
+}
+
+function entryLine(e) {
+  const meta = `id:${e.id} by:${e.by}${e.at ? ' at:' + e.at : ''}`;
+  return `- ${e.status === 'pending' ? `[${e.category}] ` : ''}${e.text} <!-- ${meta} -->`;
+}
+function serialize(model) {
+  const out = [model.title || '# Second brain'];
+  for (const b of model.blocks) {
+    if (b.kind === 'pending' && !b.items.some((it) => it.raw === undefined) && b.items.every(isBlank)) continue;
+    if (b.kind !== 'preamble') {
+      if (out[out.length - 1].trim()) out.push(''); // a section always follows a blank line
+      out.push(b.heading || `## ${b.kind === 'pending' ? PENDING : HEADINGS[b.id]}`);
+    }
+    for (const it of b.items) out.push(it.raw !== undefined ? it.raw : (it.line && !it.dirty ? it.line : entryLine(it)));
+  }
+  while (out.length > 1 && !out[out.length - 1].trim()) out.pop();
+  const eol = model.eol || '\n';
+  return out.join(eol) + eol;
+}
+
+function emptyModel() {
+  return { title: null, blocks: [{ kind: 'preamble', items: [] }, ...CATEGORIES.map((id) => ({ kind: 'category', id, heading: null, items: [] }))] };
+}
+function load(file = brainPath()) {
+  let text = '';
+  try { text = fs.readFileSync(file, 'utf8'); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+  return text.trim() ? parse(text) : emptyModel();
+}
+function save(model, file = brainPath()) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+  fs.writeFileSync(tmp, serialize(model));
+  fs.renameSync(tmp, file);
+}
+
+// Cross-process lock: the hub, any number of `spectoflow mcp` processes and runs may write in the
+// same instant. A lock older than 10s is a crashed writer's and is taken over.
+const sleepSync = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+function withLock(file, fn) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const lock = `${file}.lock`, deadline = Date.now() + 3000;
+  for (;;) {
+    try { fs.writeFileSync(lock, String(process.pid), { flag: 'wx' }); break; }
+    catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+      try { if (Date.now() - fs.statSync(lock).mtimeMs > 10000) { fs.unlinkSync(lock); continue; } } catch (_) {}
+      if (Date.now() > deadline) throw Object.assign(new Error('The second brain is busy, try again.'), { status: 503 });
+      sleepSync(15);
+    }
+  }
+  try { return fn(); } finally { try { fs.unlinkSync(lock); } catch (_) {} }
+}
+// Read, change, save — under the lock. `fn` returns { result, changed }.
+function mutate(file, fn) {
+  return withLock(file, () => {
+    const model = load(file);
+    const { result, changed } = fn(model);
+    if (changed) save(model, file);
+    return result;
+  });
+}
+
+const entriesOf = (model) => model.blocks.flatMap((b) => b.items.filter((it) => it.raw === undefined));
+function find(model, id) {
+  for (const b of model.blocks) {
+    const i = b.items.findIndex((it) => it.raw === undefined && it.id === id);
+    if (i >= 0) return { block: b, i, entry: b.items[i] };
+  }
+  return null;
+}
+// Append before the block's trailing blank lines, so the spacing before the next heading stays.
+function append(block, entry) {
+  let i = block.items.length;
+  while (i > 0 && isBlank(block.items[i - 1])) i--;
+  block.items.splice(i, 0, entry);
+}
+function blockFor(model, status, category) {
+  const want = status === 'pending' ? (b) => b.kind === 'pending' : (b) => b.kind === 'category' && b.id === category;
+  let b = model.blocks.find(want);
+  if (!b) {
+    b = status === 'pending' ? { kind: 'pending', heading: null, items: [] } : { kind: 'category', id: category, heading: null, items: [] };
+    const at = status === 'pending' ? -1 : model.blocks.findIndex((x) => x.kind === 'pending');
+    if (at < 0) model.blocks.push(b); else model.blocks.splice(at, 0, b);
+  }
+  return b;
+}
+const notFound = () => Object.assign(new Error('Entry not found.'), { status: 404 });
+const emptyText = () => Object.assign(new Error('Text is required.'), { status: 400 });
+
+// { entries (confirmed, in category order), pending, autoAdd }
+function read(file = brainPath()) {
+  const all = entriesOf(load(file));
+  return {
+    entries: CATEGORIES.flatMap((c) => all.filter((e) => e.status === 'confirmed' && e.category === c)),
+    pending: all.filter((e) => e.status === 'pending'),
+    autoAdd: autoAdd(),
+  };
+}
+
+// Adds one fact. status 'confirmed' or 'pending'. A case-insensitive duplicate of any entry is not
+// added again: → { duplicate: true, entry: <the existing one> }.
+function add({ category, text, by = 'user', status = 'confirmed' }, file = brainPath()) {
+  const t = cleanText(text);
+  if (!t) throw emptyText();
+  return mutate(file, (model) => {
+    const existing = entriesOf(model).find((e) => e.text.toLowerCase() === t.toLowerCase());
+    if (existing) return { result: { duplicate: true, entry: existing }, changed: false };
+    const entry = { id: newId(), category: normCategory(category), text: t, by, at: today(), status: status === 'pending' ? 'pending' : 'confirmed' };
+    append(blockFor(model, entry.status, entry.category), entry);
+    return { result: { duplicate: false, entry }, changed: true };
+  });
+}
+
+// What the agent learned through MCP: confirmed right away, or "to confirm", per brain.autoAdd.
+function learn({ category, text }, file = brainPath()) {
+  return add({ category, text, by: 'agent', status: autoAdd() ? 'confirmed' : 'pending' }, file);
+}
+
+function update(id, { text, category } = {}, file = brainPath()) {
+  const t = text === undefined ? undefined : cleanText(text);
+  if (text !== undefined && !t) throw emptyText();
+  return mutate(file, (model) => {
+    const hit = find(model, id); if (!hit) throw notFound();
+    const e = hit.entry;
+    if (t !== undefined) e.text = t;
+    if (category !== undefined) {
+      const c = normCategory(category);
+      if (c !== e.category && e.status === 'confirmed') { hit.block.items.splice(hit.i, 1); append(blockFor(model, 'confirmed', c), e); }
+      e.category = c;
+    }
+    e.dirty = true;
+    return { result: e, changed: true };
+  });
+}
+
+function remove(id, file = brainPath()) {
+  return mutate(file, (model) => {
+    const hit = find(model, id); if (!hit) throw notFound();
+    hit.block.items.splice(hit.i, 1);
+    return { result: { ok: true }, changed: true };
+  });
+}
+
+function confirm(id, file = brainPath()) {
+  return mutate(file, (model) => {
+    const hit = find(model, id); if (!hit) throw notFound();
+    if (hit.entry.status !== 'pending') return { result: hit.entry, changed: false };
+    hit.block.items.splice(hit.i, 1);
+    hit.entry.status = 'confirmed'; hit.entry.dirty = true;
+    append(blockFor(model, 'confirmed', hit.entry.category), hit.entry);
+    return { result: hit.entry, changed: true };
+  });
+}
+
+// Confirmed entries as markdown, grouped by category — what an agent is given.
+function renderForAgent(file = brainPath()) {
+  const { entries } = read(file);
+  return CATEGORIES.map((c) => {
+    const items = entries.filter((e) => e.category === c);
+    return items.length ? `## ${HEADINGS[c]}\n${items.map((e) => `- ${e.text}`).join('\n')}` : '';
+  }).filter(Boolean).join('\n\n');
+}
+
+function autoAdd() { return globalConfig.get('brain.autoAdd').value !== false; }
+
+module.exports = { CATEGORIES, HEADINGS, MAX_TEXT, brainPath, parse, serialize, read, add, learn, update, remove, confirm, renderForAgent, autoAdd };

package/lib/dashboard/handlers.js

@@ -20,6 +20,26 @@ function body(req) { return new Promise((r) => { let b = ''; req.on('data', (c)
 
 const { ROUTES, findRoute } = require('./routes');
 
+// Is this request really the user, on this machine, in a dashboard tab of this hub? The hub is reachable
+// from the local network; a tunnel or reverse proxy on the same machine (ngrok, Caddy) arrives from
+// loopback; and a web page can rebind its own domain to 127.0.0.1 (DNS rebinding) or post cross-site. So
+// all three must hold: a loopback socket, a local Host, and — when the browser sends one — an Origin that is
+// this very host. Anything else is treated like a request through the online relay: it can't touch the
+// second brain (ops refuse it) and a run it starts can't write into it.
+const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+const LOCAL_HOSTNAMES = new Set(['localhost', '127.0.0.1', '[::1]']);
+const isLoopback = (addr) => !!addr && (LOOPBACK.has(addr) || addr.startsWith('127.') || addr.startsWith('::ffff:127.'));
+function isLocalRequest(req) {
+  if (!isLoopback(req.socket && req.socket.remoteAddress)) return false;
+  const host = String(req.headers.host || '');
+  let hostname;
+  try { hostname = new URL(`http://${host}`).hostname; } catch { return false; }
+  if (!LOCAL_HOSTNAMES.has(hostname)) return false;
+  const origin = req.headers.origin;
+  if (origin === undefined) return true;
+  try { return new URL(origin).host === host; } catch { return false; }
+}
+
 function createHandlers(root) {
   async function handleApi(req, res, u, emit) {
     const p = u.pathname;
@@ -28,7 +48,7 @@ function createHandlers(root) {
     const [, , opName, args] = route;
     const b = req.method === 'GET' ? {} : await body(req);
     try {
-      const result = await ops[opName](root, args(u, b, p), { emit });
+      const result = await ops[opName](root, args(u, b, p), { emit, remote: !isLocalRequest(req) });
       sendJSON(res, 200, result);
     } catch (e) {
       if (e instanceof OpError) sendJSON(res, e.status, { error: e.message });
@@ -50,4 +70,4 @@ function createHandlers(root) {
   };
 }
 
-module.exports = { createHandlers, ROUTES };
+module.exports = { createHandlers, ROUTES, isLoopback, isLocalRequest };

package/lib/dashboard/hub-server.js

@@ -23,6 +23,7 @@ const os = require('os');
 const path = require('path');
 const registry = require('../registry');
 const workspace = require('../workspace');
+const brain = require('../brain');
 const { createHandlers } = require('./handlers');
 const store = require('../store');
 const { createConnector } = require('./connector');
@@ -74,7 +75,7 @@ async function execOp(localId, op, args) {
   const proj = getProject(localId);
   if (!proj) throw new OpError(404, projectErrorMessage(localId));
   if (!Object.prototype.hasOwnProperty.call(ops, op)) throw new OpError(404, `Unknown operation "${op}".`);
-  return ops[op](proj.root, args || {}, { emit: proj.emit });
+  return ops[op](proj.root, args || {}, { emit: proj.emit, remote: true });
 }
 function startConnector() {
   if (connector) { connector.stop(); connector = null; }
@@ -338,4 +339,23 @@ const server = http.createServer(async (req, res) => {
   } catch (e) { sendJSON(res, 500, { error: String(e && e.message || e) }); }
 });
 
-server.listen(PORT, () => { writeLock(); console.log(`spectoflow · hub → http://localhost:${PORT}${migrated.movedRegistry ? '  (moved your project list into the workspace)' : ''}`); startConnector(); });
+// The second brain (~/.spectoflow/brain.md) is written by the page, by any agent's `spectoflow mcp`
+// server process, and by `::spectoflow learn` run lines. Tell every open LOCAL tab it changed — never
+// the connector: the brain is not a project's and stays off the relay, even as a content-free event.
+function watchBrain() {
+  const file = brain.brainPath();
+  try { fs.mkdirSync(path.dirname(file), { recursive: true }); } catch (_) { return; }
+  let timer = null;
+  try {
+    fs.watch(path.dirname(file), (_ev, name) => {
+      if (name && name !== path.basename(file)) return;
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        const line = 'data: ' + JSON.stringify({ type: 'brain' }) + '\n\n';
+        for (const proj of projects.values()) for (const res of proj.clients) res.write(line);
+      }, 100);
+    });
+  } catch (_) {}
+}
+
+server.listen(PORT, () => { watchBrain(); writeLock(); console.log(`spectoflow · hub → http://localhost:${PORT}${migrated.movedRegistry ? '  (moved your project list into the workspace)' : ''}`); startConnector(); });

package/lib/dashboard/ops.js

@@ -17,6 +17,9 @@ const { runMeetingGenerate, todayLocal } = require('./meeting');
 const orchestrator = require('./orchestrator');
 const adapters = require('../adapters');
 const detect = require('../detect');
+const brain = require('../brain');
+const brainSetup = require('../brain-setup');
+const globalConfig = require('../global-config');
 
 const PKG_VERSION = require('../../package.json').version;
 
@@ -55,7 +58,7 @@ const KANBAN_STATUSES = ['todo', 'in_progress', 'to_validate', 'to_analyze', 'do
 // registered 'notes'; Task 3 registers 'meeting' — the Daily meeting tab — into it), mirroring
 // app.js's ROUTES array exactly — the one server-side source of truth for "what's a real native tab
 // id".
-const NATIVE_TABS = ['board', 'chat', 'requests', 'attention', 'backlog', 'workflow', 'team', 'files', 'notes', 'meeting', 'info', 'docs', 'personalize'];
+const NATIVE_TABS = ['board', 'chat', 'requests', 'attention', 'backlog', 'workflow', 'team', 'files', 'notes', 'meeting', 'info', 'docs', 'brain', 'personalize'];
 function writeConfig(root, patch, detectOpts) {
   const cp = path.join(root, '.spectoflow', 'config.json');
   const cfg = JSON.parse(fs.readFileSync(cp, 'utf8'));
@@ -138,6 +141,15 @@ function writeConfig(root, patch, detectOpts) {
 const filesResult = (r) => { if (r.error) bad(r.error); return r; };
 const changed = (ctx, result) => { ctx.emit({ type: 'change' }); return result; };
 
+// The second brain is the user's own and lives outside every project: never reachable through the
+// online relay. relay.js already refuses these ops (absent from its OP_PERMISSIONS); ctx.remote — set
+// for ops arriving through the connector, or from another machine on the network — is the second lock. No emit here: the hub
+// watches ~/.spectoflow/brain.md and tells local tabs only, whoever wrote it (page, MCP, run line).
+function brainOp(ctx, fn) {
+  if (ctx && ctx.remote) throw new OpError(404, 'Unknown operation.');
+  try { return fn(); } catch (e) { if (e.status && !(e instanceof OpError)) throw new OpError(e.status, e.message); throw e; }
+}
+
 const ops = {
   'project.read': async (root) => {
     const p = store.readProject(root);
@@ -190,7 +202,7 @@ const ops = {
 
   'run.start': async (root, { prompt, agent, display }, ctx) => {
     text(prompt, 'Empty request.');
-    const r = startRun(root, { prompt, agent, display }, ctx.emit);
+    const r = startRun(root, { prompt, agent, display, learn: !ctx.remote }, ctx.emit);
     if (r.error) bad(r.error);
     return { runId: r.runId };
   },
@@ -213,7 +225,7 @@ const ops = {
     const active = store.readRuntime(root).orchestration;
     if (active && ['running', 'awaiting_approval'].includes(active.status)) throw new OpError(409, 'An orchestration is already active.');
     const mode = store.readConfig(root).mode || 'semi';
-    orchestrator.runOrchestration({ root, request: req, mode, runStep: orchestrator.defaultRunStep, confirm: orchestrator.defaultConfirm }, ctx.emit)
+    orchestrator.runOrchestration({ root, request: req, mode, runStep: orchestrator.defaultRunStep, confirm: orchestrator.defaultConfirm, learn: !ctx.remote }, ctx.emit)
       .catch((e) => ctx.emit({ type: 'message', message: { role: 'orchestrator', kind: 'status', text: 'orchestration error: ' + e.message } }));
     const o = store.readRuntime(root).orchestration;
     return { orchestrationId: o && o.id };
@@ -248,6 +260,16 @@ const ops = {
     store.writeRuntime(root, rt);
     return changed(ctx, { item: it });
   },
+  'brain.read': async (_root, _args, ctx) => brainOp(ctx, () => ({ ...brain.read(), path: brain.brainPath(), agents: brainSetup.status() })),
+  'brain.add': async (_root, { category, text: body }, ctx) => brainOp(ctx, () => brain.add({ category, text: body, by: 'user' })),
+  'brain.update': async (_root, { id, patch }, ctx) => brainOp(ctx, () => ({ entry: brain.update(id, patch || {}) })),
+  'brain.remove': async (_root, { id }, ctx) => brainOp(ctx, () => brain.remove(id)),
+  'brain.confirm': async (_root, { id }, ctx) => brainOp(ctx, () => ({ entry: brain.confirm(id) })),
+  'brain.settings': async (_root, { autoAdd }, ctx) => brainOp(ctx, () => {
+    if (typeof autoAdd !== 'boolean') bad('autoAdd must be true or false.');
+    return { autoAdd: globalConfig.set('brain.autoAdd', autoAdd) };
+  }),
+
   'attention.remove': async (root, { id }, ctx) => {
     const rt = store.readRuntime(root); rt.attention = (rt.attention || []).filter((x) => x.id !== id); store.writeRuntime(root, rt);
     return changed(ctx, { ok: true });

package/lib/dashboard/orchestrator.js

@@ -25,7 +25,7 @@ function post(root, role, kind, text, emit) {
   emit({ type: 'message', message: m });
 }
 
-async function runOrchestration({ root, request, mode, runStep, confirm, resume }, emit) {
+async function runOrchestration({ root, request, mode, runStep, confirm, resume, learn = true }, emit) {
   const enabled = store.readWorkflow(root).filter((s) => s.enabled);
   let o, startAt = 0;
   if (resume) {
@@ -62,7 +62,7 @@ async function runOrchestration({ root, request, mode, runStep, confirm, resume
 
     st.status = 'running'; saveState(root, o, emit);
     post(root, 'orchestrator', 'status', `→ ${step.name} (${r.agent})`, emit);
-    const exit = await runStep({ root, step, agent: r.agent, skill: r.skill, request }, emit);
+    const exit = await runStep({ root, step, agent: r.agent, skill: r.skill, request, learn }, emit);
     if (exit !== 0) { st.status = 'failed'; o.status = 'failed'; saveState(root, o, emit); post(root, 'orchestrator', 'status', `⚠ ${step.name} failed (exit ${exit})`, emit); return o; }
     st.status = 'done'; saveState(root, o, emit);
   }
@@ -83,13 +83,13 @@ function buildPrompt({ step, agent, skill, request }) {
   ].join('\n');
 }
 
-function defaultRunStep({ root, step, agent, skill, request }, emit) {
+function defaultRunStep({ root, step, agent, skill, request, learn = true }, emit) {
   return new Promise((resolve) => {
     const prompt = buildPrompt({ step, agent, skill, request });
     const tool = store.readConfig(root).agent;
     // logPrompt:false — the orchestrator already posts a clean "→ step (agent)" line; the raw
     // priming prompt would otherwise show as a noisy user bubble.
-    const r = startRun(root, { prompt, agent: tool, logPrompt: false }, (e) => { emit(e); if (e.type === 'run-end') resolve(e.code); });
+    const r = startRun(root, { prompt, agent: tool, logPrompt: false, learn }, (e) => { emit(e); if (e.type === 'run-end') resolve(e.code); });
     if (r.error) { emit({ type: 'message', message: { role: 'orchestrator', kind: 'status', text: r.error } }); resolve(1); }
   });
 }