nothumanallowed 13.2.43 → 13.2.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "13.2.43",
+  "version": "13.2.45",
   "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

@@ -2600,7 +2600,11 @@ export async function cmdUI(args) {
           if (!hasSpecialist && (hasBriefing || steps.length > 0)) {
             steps.push({icon:'\u{1F4F0}',agent:'HERALD',label:it?'HERALD \u2014 Briefing esecutivo':'HERALD \u2014 Executive briefing',prompt:'Based on ALL the data collected by the previous steps, write a complete executive briefing with priorities, findings, and strategic recommendations. Do NOT invent data — only use what was provided.'});
           }
-          if (hasCanvas) steps.push({icon:'\u{1F4CA}',agent:'CanvasAgent',label:it?'Dashboard HTML':'HTML Dashboard',prompt:'Create a professional HTML dashboard report with the briefing data'});
+          // Add CanvasAgent: always when explicitly requested OR when 2+ specialist agents ran (complex analysis deserves a visual report)
+          const specialistCount = [hasSecurity,hasFinance,hasStrategy,hasReputation,hasCode,hasWriting,hasData].filter(Boolean).length;
+          if (hasCanvas || specialistCount >= 2 || (hasSpecialist && hasBriefing)) {
+            steps.push({icon:'\u{1F4CA}',agent:'CanvasAgent',label:it?'Dashboard HTML':'HTML Dashboard',prompt:'Create a professional HTML dashboard report summarizing all findings from the previous agents'});
+          }
           return steps;
         };
 
@@ -2822,8 +2826,12 @@ RULES:
             // These agents fetched real data — use a focused prompt (no tool definitions to avoid JSON output)
             const agentInstruction = `You are ${agent}, a specialist AI agent inside NHA Studio. Today is ${today}. Respond entirely in ${language}.
 
+## OVERALL WORKFLOW GOAL:
+${task}
+
 CRITICAL: Do NOT invent, hallucinate, or add any data not present in the DATA sections below. ONLY use the exact data provided.
 Do NOT output JSON, tool calls, or code blocks. Write in plain text with markdown headers.
+Always apply your analysis specifically to the subject mentioned in the WORKFLOW GOAL.
 
 ${toolData ? `## DATA FROM TOOLS:\n${toolData.slice(0, 6000)}\n` : '## DATA: No data was retrieved by this agent.\n'}
 ${context ? `## OUTPUT FROM PREVIOUS AGENTS:\n${context.slice(0, 4000)}\n` : ''}
@@ -2837,10 +2845,12 @@ Your task: ${stepPrompt}`;
               : stepPrompt;
           } else {
             // All other agents (WriterAgent, DataAnalystAgent, specialist agents, etc.)
-            // Use a focused prompt with NO TOOL_DEFINITIONS to prevent JSON/tool-call output
             const hasRealData = !!(toolData || context);
             sysPrompt = `You are ${agent}, a specialist AI agent inside NHA Studio. Today is ${today}. You MUST respond entirely in ${language}.
 
+## OVERALL WORKFLOW GOAL:
+${task}
+
 CRITICAL RULES:
 - Do NOT output JSON, tool calls, function calls, or code blocks
 - NEVER invent, fabricate, or hallucinate data, events, emails, meetings, or news
@@ -2848,12 +2858,13 @@ CRITICAL RULES:
 - Do NOT add fictional examples, placeholder content, or generic suggestions not grounded in the data
 - Write in plain prose, structured with markdown headers (##) and bullet points (-)
 - Be thorough and specific — this is for an executive briefing based on REAL data only
+- Always keep the OVERALL WORKFLOW GOAL in mind — apply your analysis specifically to the subject mentioned
 
 ${toolData ? `## LIVE DATA FROM TOOLS:\n${toolData.slice(0, 6000)}\n` : '## LIVE DATA: No tool data was fetched for this step.\n'}
 ${context ? `## OUTPUT FROM PREVIOUS AGENTS:\n${context.slice(0, 6000)}\n` : ''}`;
             userMsg = hasRealData
-              ? `Based ONLY on the real data above, complete this task: ${stepPrompt}`
-              : `No real data is available. State clearly that no data was retrieved and explain what would be needed: ${stepPrompt}`;
+              ? `Based ONLY on the real data above, complete this task specifically for the subject in the WORKFLOW GOAL: ${stepPrompt}`
+              : `No real data is available for "${task}". State this clearly and explain what data would be needed to complete: ${stepPrompt}`;
           }
 
           // ── Stream LLM response ───────────────────────────────────────
@@ -2936,6 +2947,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.43';
+export const VERSION = '13.2.45';
 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 ──