spectoflow 0.24.0 → 0.27.0

package/lib/dashboard/hub-server.js

@@ -25,6 +25,9 @@ const registry = require('../registry');
 const workspace = require('../workspace');
 const { createHandlers } = require('./handlers');
 const store = require('../store');
+const { createConnector } = require('./connector');
+const { ops, OpError } = require('./ops');
+const { injectDesign, DEFAULT_DESIGN } = require('./inject-design');
 
 const migrated = workspace.migrateLegacyHome();
 if (!workspace.exists()) workspace.init({});
@@ -40,18 +43,79 @@ function body(req) { return new Promise((r) => { let b = ''; req.on('data', (c)
 // handlers.js for every project (D64): nothing is ever require()'d from a project, so a project that
 // has never run `spectoflow update` opens exactly like a fresh one.
 const projects = new Map();
+
+// ---- online dashboard (C1): the connector role ----
+// One outbound connection to the online dashboard named in the workspace's remote.json (written by
+// `spectoflow dashboard login`). Only published projects (meta.json → published:true, cached here as
+// a Set so a chatty run-line stream never re-reads the file) are announced and relayed. Every project's
+// emit is teed: SSE clients first, then the connector — the same emit an op called from the relay
+// uses, so a local click and an online click hit one orchestrator, one pending gate, one state.
+let connector = null;
+let publishedIds = new Set();
+function refreshPublished() { publishedIds = new Set(workspace.listPublished().map((p) => p.id)); }
+const snapshotTimers = new Map();
+function scheduleSnapshot(id) {
+  clearTimeout(snapshotTimers.get(id));
+  snapshotTimers.set(id, setTimeout(async () => {
+    snapshotTimers.delete(id);
+    if (!connector || !publishedIds.has(id)) return;
+    try { const project = await readSnapshot(id); if (project) connector.pushSnapshot(id, project); } catch (_) {}
+  }, 500));
+}
+async function readSnapshot(id) {
+  const proj = getProject(id);
+  return proj ? ops['project.read'](proj.root, {}, { emit() {} }) : null;
+}
+function listPublishedForHello() {
+  return workspace.listPublished().map((p) => ({ localId: p.id, name: p.name, kind: p.kind || 'spectoflow', stats: projectStats(p.path) }));
+}
+async function execOp(localId, op, args) {
+  if (!publishedIds.has(localId)) throw new OpError(403, 'This project is not published.');
+  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 });
+}
+function startConnector() {
+  if (connector) { connector.stop(); connector = null; }
+  refreshPublished();
+  const remote = workspace.readRemote();
+  if (!remote) return;
+  connector = createConnector({
+    url: remote.url, token: remote.token, machineName: remote.machineName || os.hostname(), transport: remote.transport, version: VERSION,
+    listPublished: listPublishedForHello, readSnapshot, execOp, log: (m) => console.log(`spectoflow · ${m}`),
+  });
+  connector.start();
+}
+function remoteStatus() {
+  const remote = workspace.readRemote();
+  if (!remote) return { configured: false, url: null, machineName: null, connected: false, transport: null, lastError: null, since: null };
+  const s = connector ? connector.status() : { connected: false, transport: remote.transport, lastError: null, since: null };
+  return { configured: true, url: remote.url, machineName: remote.machineName, connected: s.connected, transport: s.transport, lastError: s.lastError, since: s.since };
+}
+
 function getProject(id) {
   if (projects.has(id)) return projects.get(id);
   const entry = registry.listProjects().find((p) => p.id === id);
   if (!entry || !fs.existsSync(entry.path)) return null;
   const handlers = createHandlers(entry.path);
   const clients = new Set();
-  const emit = (obj) => { const line = 'data: ' + JSON.stringify(obj) + '\n\n'; for (const res of clients) res.write(line); };
+  const emit = (obj) => {
+    const line = 'data: ' + JSON.stringify(obj) + '\n\n';
+    for (const res of clients) res.write(line);
+    if (connector && publishedIds.has(id)) { connector.pushEvent(id, obj); if (obj.type === 'change') scheduleSnapshot(id); }
+  };
   handlers.onBoot();
   const watchers = [];
+  // A single logical write (e.g. store.js's write-then-rename) can fire an fs.watch directory
+  // listener several times in a row for one underlying change (worst on Windows, which also reports
+  // sibling-entry metadata churn) — coalesce any burst within 150ms into exactly one 'change' emit,
+  // so a published project's connector feed gets one 'event' frame per real change, not several.
+  let changeTimer = null;
+  const onDirChange = () => { clearTimeout(changeTimer); changeTimer = setTimeout(() => emit({ type: 'change' }), 150); };
   handlers.watchDirs.forEach((d) => {
     const dir = path.join(entry.path, d);
-    if (fs.existsSync(dir)) { try { watchers.push(fs.watch(dir, { recursive: false }, () => emit({ type: 'change' }))); } catch (_) {} }
+    if (fs.existsSync(dir)) { try { watchers.push(fs.watch(dir, { recursive: false }, onDirChange)); } catch (_) {} }
   });
   const proj = { id, root: entry.path, handlers, clients, emit, watchers };
   projects.set(id, proj);
@@ -87,7 +151,7 @@ function projectStats(root) {
   } catch { return null; }
 }
 function listHubProjects() {
-  return registry.listProjects().map((p) => ({ ...p, stats: projectStats(p.path) }));
+  return registry.listProjects().map((p) => ({ ...p, stats: projectStats(p.path), published: publishedIds.has(p.id) }));
 }
 function listRoots() {
   const home = os.homedir();
@@ -129,7 +193,7 @@ function addHubProject(rawPath) {
 }
 async function handleHubApi(req, res, u) {
   const p = u.pathname;
-  if (p === '/api/hub/projects' && req.method === 'GET') { sendJSON(res, 200, { projects: listHubProjects() }); return true; }
+  if (p === '/api/hub/projects' && req.method === 'GET') { sendJSON(res, 200, { projects: listHubProjects(), remote: remoteStatus() }); return true; }
   if (p === '/api/hub/projects' && req.method === 'POST') {
     const { path: rawPath } = await body(req);
     if (!rawPath || !String(rawPath).trim()) { sendJSON(res, 400, { error: 'A folder path is required.' }); return true; }
@@ -140,6 +204,7 @@ async function handleHubApi(req, res, u) {
   if (/^\/api\/hub\/projects\/[^/]+$/.test(p) && req.method === 'DELETE') {
     const id = decodeURIComponent(p.split('/')[4] || '');
     const ok = registry.removeProject(id);
+    if (ok) { refreshPublished(); if (connector) connector.announce(); }
     sendJSON(res, ok ? 200 : 404, ok ? { ok: true } : { error: 'No project registered with that id.' });
     return true;
   }
@@ -155,13 +220,38 @@ async function handleHubApi(req, res, u) {
     sendJSON(res, 200, { ok: true, reloaded });
     return true;
   }
+  if (p === '/api/hub/remote' && req.method === 'GET') { sendJSON(res, 200, remoteStatus()); return true; }
+  if (p === '/api/hub/remote/reconnect' && req.method === 'POST') { startConnector(); sendJSON(res, 200, { ok: true, ...remoteStatus() }); return true; }
+  if (/^\/api\/hub\/projects\/[^/]+\/publish$/.test(p) && req.method === 'POST') {
+    const id = decodeURIComponent(p.split('/')[4] || '');
+    const { published } = await body(req);
+    const meta = workspace.setPublished(id, published !== false);
+    if (!meta) { sendJSON(res, 404, { error: 'No project registered with that id.' }); return true; }
+    refreshPublished();
+    if (connector) connector.announce();
+    sendJSON(res, 200, { ok: true, id, published: meta.published });
+    return true;
+  }
   return false;
 }
 
+// A viewer's own localStorage choice (once one exists) always wins client-side (app.js's IIFE at the
+// top of the file, and the reconciliation in renderSettings()) — this is only filling the gap for a
+// visitor with nothing saved yet, so the very first paint already matches the project's own
+// configured design instead of flashing whatever static default shipped in the HTML file.
+function projectDesign(root) {
+  if (!root) return DEFAULT_DESIGN;
+  try { return (store.readConfig(root) || {}).design || DEFAULT_DESIGN; }
+  catch { return DEFAULT_DESIGN; }
+}
+
 // Serves one static asset (or the SPA index.html fallback for an extensionless path) from the
 // shared, globally-installed PUBLIC dir — factored into a function since both the root-level and
-// /p/<id>/-prefixed requests need it.
-function serveStatic(reqPath, req, res) {
+// /p/<id>/-prefixed requests need it. `root` (the specific project's folder), when known, is used to
+// stamp the served HTML's <html data-design="..."> synchronously with that project's own
+// config.design, before the file ever reaches the browser — avoiding a flash of the wrong theme on a
+// viewer's very first-ever page load (no localStorage value saved yet to reconcile against).
+function serveStatic(reqPath, req, res, root) {
   const file = reqPath === '/' ? '/index.html' : reqPath;
   const full = path.join(PUBLIC, path.normalize(file).replace(/^(\.\.[/\\])+/, ''));
   if (!full.startsWith(PUBLIC)) { res.writeHead(403); return res.end('Forbidden'); }
@@ -171,14 +261,16 @@ function serveStatic(reqPath, req, res) {
       if (req.method === 'GET' && !path.extname(reqPath)) {
         return fs.readFile(path.join(PUBLIC, 'index.html'), (e2, d2) => {
           if (e2) { res.writeHead(404); return res.end('Not found'); }
-          res.writeHead(200, Object.assign({ 'Content-Type': MIME['.html'] }, noCache)); res.end(d2);
+          const html = root ? injectDesign(d2.toString('utf8'), projectDesign(root)) : d2;
+          res.writeHead(200, Object.assign({ 'Content-Type': MIME['.html'] }, noCache)); res.end(html);
         });
       }
       res.writeHead(404); return res.end('Not found');
     }
     const ext = path.extname(full);
     const headers = ext === '.woff2' || ext === '.woff' ? { 'Cache-Control': 'public, max-age=604800' } : noCache;
-    res.writeHead(200, Object.assign({ 'Content-Type': MIME[ext] || 'application/octet-stream' }, headers)); res.end(data);
+    const payload = (root && ext === '.html') ? injectDesign(data.toString('utf8'), projectDesign(root)) : data;
+    res.writeHead(200, Object.assign({ 'Content-Type': MIME[ext] || 'application/octet-stream' }, headers)); res.end(payload);
   });
 }
 
@@ -188,7 +280,7 @@ const LOCK = workspace.lockPath();
 function writeLock(){ try{ fs.mkdirSync(path.dirname(LOCK),{recursive:true}); fs.writeFileSync(LOCK, JSON.stringify({ pid:process.pid, port:PORT, url:`http://localhost:${PORT}`, startedAt:new Date().toISOString() })+'\n'); }catch{} }
 function clearLock(){ try{ const l=JSON.parse(fs.readFileSync(LOCK,'utf8')); if(l.pid===process.pid) fs.unlinkSync(LOCK); }catch{} }
 process.on('exit', clearLock);
-['SIGINT','SIGTERM'].forEach((s)=> process.on(s, ()=>{ clearLock(); process.exit(0); }));
+['SIGINT','SIGTERM'].forEach((s)=> process.on(s, ()=>{ if (connector) connector.stop(); clearLock(); process.exit(0); }));
 
 const server = http.createServer(async (req, res) => {
   const u = new URL(req.url, `http://localhost:${PORT}`);
@@ -226,7 +318,7 @@ const server = http.createServer(async (req, res) => {
       const proj = getProject(id);
       if (!proj) { res.writeHead(404); return res.end(projectErrorMessage(id)); }
       registry.touchProject(id);
-      return serveStatic(m[2] || '/', req, res);
+      return serveStatic(m[2] || '/', req, res, proj.root);
     }
 
     if (p === '/') {
@@ -246,4 +338,4 @@ 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)' : ''}`); });
+server.listen(PORT, () => { writeLock(); console.log(`spectoflow · hub → http://localhost:${PORT}${migrated.movedRegistry ? '  (moved your project list into the workspace)' : ''}`); startConnector(); });

package/lib/dashboard/inject-design.js

@@ -0,0 +1,41 @@
+'use strict';
+/*
+ * Shared by both dashboard surfaces — the local hub (hub-server.js) and the online relay
+ * (server/src/app.js) — so a project's own configured design (config.design) is stamped onto the
+ * served index.html's <html data-design="..."> attribute BEFORE the file ever reaches the browser.
+ * Design is a shared, project-level setting (not a per-viewer choice, Sous-projet B) — this is the
+ * ONLY place the design attribute is ever set for first paint; app.js has no localStorage fallback
+ * or reconciliation for it any more, it only reflects P.config.design once the client boots.
+ */
+
+// Mirrors app.js's currentDesign() own default ('console') when the attribute is absent — same
+// fallback a project with no design saved yet (or an unresolvable project) would land on anyway.
+const DEFAULT_DESIGN = 'console';
+
+// The real, live registry of selectable designs (lib/dashboard/public/designs.js) — required, not
+// re-declared here, so an id added/removed there is instantly reflected here with zero drift risk.
+const DESIGNS = require('./public/designs.js');
+const KNOWN_IDS = new Set(DESIGNS.map((d) => d.id));
+
+// Only ever accept a value that is one of the real, currently-registered design ids — never trust an
+// arbitrary stored/cached string into the HTML (that would be an injection risk), and never trust a
+// shape-valid but unregistered id either (a stale/typo'd/removed design would silently produce an
+// unstyled page instead of falling back to the same default a missing value gets).
+function sanitizeDesign(d) {
+  return (typeof d === 'string' && KNOWN_IDS.has(d)) ? d : DEFAULT_DESIGN;
+}
+
+// Rewrites (or adds) the <html> tag's data-design attribute to the given value — leaves everything
+// else in the file untouched, including data-theme (config.theme is applied client-side once app.js
+// boots, same as before — this injector was only ever built to solve design's first-paint flash).
+function injectDesign(html, design) {
+  const safe = sanitizeDesign(design);
+  return html.replace(/<html([^>]*)>/i, (full, attrs) => {
+    const newAttrs = /\bdata-design=/.test(attrs)
+      ? attrs.replace(/data-design="[^"]*"/, `data-design="${safe}"`)
+      : `${attrs} data-design="${safe}"`;
+    return `<html${newAttrs}>`;
+  });
+}
+
+module.exports = { injectDesign, sanitizeDesign, DEFAULT_DESIGN };

package/lib/dashboard/meeting.js

@@ -0,0 +1,116 @@
+'use strict';
+/*
+ * Daily meeting — generates a dated standup-style note (.spectoflow/meetings/<date>.md) via the
+ * configured agent. Structurally parallel to summarize.js's runSummarize (read that first — this
+ * file mirrors its resolveRunnerCommand/spawn/emit shape exactly) but differs in two ways: what it
+ * feeds the agent (a digest of recent task activity + the chat log, not just the chat log alone) and
+ * where the result lands (a dated file under .spectoflow/meetings/, via files.js, never
+ * runtime.messages — a meeting note is a project artifact, not a chat message).
+ */
+const { spawn } = require('child_process');
+const store = require('../store');
+const files = require('./files');
+const { resolveRunnerCommand } = require('./runner');
+const { formatLog } = require('./summarize'); // reused as-is rather than reimplemented — see report
+
+const TASK_LIMIT = 20; // mirrors summarize.js's own DEFAULT_LIMIT philosophy (cap, most-recent-last)
+const LOG_LIMIT = 40; // same DEFAULT_LIMIT summarize.js uses for the chat log
+
+// YYYY-MM-DD in the machine running the dashboard's OWN local time zone. This is a deliberate,
+// explicit choice (see the project report for the full reasoning): a meeting note's filename must be
+// unambiguous, and this is a single-writer local tool — a viewer's own browser time zone must never
+// decide which file "today" resolves to (it could differ from the server's, or from another viewer's
+// browser, producing two different "today"s for the same project). The client reads this same value
+// back from GET /api/project (ops.js's 'project.read' → p.todayDate), so both halves of this feature
+// (manual edit and agent-generate) agree on exactly one "today".
+function todayLocal() {
+  const d = new Date();
+  const y = d.getFullYear(), m = String(d.getMonth() + 1).padStart(2, '0'), day = String(d.getDate()).padStart(2, '0');
+  return `${y}-${m}-${day}`;
+}
+
+// "id: title (status)" lines for tasks that are done or in_progress — a cheap, already-available
+// proxy for "what was built / is in flight" (no new aggregation invented), most-recent-last order
+// (readPlans' own file/task order), capped to TASK_LIMIT.
+function formatTasks(plans, limit = TASK_LIMIT) {
+  const tasks = [];
+  for (const pl of plans || []) {
+    for (const ph of pl.phases || []) {
+      for (const t of ph.tasks || []) {
+        if (t.status === 'done' || t.status === 'in_progress') tasks.push(t);
+      }
+    }
+  }
+  return tasks.slice(-limit).map((t) => `${t.id}: ${t.title} (${t.status})`).join('\n');
+}
+
+// Strict YYYY-MM-DD only. This is the security boundary for the meetings feature: meetingPath()
+// concatenates `date` straight into a file path, and files.writeFile()'s own safePath() guard only
+// rejects a path that resolves OUTSIDE the project root entirely — it does NOT confine a write to
+// .spectoflow/meetings/, so an unvalidated date like "../../important" would happily write to
+// <root>/important.md. Every caller of meetingPath()/runMeetingGenerate() with a date that did not
+// come from todayLocal() MUST go through this check first (see runMeetingGenerate below).
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function isValidDate(date) {
+  return DATE_RE.test(date);
+}
+
+function meetingPath(date) {
+  return `.spectoflow/meetings/${date}.md`;
+}
+
+// Same "reply with the text only" instruction line runSummarize already uses (already well-tuned),
+// adapted for a daily-meeting-note framing instead of a chat-log-digest framing.
+function buildPrompt(plans, messages) {
+  const taskDigest = formatTasks(plans) || '(no done / in-progress tasks yet)';
+  const logDigest = formatLog(messages, LOG_LIMIT) || '(no recent chat activity)';
+  return 'Write a short daily meeting note for this project, standup-style: what was done, '
+    + 'what\'s in progress or blocked, and suggested next steps — 3-6 concise bullet points or short '
+    + 'paragraphs. Reply with the note text only: no preamble, no sentinel lines, and do not read, '
+    + 'search or edit any files — answer using only the digest below.'
+    + '\n\nRecent tasks:\n' + taskDigest
+    + '\n\nRecent chat log:\n' + logDigest;
+}
+
+// Generates a daily meeting note and WRITES it to .spectoflow/meetings/<date>.md (default: today —
+// see todayLocal()), OVERWRITING whatever is already there. Overwrite-SAFETY (not silently
+// destroying a real existing note) is the CLIENT's responsibility — see app.js's meeting-generate
+// confirm flow — this function trusts its caller the same way runSummarize trusts chat.summarize's
+// caller. Returns { child } on success or { error }, mirroring runSummarize's own shape exactly.
+function runMeetingGenerate(root, { agent, date } = {}, emit) {
+  const cfg = store.readConfig(root);
+  const which = agent || cfg.agent || 'claude';
+  const cmdStr = resolveRunnerCommand(root, cfg, which);
+  if (!cmdStr) return { error: `No runner configured for "${which}".` };
+
+  const day = date || todayLocal();
+  if (!isValidDate(day)) return { error: 'Invalid date.' };
+  const plans = store.readPlans(root);
+  const messages = store.readRuntime(root).messages || [];
+  const prompt = buildPrompt(plans, messages);
+
+  const parts = cmdStr.split(/\s+/).filter(Boolean);
+  const runId = 'meeting-' + Date.now().toString(36);
+  // Emitted before the spawn attempt (same order runner.js/summarize.js use) so the client's "agent
+  // running" indicator lights up immediately, and a spawn failure below still gets a matching run-end.
+  if (emit) emit({ type: 'run-start', run: { id: runId } });
+  let child;
+  // windowsHide: without it, spawning a .cmd-shimmed CLI on Windows pops up a real console window.
+  try { child = spawn(parts[0], [...parts.slice(1), prompt], { cwd: root, env: process.env, windowsHide: true }); }
+  catch (e) { if (emit) emit({ type: 'run-end', runId, code: 1 }); return { error: e.message }; }
+  try { child.stdin && child.stdin.end(); } catch {}
+
+  let out = '';
+  child.stdout && child.stdout.on('data', (d) => { out += d.toString(); });
+  child.stderr && child.stderr.on('data', (d) => { out += d.toString(); });
+  child.on('close', (code) => {
+    const text = out.trim() || (code === 0 ? '(no output)' : `meeting generate failed (exit ${code})`);
+    files.writeFile(root, meetingPath(day), text);
+    // run-end before change, same ordering summarize.js uses — the client must never see "running"
+    // linger past the point where the new content is actually ready to be re-fetched.
+    if (emit) { emit({ type: 'run-end', runId, code }); emit({ type: 'change' }); }
+  });
+  return { child };
+}
+
+module.exports = { runMeetingGenerate, formatTasks, todayLocal, meetingPath, buildPrompt, isValidDate };

package/lib/dashboard/ops.js

@@ -13,6 +13,7 @@ const store = require('../store');
 const files = require('./files');
 const { startRun } = require('./runner');
 const { runSummarize } = require('./summarize');
+const { runMeetingGenerate, todayLocal } = require('./meeting');
 const orchestrator = require('./orchestrator');
 const adapters = require('../adapters');
 const detect = require('../detect');
@@ -46,12 +47,83 @@ function readAgentFile(root, rel) {
   if (!okReal || !real.endsWith('.md') || fs.statSync(real).isDirectory()) bad('not an agent/skill file');
   return { content: fs.readFileSync(real, 'utf8') };
 }
+// The 6 Kanban column ids, mirroring app.js's STATUS keys exactly (order doesn't matter here — the
+// client always re-derives display order from its own STATUS object). Kept as the one server-side
+// source of truth for "what's a real column id" — never trust the client's array blindly.
+const KANBAN_STATUSES = ['todo', 'in_progress', 'to_validate', 'to_analyze', 'done', 'blocked'];
+// The 13 native nav tab ids (Sous-projet C: Task 1 built the mechanism with the original 11; Task 2
+// 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'];
 function writeConfig(root, patch, detectOpts) {
   const cp = path.join(root, '.spectoflow', 'config.json');
   const cfg = JSON.parse(fs.readFileSync(cp, 'utf8'));
   if (patch.mode && ['autopilot', 'semi', 'manual'].includes(patch.mode)) cfg.mode = patch.mode;
   if (typeof patch.language === 'string' && patch.language.trim()) cfg.language = patch.language.trim();
   if (typeof patch.design === 'string' && /^[a-z0-9-]{1,40}$/.test(patch.design)) cfg.design = patch.design;
+  if (typeof patch.theme === 'string' && ['light', 'dark'].includes(patch.theme)) cfg.theme = patch.theme;
+  if (typeof patch.boardView === 'string' && ['list', 'kanban'].includes(patch.boardView)) cfg.boardView = patch.boardView;
+  if (typeof patch.sideHidden === 'boolean') cfg.sideHidden = patch.sideHidden;
+  if (Array.isArray(patch.expandedPhases)) cfg.expandedPhases = patch.expandedPhases.filter((v) => typeof v === 'string');
+  if (typeof patch.activeTab === 'string' && patch.activeTab.trim()) cfg.activeTab = patch.activeTab.trim();
+  if (typeof patch.chatOpen === 'boolean') cfg.chatOpen = patch.chatOpen;
+  // kanbanColumns: reject the whole patch (leave the current value untouched) rather than silently
+  // filtering out bad entries — an invalid/unknown status id here means the client sent something it
+  // shouldn't have, and a real product-safety rule (never persist zero visible columns) applies too.
+  if (Array.isArray(patch.kanbanColumns)) {
+    const allKnown = patch.kanbanColumns.every((v) => typeof v === 'string' && KANBAN_STATUSES.includes(v));
+    const uniq = [...new Set(patch.kanbanColumns)];
+    if (allKnown && uniq.length) cfg.kanbanColumns = uniq;
+  }
+  if (patch.kanbanPageSize === 10 || patch.kanbanPageSize === 20) cfg.kanbanPageSize = patch.kanbanPageSize;
+  // navTabs: same "reject the whole patch" philosophy as kanbanColumns above — plus a stricter safety
+  // rule than Kanban's "can't disable the last column": the stored list must always be a COMPLETE
+  // reordering/enable-state of the full native tab set (every known id exactly once, never a partial
+  // filter), and 'personalize' must always stay enabled — it's the only place the user can ever turn
+  // a tab back on, so letting it be disabled would permanently lock them out (short of hand-editing
+  // config.json on disk).
+  if (patch.navTabs !== undefined) {
+    const arr = patch.navTabs;
+    const valid = Array.isArray(arr)
+      && arr.every((v) => v && typeof v === 'object' && typeof v.id === 'string' && typeof v.enabled === 'boolean')
+      && arr.length === NATIVE_TABS.length
+      && new Set(arr.map((v) => v.id)).size === NATIVE_TABS.length
+      && arr.every((v) => NATIVE_TABS.includes(v.id));
+    const personalizeOk = valid && arr.find((v) => v.id === 'personalize').enabled === true;
+    if (personalizeOk) cfg.navTabs = arr.map((v) => ({ id: v.id, enabled: v.enabled }));
+  }
+  // commands: the dashboard's slash-command macros. Same "reject the whole patch" safety as
+  // kanbanColumns/navTabs above — if it isn't an array, or ANY entry is structurally malformed (a
+  // trigger that fails the format, or an empty instruction), the stored list is left untouched rather
+  // than partially applied. A valid array (including an empty one) replaces it: triggers are deduped
+  // case-insensitively (first wins), description/instruction are trimmed and clamped, enabled coerced.
+  if (patch.commands !== undefined) {
+    const arr = patch.commands;
+    // The format regex has no /i flag (the client is expected to normalize to lowercase before
+    // sending), but it is tested against the lowercased trigger here rather than the raw one: this
+    // still enforces the exact charset/length rule while letting an occasional mixed-case trigger
+    // (e.g. a client that didn't normalize) validate and dedupe correctly instead of taking down the
+    // whole patch over casing alone. The stored trigger is always the canonical lowercase form.
+    const okShape = Array.isArray(arr) && arr.every((c) => c && typeof c === 'object'
+      && typeof c.trigger === 'string' && /^[a-z0-9][a-z0-9_-]{0,39}$/.test(c.trigger.toLowerCase())
+      && typeof c.instruction === 'string' && c.instruction.trim().length > 0);
+    if (okShape) {
+      const seen = new Set(); const out = [];
+      for (const c of arr) {
+        const lc = c.trigger.toLowerCase();
+        if (seen.has(lc)) continue;
+        seen.add(lc);
+        out.push({
+          trigger: lc,
+          description: (typeof c.description === 'string' ? c.description.trim() : '').slice(0, 120),
+          instruction: c.instruction.trim().slice(0, 4000),
+          enabled: c.enabled !== false,
+        });
+      }
+      cfg.commands = out;
+    }
+  }
   if (typeof patch.agent === 'string' && patch.agent.trim()) {
     const id = patch.agent.trim();
     const known = adapters.knownAgents().find((a) => a.id === id);
@@ -73,6 +145,10 @@ const ops = {
     p.projectName = path.basename(root);
     p.knownAgents = adapters.knownAgents().map((a) => ({ id: a.id, label: a.label, headless: a.headless, docsUrl: a.docsUrl }));
     p.installedAgents = detect.installedAgents(root);
+    // Daily meeting (Sous-projet C, Task 3): the SERVER's own local date — see meeting.js's
+    // todayLocal() header comment for why this, not the browser's date, is the one source of truth
+    // for which .spectoflow/meetings/<date>.md "today" resolves to.
+    p.todayDate = todayLocal();
     return p;
   },
   'agentfile.read': async (root, { path: rel }) => readAgentFile(root, rel),
@@ -112,9 +188,9 @@ const ops = {
     return changed(ctx, { ok: true });
   },
 
-  'run.start': async (root, { prompt, agent }, ctx) => {
+  'run.start': async (root, { prompt, agent, display }, ctx) => {
     text(prompt, 'Empty request.');
-    const r = startRun(root, { prompt, agent }, ctx.emit);
+    const r = startRun(root, { prompt, agent, display }, ctx.emit);
     if (r.error) bad(r.error);
     return { runId: r.runId };
   },
@@ -123,6 +199,11 @@ const ops = {
     if (r.error) bad(r.error);
     return { ok: true };
   },
+  'meeting.generate': async (root, { agent, date }, ctx) => {
+    const r = runMeetingGenerate(root, { agent, date }, ctx.emit);
+    if (r.error) bad(r.error);
+    return { ok: true };
+  },
   'chat.clear': async (root, _args, ctx) => {
     const rt = store.readRuntime(root); rt.messages = []; store.writeRuntime(root, rt);
     return changed(ctx, { ok: true });