nothumanallowed 13.2.95 → 13.2.97

package/package.json

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

@@ -3280,116 +3280,146 @@ ${context ? `## OUTPUT FROM PREVIOUS AGENTS (use only what is RELEVANT to the wo
           }
 
           // ── Stream LLM response ───────────────────────────────────────
+          // Specialist (non-canvas, non-live-data) agents use Structured Generation:
+          //   Phase 1 — Outline: one call that returns ONLY section headings as a numbered list
+          //   Phase 2 — Section fill: one call per section, with full context of sections already written
+          // Live-data + Canvas agents use the classic single-stream approach.
           let fullOutput = '';
-          let inThinkBlock = false;
-          let thinkBuf = '';
-          sendToken(isCanvasAgent ? 'Generating visual report...' : '');
-          const llmTimeout = isCanvasAgent ? 180000 : 120000;
-          // Canvas: no thinking (needs full tokens for HTML). Specialists: cap thinking to 2048 to leave room for answer.
-          const stepLlmOpts = isCanvasAgent
-            ? { max_tokens: 12288, thinking: 'off' }
-            : { max_tokens: 8192, thinking_budget: 2048 };
-          try {
+          let fullOutputClean = '';
+
+          // ── Helper: strip <think> tags from a string ─────────────────
+          const stripThink = (s) => s.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+
+          // ── Helper: stream a single LLM call, strip think tags, return full text ─
+          const streamCall = async (sysPr, usrMsg, opts, timeout, onToken) => {
+            let raw = '';
+            let inThink = false;
+            let tBuf = '';
             await withTimeout(
-              callLLMStream(config, sysPrompt, userMsg,
-                (token) => {
-                  fullOutput += token;
-                  if (!isCanvasAgent) {
-                    // Buffer and strip <think>...</think> blocks before sending to client
-                    thinkBuf += token;
-                    // Process thinkBuf: emit only content outside think tags
-                    let out = '';
-                    let buf = thinkBuf;
-                    while (buf.length > 0) {
-                      if (inThinkBlock) {
-                        const closeIdx = buf.indexOf('</think>');
-                        if (closeIdx >= 0) {
-                          buf = buf.slice(closeIdx + 8);
-                          inThinkBlock = false;
-                        } else {
-                          buf = '';
-                        }
-                      } else {
-                        const openIdx = buf.indexOf('<think>');
-                        if (openIdx >= 0) {
-                          out += buf.slice(0, openIdx);
-                          buf = buf.slice(openIdx + 7);
-                          inThinkBlock = true;
-                        } else {
-                          out += buf;
-                          buf = '';
-                        }
-                      }
+              callLLMStream(config, sysPr, usrMsg, (tok) => {
+                raw += tok;
+                if (onToken) {
+                  tBuf += tok;
+                  let out = '';
+                  let buf = tBuf;
+                  while (buf.length > 0) {
+                    if (inThink) {
+                      const ci = buf.indexOf('</think>');
+                      if (ci >= 0) { buf = buf.slice(ci + 8); inThink = false; }
+                      else { buf = ''; }
+                    } else {
+                      const oi = buf.indexOf('<think>');
+                      if (oi >= 0) { out += buf.slice(0, oi); buf = buf.slice(oi + 7); inThink = true; }
+                      else { out += buf; buf = ''; }
                     }
-                    thinkBuf = '';
-                    // Strip JSON tool calls from specialist agent output
-                    const stripped = out.replace(/\{[\s\S]*?"action"[\s\S]*?\}/g, '').trim();
-                    if (stripped) sendToken(stripped);
                   }
-                },
-                stepLlmOpts,
-              ),
-              llmTimeout
+                  tBuf = '';
+                  const stripped = out.replace(/\{[\s\S]*?"action"[\s\S]*?\}/g, '').trim();
+                  if (stripped) onToken(stripped);
+                }
+              }, opts),
+              timeout
             );
-          } catch (e) {
-            if (!isCanvasAgent) sendToken(`[Error: ${e.message}]`);
-          }
-
-          // Strip think tags from fullOutput before emptiness check
-          let fullOutputClean = fullOutput.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
-
-          // ── Fill empty sections ──────────────────────────────────────────
-          // Detect headings with no body: heading immediately followed by another heading or end
-          // e.g. "## 6. Piano d'Azione\n\n## 7. ..." — section 6 has no content
-          const emptySectionRegex = /^(#{1,4}\s+[^\n]+)\n+(?=#{1,4}\s|$)/gm;
-          const emptySections = [];
-          let emMatch;
-          while ((emMatch = emptySectionRegex.exec(fullOutputClean)) !== null) {
-            emptySections.push(emMatch[1].trim());
-          }
-
-          if (!isCanvasAgent && emptySections.length > 0) {
-            // Fill each empty section with a targeted LLM call
-            sendToken('\n\n[Completando sezioni mancanti...] ');
-            // Pass raw data AND the partial report already written so the model writes in context
-            const dataForFill = (toolData || context || '').slice(0, 4000);
-            const fillConfig = Object.assign({}, config, { thinking: 'off' });
-            for (const emptyHeading of emptySections) {
-              sendToken('\n' + emptyHeading + '\n');
-              let filledContent = '';
-              // Snapshot of the report written so far (trimmed to last 3000 chars for recency)
-              const reportSoFar = fullOutputClean.slice(-3000);
+            return stripThink(raw);
+          };
+
+          const useStructuredGen = !isCanvasAgent && !isLiveDataAgent;
+
+          if (isCanvasAgent) {
+            // ── Canvas: single stream, HTML output ────────────────────
+            sendToken('Generating visual report...');
+            try {
+              fullOutput = await streamCall(sysPrompt, userMsg, { max_tokens: 12288, thinking: 'off' }, 180000, null);
+            } catch (e) { /* canvas errors surfaced below */ }
+            fullOutputClean = fullOutput;
+
+          } else if (useStructuredGen) {
+            // ── Structured Generation ─────────────────────────────────
+            // Phase 1: ask for ONLY the section outline (headings list), fast and cheap
+            const structConfig = Object.assign({}, config, { thinking: 'off' });
+            const outlineSys = `You are ${agent}, a specialist AI agent. Today is ${today}. Respond in ${language}.
+Your task: plan the sections of a complete structured report for this goal: ${task}
+Instruction: ${stepPrompt}
+
+Output ONLY a numbered list of section headings — one per line, no body text, no explanation.
+Use ## prefix for each heading. Maximum 8 sections. Example:
+## 1. Executive Summary
+## 2. Key Findings
+## 3. Analysis`;
+            let outlineRaw = '';
+            try {
+              outlineRaw = await withTimeout(
+                new Promise((res) => {
+                  let acc = '';
+                  callLLMStream(structConfig, outlineSys, 'List the section headings only.', (tok) => { acc += tok; }, { max_tokens: 300, thinking: 'off' }).then(() => res(acc)).catch(() => res(acc));
+                }),
+                20000
+              );
+            } catch {}
+
+            // Parse headings: lines starting with ## (or plain numbered lines as fallback)
+            const headingLines = stripThink(outlineRaw)
+              .split('\n')
+              .map(l => l.trim())
+              .filter(l => l.match(/^#{1,4}\s+\S/) || l.match(/^\d+[\.\)]\s+\S/))
+              .map(l => l.match(/^#{1,4}\s+/) ? l : '## ' + l.replace(/^\d+[\.\)]\s+/, ''))
+              .slice(0, 8);
+
+            if (headingLines.length === 0) {
+              // Outline failed — fall back to single stream
+              sendToken('');
               try {
-                await withTimeout(
-                  callLLMStream(
-                    fillConfig,
-                    `You are ${agent}. You wrote a report and accidentally left one section empty. Fill in ONLY the missing section — do NOT repeat the heading, do NOT add other sections. Be specific, consistent with the rest of the report, and thorough. Write in ${language}.\n\nSource data:\n${dataForFill}\n\nOverall task: ${task}\n\nReport written so far (for context and style consistency):\n${reportSoFar}`,
-                    `Write ONLY the body content for this section (heading already printed, do not repeat it):\n${emptyHeading}`,
-                    (tok) => { filledContent += tok; sendToken(tok); },
-                    { max_tokens: 1500, thinking: 'off' }
-                  ),
-                  45000
-                );
-              } catch {}
-              if (filledContent.trim()) {
-                // Inject the filled content into fullOutputClean right after the heading
-                const escapedH = emptyHeading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-                fullOutputClean = fullOutputClean.replace(
-                  new RegExp('(' + escapedH + ')\\n+(#{1,4}\\s)', 'g'),
-                  '$1\n\n' + filledContent.trim() + '\n\n$2'
-                );
-                // Also handle trailing empty heading (last section)
-                fullOutputClean = fullOutputClean.replace(
-                  new RegExp('(' + escapedH + ')\\s*$', 'g'),
-                  '$1\n\n' + filledContent.trim()
-                );
+                fullOutput = await streamCall(sysPrompt, userMsg, { max_tokens: 8192, thinking_budget: 2048 }, 120000, sendToken);
+              } catch (e) { sendToken(`[Error: ${e.message}]`); }
+              fullOutputClean = stripThink(fullOutput);
+            } else {
+              // Phase 2: one call per section, each sees the sections already written
+              const dataBlock = [
+                attachmentText ? `## ATTACHED FILE:\n${attachmentText}` : '',
+                toolData ? `## LIVE DATA:\n${toolData}` : '',
+                context ? `## PREVIOUS AGENTS OUTPUT:\n${context}` : '',
+              ].filter(Boolean).join('\n\n');
+              const sectionParts = [];
+              for (let si = 0; si < headingLines.length; si++) {
+                const heading = headingLines[si];
+                const writtenSoFar = sectionParts.join('\n\n');
+                const secSys = `You are ${agent}, a specialist AI agent inside NHA Studio. Today is ${today}. Respond entirely in ${language}.
+
+## OVERALL WORKFLOW GOAL:
+${task}
+
+CRITICAL RULES:
+- Write ONLY the body content for the section heading given — do NOT repeat the heading
+- Do NOT open new headings or sub-sections — write flowing prose + bullet points
+- Do NOT invent data — use ONLY what is in the DATA block below
+- Be thorough, specific, and complete — this is one section of an executive report
+
+${dataBlock}
+${writtenSoFar ? `## REPORT WRITTEN SO FAR (for consistency):\n${writtenSoFar.slice(-3000)}` : ''}`;
+                const secUser = `Write the complete body content for this section (do NOT repeat the heading):\n${heading}`;
+                sendToken('\n\n' + heading + '\n');
+                let secContent = '';
+                try {
+                  secContent = await streamCall(secSys, secUser, { max_tokens: 2000, thinking: 'off' }, 60000, sendToken);
+                } catch {}
+                if (secContent.trim()) {
+                  sectionParts.push(heading + '\n\n' + secContent.trim());
+                  fullOutput += '\n\n' + heading + '\n\n' + secContent.trim();
+                }
               }
+              fullOutputClean = fullOutput.trim();
             }
+
           } else {
-            // Remove empty sections if we can't fill them (fallback: no data available)
-            fullOutputClean = fullOutputClean.replace(/^(#{1,4}\s+[^\n]+)\n+(?=#{1,4}\s|$)/gm, '');
+            // ── Live-data agents: single stream ───────────────────────
+            sendToken('');
+            try {
+              fullOutput = await streamCall(sysPrompt, userMsg, { max_tokens: 8192, thinking_budget: 2048 }, 120000, sendToken);
+            } catch (e) { sendToken(`[Error: ${e.message}]`); }
+            fullOutputClean = stripThink(fullOutput);
           }
-          // Strip trailing lone headings at end of output (truly unfillable)
+
+          // Strip trailing lone headings at end of output (truly unfillable edge cases)
           fullOutputClean = fullOutputClean.replace(/(#{1,4}\s+[^\n]+)\s*$/g, '').trim();
 
           // Fallback: if LLM returned empty and we have tool data, send it directly

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.95';
+export const VERSION = '13.2.97';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/web-ui.mjs

@@ -677,11 +677,21 @@ function openCanvasPanel(){
   var cp = document.getElementById('canvasPanel');
   if (!cp) return;
   cp.classList.add('open');
-  // If no canvas data, show a tip in the frame area
-  if (!studioState.canvas) {
-    var cf = document.getElementById('canvasFrame');
-    if (cf) {
-      var tip = \x27<!DOCTYPE html><html><body style="background:#0a0a0a;color:#6b7280;font-family:monospace;display:flex;align-items:center;justify-content:center;height:100vh;text-align:center;padding:20px"><div><div style="font-size:32px;margin-bottom:16px">&#9632;</div><div style="font-size:13px;line-height:1.6">Nessun Canvas in questo workflow.<br>Aggiungi <strong style=\x22color:#4ade80\x22>html</strong>, <strong style=\x22color:#4ade80\x22>dashboard</strong> o <strong style=\x22color:#4ade80\x22>visual</strong> al prompt,<br>oppure usa un task con 2+ agenti specialisti.</div></div></body></html>\x27;
+  var cf = document.getElementById('canvasFrame');
+  if (studioState.canvas) {
+    // Re-inject canvas HTML — survives panel close/reopen
+    if (cf) cf.srcdoc = studioState.canvas;
+    var ct = document.getElementById('canvasTitle');
+    if (ct && ct.textContent === 'Canvas') ct.textContent = 'Studio Report';
+  } else {
+    // Check allCanvasData for current conversation
+    var d = getConvCanvasData();
+    if (d.canvases.length > 0) {
+      canvasMode = 'canvas';
+      canvasIdx = d.canvases.length - 1;
+      renderCanvasPanel();
+    } else if (cf) {
+      var tip = '<!DOCTYPE html><html><body style="background:#0a0a0a;color:#6b7280;font-family:monospace;display:flex;align-items:center;justify-content:center;height:100vh;text-align:center;padding:20px"><div><div style="font-size:32px;margin-bottom:16px">&#9632;</div><div style="font-size:13px;line-height:1.6">Nessun Canvas in questo workflow.<br>Aggiungi <strong style="color:#4ade80">html</strong>, <strong style="color:#4ade80">dashboard</strong> o <strong style="color:#4ade80">visual</strong> al prompt,<br>oppure usa un task con 2+ agenti specialisti.</div></div></body></html>';
       cf.srcdoc = tip;
     }
   }
@@ -3700,52 +3710,81 @@ function downloadStudioPDF() {
       '.section-title{color:#4f46e5!important}}</style>';
     var pdfHtml = html.replace('</head>', printCss + '</head>');
 
-    // Build hidden iframe at 800px (A4 equivalent at 96dpi)
+    // Inject light-mode overrides for PDF — dark backgrounds become unreadable on paper
+    var lightOverride = '<style>' +
+      'body{background:#ffffff!important;color:#1a1a2e!important;padding:28px!important;max-width:760px!important;margin:0 auto!important}' +
+      '.header{background:linear-gradient(135deg,#4f46e5 0%,#06b6d4 100%)!important;-webkit-print-color-adjust:exact!important;color-adjust:exact!important}' +
+      '.header h1,.header p,.meta span{color:#fff!important}' +
+      '.card,.section{background:#f4f6fb!important;border:1px solid #dde1ee!important}' +
+      '.card h3,.section h3,.section-title,.card-label{color:#4f46e5!important}' +
+      '.card p,.section p,ul li,ol li{color:#374151!important}' +
+      '.priority-item{background:#eef0f8!important}' +
+      '.priority-item h4{color:#1a1a2e!important}' +
+      '.priority-item p{color:#374151!important}' +
+      '.source-item{background:#eef0f8!important;border-left-color:#4f46e5!important}' +
+      '.source-item h4{color:#1a1a2e!important}' +
+      '.source-item p{color:#374151!important}' +
+      '.bar-track{background:#e0e4ef!important}' +
+      '.footer{color:#9ca3af!important}' +
+      'a{color:#4f46e5!important}' +
+      '.section,.card,.priority-item,.source-item,.bar-row{break-inside:avoid;page-break-inside:avoid}' +
+      'h1,h2,h3,h4{break-after:avoid;page-break-after:avoid}' +
+      '.header{break-after:avoid;page-break-after:avoid}' +
+      '</style>';
+    var pdfHtml2 = html.replace('</head>', lightOverride + '</head>');
+
+    // Build hidden iframe at 794px (A4 width at 96dpi = 210mm)
     var iframe = document.createElement('iframe');
-    iframe.style.cssText = 'position:fixed;left:-9999px;top:0;width:800px;height:1px;border:none;visibility:hidden';
+    iframe.style.cssText = 'position:fixed;left:-9999px;top:0;width:794px;height:1px;border:none;visibility:hidden';
     document.body.appendChild(iframe);
     var ifrDoc = iframe.contentDocument || iframe.contentWindow.document;
-    ifrDoc.open(); ifrDoc.write(pdfHtml); ifrDoc.close();
+    ifrDoc.open(); ifrDoc.write(pdfHtml2); ifrDoc.close();
     iframe.onload = function() {
-      var body = ifrDoc.body;
-      var totalH = Math.max(body.scrollHeight, body.offsetHeight, ifrDoc.documentElement.scrollHeight);
+      var ifrBody = ifrDoc.body;
+      var totalH = Math.max(ifrBody.scrollHeight, ifrBody.offsetHeight, ifrDoc.documentElement.scrollHeight);
       iframe.style.height = totalH + 'px';
-      // Render at 2.5x scale for crisp text
-      window.html2canvas(body, {
-        scale: 2.5, useCORS: true, allowTaint: true,
-        backgroundColor: '#0d0d14',
-        width: 800, windowWidth: 800,
-        scrollX: 0, scrollY: 0,
-        ignoreElements: function(el){ return el.tagName === 'SCRIPT'; }
+      // Scale: 3x on HiDPI screens, minimum 2.5x for sharp text at A4
+      var renderScale = Math.max(2.5, Math.min(3, window.devicePixelRatio * 1.5));
+      window.html2canvas(ifrBody, {
+        scale: renderScale,
+        useCORS: true,
+        allowTaint: true,
+        backgroundColor: '#ffffff',
+        width: 794,
+        windowWidth: 794,
+        scrollX: 0,
+        scrollY: 0,
+        logging: false,
+        imageTimeout: 15000,
+        ignoreElements: function(el){ return el.tagName === 'SCRIPT' || el.tagName === 'NOSCRIPT'; }
       }).then(function(canvas) {
-        var imgData = canvas.toDataURL('image/png'); // PNG for crisp text
         var pdf = new window.jspdf.jsPDF({orientation:'portrait', unit:'pt', format:'a4', compress:true});
-        var pageW = pdf.internal.pageSize.getWidth();   // 595pt
-        var pageH = pdf.internal.pageSize.getHeight();  // 842pt
-        var margin = 24; // pt
+        var pageW = pdf.internal.pageSize.getWidth();   // 595.28pt
+        var pageH = pdf.internal.pageSize.getHeight();  // 841.89pt
+        var margin = 28; // pt — ~10mm margins
         var usableW = pageW - margin * 2;
         var usableH = pageH - margin * 2;
-        // Scale image to fit page width
-        var imgW = usableW;
-        var imgH = (canvas.height * usableW) / canvas.width;
 
-        // Smart paging: find safe cut points every ~usableH
-        // Strategy: render slice by slice, each slice fits one page
-        var sliceH = Math.floor(canvas.height * (usableH / imgH)); // canvas px per page
+        // px per rendered page = canvas pixels that map to usableH in pt
+        var pxPerPt = canvas.width / usableW;
+        var sliceH = Math.floor(usableH * pxPerPt); // canvas px per A4 page
+
         var yCanvas = 0;
         var pageNum = 0;
         while (yCanvas < canvas.height) {
           if (pageNum > 0) pdf.addPage();
           var remaining = canvas.height - yCanvas;
           var thisSlice = Math.min(sliceH, remaining);
-          // Create a temporary canvas for this slice
           var sliceCanvas = document.createElement('canvas');
           sliceCanvas.width = canvas.width;
           sliceCanvas.height = thisSlice;
           var ctx = sliceCanvas.getContext('2d');
+          ctx.fillStyle = '#ffffff';
+          ctx.fillRect(0, 0, sliceCanvas.width, sliceCanvas.height);
           ctx.drawImage(canvas, 0, yCanvas, canvas.width, thisSlice, 0, 0, canvas.width, thisSlice);
           var sliceData = sliceCanvas.toDataURL('image/png');
-          var sliceImgH = (thisSlice * usableW) / canvas.width;
+          // Proportional height in pt: thisSlice / pxPerPt
+          var sliceImgH = thisSlice / pxPerPt;
           pdf.addImage(sliceData, 'PNG', margin, margin, usableW, sliceImgH, '', 'FAST');
           yCanvas += thisSlice;
           pageNum++;