nothumanallowed 13.2.44 → 13.2.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "13.2.44",
+  "version": "13.2.46",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/commands/ui.mjs

@@ -2911,21 +2911,29 @@ ${context ? `## OUTPUT FROM PREVIOUS AGENTS:\n${context.slice(0, 6000)}\n` : ''}
               const bodyStart = bodyHtml.search(/<body[^>]*>/i);
               if (bodyStart >= 0) bodyHtml = bodyHtml.slice(bodyStart).replace(/<body[^>]*>/i, '').replace(/<\/body>[\s\S]*/i, '').trim();
             }
+            // Derive a short report title from the task (skip stop words, take first 5-6 meaningful words)
+            const stopWords = new Set(['di','la','il','lo','le','gli','un','una','dei','del','della','per','che','con','su','in','e','a','da','è','come','analizza','analisi','ricerca','crea','genera','fai','fammi','dammi','the','of','for','and','a','an','in','with','on','about','analyze','analysis','research','create','generate','make','find','search']);
+            const titleWords = task.replace(/[.,;:!?]/g,'').split(/\s+/).filter(w => w.length > 2 && !stopWords.has(w.toLowerCase())).slice(0, 6);
+            const reportTitle = titleWords.length > 0 ? titleWords.map(w => w.charAt(0).toUpperCase()+w.slice(1)).join(' ') : 'Studio Report';
             // Fallback: if LLM output is empty or has no HTML tags, build body from context using markdown→HTML conversion
             if (!bodyHtml || !bodyHtml.includes('<')) {
-              const reportTitle = task.slice(0, 80).replace(/</g,'&lt;');
               const sections = context.split(/\n#{1,3} |(?=\n\n)/).filter(s => s.trim()).slice(0, 12);
-              bodyHtml = `<div class="header"><h1>${reportTitle}</h1><p>NHA Studio Report \u00b7 ${today}</p><div class="meta"><span>${today}</span></div></div>` +
+              bodyHtml = `<div class="header"><h1>${reportTitle.replace(/</g,'&lt;')}</h1><p>NHA Studio Report \u00b7 ${today}</p><div class="meta"><span>${today}</span></div></div>` +
                 sections.map(s => {
                   const lines = s.replace(/\*\*/g,'').replace(/\*/g,'').trim().split('\n').filter(Boolean);
-                  const title = lines[0] || '';
+                  const stitle = lines[0] || '';
                   const body = lines.slice(1).map(l => `<p>${l.replace(/</g,'&lt;')}</p>`).join('');
-                  return `<div class="section"><div class="section-title">${title.replace(/</g,'&lt;')}</div>${body}</div>`;
+                  return `<div class="section"><div class="section-title">${stitle.replace(/</g,'&lt;')}</div>${body}</div>`;
                 }).join('') +
                 `<div class="footer">NHA Studio \u00b7 ${today}</div>`;
+            } else {
+              // Replace the h1 inside existing header div if the model included the full prompt as title
+              bodyHtml = bodyHtml.replace(/(<div[^>]*class="header"[^>]*>[\s\S]*?<h1[^>]*>)([^<]{60,})(<\/h1>)/, (m, open, title, close) => {
+                return open + reportTitle.replace(/</g,'&lt;') + close;
+              });
             }
             // Always wrap in the guaranteed NHA dark CSS template
-            const finalHtml = wrapInNHATemplate(bodyHtml, task.slice(0, 60));
+            const finalHtml = wrapInNHATemplate(bodyHtml, reportTitle);
             sendToken('\n\n[Report generato]');
             sendEvent({ canvas: finalHtml });
           }
@@ -2947,6 +2955,164 @@ ${context ? `## OUTPUT FROM PREVIOUS AGENTS:\n${context.slice(0, 6000)}\n` : ''}
         return;
       }
 
+      // ── Studio: Parliament deliberation (SSE streaming) ──────────────────
+      // Implements the Legion DeliberationEngine protocol adapted for Studio:
+      // Round 1 outputs already exist (from normal workflow steps).
+      // Round 2: each agent cross-reads all others' Round 1 outputs and refines.
+      // Convergence: Jaccard similarity on key terms between R1 and R2 outputs.
+      // Round 3 (optional): if divergence > threshold, HERALD mediates.
+      if (pathname === '/api/studio/deliberate' && method === 'POST') {
+        const body = await parseBody(req);
+        const { task, proposals, language: bodyLang } = body;
+        if (!task || !Array.isArray(proposals) || proposals.length < 2) {
+          sendJSON(res, 400, { error: 'task and at least 2 proposals required' });
+          logRequest(method, pathname, 400, Date.now() - start);
+          return;
+        }
+
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+          'Access-Control-Allow-Origin': '*',
+        });
+
+        const sendEv2 = (data) => { try { res.write(`data: ${JSON.stringify(data)}\n\n`); } catch {} };
+        const sendTok2 = (t) => sendEv2({ token: t });
+        const keepaliveD = setInterval(() => { try { res.write(': keepalive\n\n'); } catch {} }, 5000);
+        const language = bodyLang || 'Italian';
+        const today = new Date().toISOString().slice(0, 10);
+
+        // Jaccard similarity between two texts (key terms 4+ chars)
+        const jaccard = (a, b) => {
+          const terms = (s) => new Set(s.toLowerCase().match(/\b\w{4,}\b/g) || []);
+          const sa = terms(a), sb = terms(b);
+          let inter = 0;
+          for (const w of sa) { if (sb.has(w)) inter++; }
+          const union = sa.size + sb.size - inter;
+          return union > 0 ? inter / union : 1;
+        };
+
+        const measureConvergence = (outputs) => {
+          if (outputs.length < 2) return 1.0;
+          let total = 0, pairs = 0;
+          for (let i = 0; i < outputs.length; i++) {
+            for (let j = i + 1; j < outputs.length; j++) {
+              total += jaccard(outputs[i], outputs[j]);
+              pairs++;
+            }
+          }
+          return pairs > 0 ? total / pairs : 1.0;
+        };
+
+        try {
+          const eligibleProposals = proposals.filter(p => p.agent !== 'CanvasAgent' && p.agent !== 'GitHubAgent' && p.agent !== 'EmailAgent' && p.agent !== 'CalendarAgent');
+          if (eligibleProposals.length < 2) {
+            sendEv2({ deliberation_done: true, skipped: true, reason: 'not enough specialist agents' });
+            sendEv2({ done: true });
+            res.write('data: [DONE]\n\n');
+            res.end();
+            clearInterval(keepaliveD);
+            logRequest(method, pathname, 200, Date.now() - start);
+            return;
+          }
+
+          // Round 1 convergence
+          const r1Convergence = measureConvergence(eligibleProposals.map(p => p.output));
+          sendTok2(`[Parlamento — Round 1 convergenza: ${(r1Convergence * 100).toFixed(0)}%] `);
+
+          const buildCrossReadCtx = (excludeAgent) =>
+            eligibleProposals
+              .filter(p => p.agent !== excludeAgent)
+              .map(p => `## ${p.label || p.agent} (Round 1):\n${p.output.slice(0, 2000)}`)
+              .join('\n\n---\n\n');
+
+          // Round 2: cross-reading + refinement (sequential to save tokens)
+          sendTok2('[Parlamento — Round 2: Cross-Reading & Refinamento] ');
+          const r2Results = [];
+
+          for (const proposal of eligibleProposals) {
+            sendTok2(`[Round 2: ${proposal.label || proposal.agent}] `);
+            const crossCtx = buildCrossReadCtx(proposal.agent);
+            const r2Sys = `You are ${proposal.agent}, a specialist AI agent in NHA Studio Parliament. Today is ${today}. Respond entirely in ${language}.
+
+## WORKFLOW GOAL: ${task}
+
+## YOUR ROUND 1 RESPONSE:
+${proposal.output.slice(0, 1500)}
+
+## OTHER AGENTS' ROUND 1 PROPOSALS:
+${crossCtx}
+
+DELIBERATION ROUND 2 — REFINEMENT:
+1. Review the other agents' proposals
+2. Incorporate valid points where you AGREE — mark with [ASSIST]
+3. Flag genuine disagreements with [CONTRADICTION] and explain your reasoning
+4. Produce your COMPLETE REFINED response (full answer, not a diff)
+5. Keep your analysis focused on: ${task}`;
+
+            let r2Out = '';
+            try {
+              await callLLMStream(config, r2Sys, 'Produce your refined Round 2 response.',
+                (tok) => { r2Out += tok; }, { max_tokens: 2048 });
+            } catch (e) { r2Out = proposal.output; }
+            r2Results.push({ agent: proposal.agent, label: proposal.label, icon: proposal.icon, output: r2Out });
+            sendEv2({ deliberation_r2: { agent: proposal.agent, label: proposal.label, icon: proposal.icon, output: r2Out } });
+          }
+
+          // Round 2 convergence
+          const r2Convergence = measureConvergence(r2Results.map(r => r.output));
+          sendTok2(`[Parlamento — Round 2 convergenza: ${(r2Convergence * 100).toFixed(0)}%] `);
+          const converged = r2Convergence >= 0.30;
+
+          // Round 3: mediation only if still divergent
+          let mediationOutput = '';
+          if (!converged) {
+            sendTok2('[Parlamento — Round 3: Mediazione...] ');
+            const allR2Ctx = r2Results
+              .map(r => `## ${r.label || r.agent}:\n${r.output.slice(0, 1500)}`)
+              .join('\n\n---\n\n');
+            const medSys = `You are HERALD, the Parliament Mediator in NHA Studio. Today is ${today}. Respond entirely in ${language}.
+
+## WORKFLOW GOAL: ${task}
+
+## ALL AGENTS' REFINED POSITIONS (Round 2):
+${allR2Ctx}
+
+MEDIATION TASK:
+1. Identify core points of AGREEMENT across all agents
+2. For each disagreement, evaluate which position has stronger evidence
+3. Produce a UNIFIED synthesis preserving genuine insights from each agent
+4. Make clear editorial choices — do NOT blend blindly
+5. Output a complete executive summary with concrete action items for: ${task}`;
+            try {
+              await callLLMStream(config, medSys, 'Produce the mediated Parliament consensus.',
+                (tok) => { mediationOutput += tok; }, { max_tokens: 3000 });
+            } catch (e) { mediationOutput = ''; }
+            sendEv2({ deliberation_r3: { output: mediationOutput } });
+          }
+
+          clearInterval(keepaliveD);
+          sendEv2({
+            deliberation_done: true,
+            r1_convergence: r1Convergence,
+            r2_convergence: r2Convergence,
+            converged,
+            r2_results: r2Results,
+            mediation: mediationOutput || null,
+          });
+          sendEv2({ done: true });
+          res.write('data: [DONE]\n\n');
+          res.end();
+        } catch (e) {
+          clearInterval(keepaliveD);
+          sendEv2({ error: e.message });
+          res.end();
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
       // ── 404 ──────────────────────────────────────────────────────────
       sendJSON(res, 404, { error: 'Not found' });
       logRequest(method, pathname, 404, Date.now() - start);

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '13.2.44';
+export const VERSION = '13.2.46';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/web-ui.mjs

@@ -2971,12 +2971,13 @@ function renderSidebar() {
 
 var studioState = {
   task: '',
-  nodes: [],       // [{icon,agent,label,status:'waiting'|'running'|'done'|'error'}]
+  nodes: [],       // [{icon,agent,label,status:'waiting'|'running'|'done'|'error',output:''}]
   log: [],         // [{agent,icon,text,time,type:'agent'|'system'|'error'}]
   result: '',
   canvas: null,    // HTML canvas content if generated
   running: false,
-  planned: false
+  planned: false,
+  parliamentMode: false
 };
 
 var studioAbortController = null;
@@ -3001,6 +3002,7 @@ function studioReset() {
   studioState.nodes = [];
   studioState.log = [];
   studioState.result = '';
+  studioState.canvas = null;
   studioState.running = false;
   studioState.planned = false;
   studioTokens = {in:0, out:0};
@@ -3176,6 +3178,7 @@ async function runStudio() {
       }
       studioSetNodeStatus(i, 'done');
       var realOutput = (stepResult.output && stepResult.output !== '(no output)') ? stepResult.output : null;
+      studioState.nodes[i].output = realOutput || '';
       studioLog(node.label, node.icon, realOutput || (stepResult.canvas ? '[Canvas report generated]' : '(done)'), 'agent', true);
       // If CanvasAgent produced HTML, open it in the canvas panel
       if (stepResult.canvas) {
@@ -3191,6 +3194,68 @@ async function runStudio() {
       context = realOutput || stepResult.canvas || context;
     }
 
+    // Parliament mode: Round 2 cross-reading deliberation
+    var parliamentChk = document.getElementById(\x27studioParliamentMode\x27);
+    if (parliamentChk && parliamentChk.checked && studioState.nodes.length >= 2) {
+      var proposals = studioState.nodes
+        .filter(function(n) { return n.output && n.output !== \x27(no output)\x27 && n.agent !== \x27CanvasAgent\x27; })
+        .map(function(n) { return {agent: n.agent, label: n.label, output: n.output}; });
+      if (proposals.length >= 2) {
+        studioLog(\x27Parlamento\x27, \x27♖\x27, \x27Avvio deliberazione — Round 2 cross-reading tra agenti...\x27, \x27system\x27);
+        var deliberateBody = JSON.stringify({task: task, proposals: proposals, language: document.getElementById(\x27langSelect\x27) ? document.getElementById(\x27langSelect\x27).value : \x27it\x27});
+        try {
+          var delRes = await fetch(\x27/api/studio/deliberate\x27, {method:\x27POST\x27, headers:{\x27Content-Type\x27:\x27application/json\x27}, body: deliberateBody, signal: studioAbortController ? studioAbortController.signal : undefined});
+          if (delRes.ok) {
+            var delReader = delRes.body.getReader();
+            var delDecoder = new TextDecoder();
+            var delBuf = \x27\x27;
+            var delDone = false;
+            while (!delDone) {
+              var delChunk = await delReader.read();
+              if (delChunk.done) break;
+              delBuf += delDecoder.decode(delChunk.value, {stream:true});
+              var delLines = delBuf.split(\x27\\n\x27);
+              delBuf = delLines.pop();
+              delLines.forEach(function(ln) {
+                if (!ln.startsWith(\x27data: \x27)) return;
+                var dd = ln.slice(6).trim();
+                if (dd === \x27[DONE]\x27) { delDone = true; return; }
+                try {
+                  var dev = JSON.parse(dd);
+                  if (dev.token) {
+                    // Status tokens from server — update last log entry text inline
+                    var delEntries = document.querySelectorAll(\x27.studio-log-entry\x27);
+                    var delLast = delEntries[delEntries.length - 1];
+                    if (delLast) { var delTb = delLast.querySelector(\x27.studio-log-entry__text\x27); if (delTb) delTb.textContent = dev.token; }
+                  } else if (dev.deliberation_r2) {
+                    var r2d = dev.deliberation_r2;
+                    studioLog(r2d.label || r2d.agent, \x27♖\x27, \x27[R2] \x27 + (r2d.output || \x27\x27).slice(0, 300), \x27agent\x27, true);
+                    var ni2 = studioState.nodes.findIndex(function(x){return x.agent===r2d.agent;});
+                    if (ni2 >= 0) { studioState.nodes[ni2].output = r2d.output; }
+                    context = r2d.output || context;
+                  } else if (dev.deliberation_r3) {
+                    studioLog(\x27HERALD\x27, \x27🔧\x27, \x27[Mediazione] \x27 + (dev.deliberation_r3.output || \x27\x27).slice(0, 300), \x27system\x27, true);
+                    context = dev.deliberation_r3.output || context;
+                  } else if (dev.deliberation_done) {
+                    var r2Conv = Math.round((dev.r2_convergence || 0) * 100);
+                    studioLog(\x27Parlamento\x27, \x27♖\x27, \x27Deliberazione completa — convergenza R2: \x27 + r2Conv + \x27%\x27, \x27system\x27);
+                    if (dev.mediation) { context = dev.mediation; }
+                    delDone = true;
+                  } else if (dev.done) {
+                    delDone = true;
+                  }
+                } catch(e2) {}
+              });
+            }
+          }
+        } catch(e3) {
+          if (e3.name !== \x27AbortError\x27) {
+            studioLog(\x27Parlamento\x27, \x27♖\x27, \x27Deliberazione non disponibile: \x27 + (e3.message || String(e3)), \x27error\x27);
+          }
+        }
+      }
+    }
+
     // Final result is the last step's output
     studioState.result = context;
     renderStudioResult();
@@ -3497,6 +3562,10 @@ function renderStudio(el) {
               '<button onclick="studioReset()" title="' + t('reset') + '" style="padding:8px 12px;background:none;border:1px solid var(--border);border-radius:8px;color:var(--dim);cursor:pointer;font-size:16px;line-height:1" ' + (studioState.running ? 'disabled' : '') + '>&#8635;</button>' +
             '</div>' +
           '</div>' +
+          '<label style="display:flex;align-items:center;gap:8px;margin-top:8px;cursor:pointer;user-select:none">' +
+            '<input type="checkbox" id="studioParliamentMode" style="width:15px;height:15px;accent-color:var(--green3)" ' + (studioState.parliamentMode ? \x27checked\x27 : \x27\x27) + ' onchange="studioState.parliamentMode=this.checked">' +
+            '<span style="font-size:12px;color:var(--dim)">&#x2656; <strong style="color:var(--green)">Parlamento</strong> — Round 2 cross-reading tra agenti (2x token)</span>' +
+          '</label>' +
         '</div>' +
 
         // ── MANUAL BUILDER MODE ──