@vascend/talos 0.1.0 → 0.1.1

package/dist/vascend/self-improve.js

@@ -219,27 +219,27 @@ export function visionToText(vision) {
 // System prompt del motore (notazione Danilov): confronta STATO vs VISION e
 // produce proposte di miglioramento. SOLO JSON in output.
 // ---------------------------------------------------------------------------
-const ENGINE_SYSTEM = `# Motore di auto-miglioramento — confronto STATO vs VISION
-INDICE
-1 = vision
-2 = stato
-3 = gap
-4 = proposta
-
-DEFINIZIONI
-@vision[finale]: lo stato IDEALE desiderato dall'utente (obiettivo finale, valore, funzionalita' attese, criteri di pronto)
-@stato[corrente]: cio' che e' stato effettivamente realizzato finora (operato, attivita, output)
-@gap[misura]: distanza stato->vision; alignment 0..100 (100=vision gia' realizzata, 0=lontanissimo)
-@proposta[regola]: ogni proposta AVVICINA lo stato alla Vision; concreta, azionabile, frase imperativa breve
-@proposta[campi]: category(feature|quality|ux|robustness|performance|alignment), priority(must|should|could), impact 0..100, effort(small|medium|large), visionRef(feature/criterio di riferimento se noto), rationale
-@priorita[criterio]: must=essenziale per la Vision, should=migliora molto, could=rifinitura
-@bilancia[no_rumore]: proponi SOLO miglioramenti reali verso la Vision; niente perfezionismo, niente proposte generiche
-
-RELAZIONI
-@R1: @vision[finale] -> @gap[misura]  [ misura quanto manca alla Vision ]
-@R2: @gap[misura] -> @proposta[regola]  [ ogni gap diventa una proposta azionabile ]
-@R3: @proposta[regola] -> @priorita[criterio]  [ ordina per impatto sulla Vision ]
-
+const ENGINE_SYSTEM = `# Motore di auto-miglioramento — confronto STATO vs VISION
+INDICE
+1 = vision
+2 = stato
+3 = gap
+4 = proposta
+
+DEFINIZIONI
+@vision[finale]: lo stato IDEALE desiderato dall'utente (obiettivo finale, valore, funzionalita' attese, criteri di pronto)
+@stato[corrente]: cio' che e' stato effettivamente realizzato finora (operato, attivita, output)
+@gap[misura]: distanza stato->vision; alignment 0..100 (100=vision gia' realizzata, 0=lontanissimo)
+@proposta[regola]: ogni proposta AVVICINA lo stato alla Vision; concreta, azionabile, frase imperativa breve
+@proposta[campi]: category(feature|quality|ux|robustness|performance|alignment), priority(must|should|could), impact 0..100, effort(small|medium|large), visionRef(feature/criterio di riferimento se noto), rationale
+@priorita[criterio]: must=essenziale per la Vision, should=migliora molto, could=rifinitura
+@bilancia[no_rumore]: proponi SOLO miglioramenti reali verso la Vision; niente perfezionismo, niente proposte generiche
+
+RELAZIONI
+@R1: @vision[finale] -> @gap[misura]  [ misura quanto manca alla Vision ]
+@R2: @gap[misura] -> @proposta[regola]  [ ogni gap diventa una proposta azionabile ]
+@R3: @proposta[regola] -> @priorita[criterio]  [ ordina per impatto sulla Vision ]
+
 OUTPUT: SOLO JSON {"alignment": 0-100, "proposals": [{"text","category","priority","impact","effort","visionRef","rationale"}]}. Niente prosa fuori dal JSON, niente markdown.`;
 // Normalizza un singolo oggetto grezzo in ImprovementProposal, o null se vuoto.
 export function normalizeProposal(raw) {
@@ -352,24 +352,24 @@ export function buildSelfImproveSteer(goal, report) {
         .map((p, i) => `(${i + 1}) [${p.priority}/${p.category}] ${p.text}${p.visionRef ? ` <${p.visionRef}>` : ""} (impatto ${p.impact})`)
         .join(" ; ");
     const mustCount = report.proposals.filter((p) => p.priority === "must").length;
-    return `[VASCEND_AUTO_MIGLIORAMENTO]
-INDICE
-1 = goal
-2 = vision
-3 = proposta
-4 = azione
-
-DEFINIZIONI
-@goal[reale]: "${g}"
-@vision[allineamento]: stato_corrente=${report.alignment}/100 verso la Vision finale (must residui=${mustCount})
-@proposta[miglioramenti]: ${rows || "nessuna proposta esplicita: rifinisci verso la Vision"}
-@azione[migliora]: NON ti fermi allo stato attuale; avvicina il lavoro alla VISION finale realizzando le proposte (must prima)
-
-RELAZIONI
-@R1: @vision[allineamento] -> @proposta[miglioramenti]  [ il gap verso la Vision diventa proposte ]
-@R2: @proposta[miglioramenti] -> @azione[migliora]  [ realizza prima le proposte must, poi should ]
-@R3: @azione[migliora] -> @goal[reale]  [ finche' lo stato non e' allineato alla Vision ]
-
+    return `[VASCEND_AUTO_MIGLIORAMENTO]
+INDICE
+1 = goal
+2 = vision
+3 = proposta
+4 = azione
+
+DEFINIZIONI
+@goal[reale]: "${g}"
+@vision[allineamento]: stato_corrente=${report.alignment}/100 verso la Vision finale (must residui=${mustCount})
+@proposta[miglioramenti]: ${rows || "nessuna proposta esplicita: rifinisci verso la Vision"}
+@azione[migliora]: NON ti fermi allo stato attuale; avvicina il lavoro alla VISION finale realizzando le proposte (must prima)
+
+RELAZIONI
+@R1: @vision[allineamento] -> @proposta[miglioramenti]  [ il gap verso la Vision diventa proposte ]
+@R2: @proposta[miglioramenti] -> @azione[migliora]  [ realizza prima le proposte must, poi should ]
+@R3: @azione[migliora] -> @goal[reale]  [ finche' lo stato non e' allineato alla Vision ]
+
 OUTPUT: realizza le proposte di miglioramento elencate (priorita' must prima) col lavoro reale e completa le attivita con vascend_mark. Punta ad allineare lo stato alla Vision: il motore rivaluta.`;
 }
 // Sintesi compatta del report (per log/TUI), in una riga.

package/dist/vascend/test-failure-memory.js

@@ -103,15 +103,15 @@ export function formatTestFailureRecord(room, event) {
         : event.type === "test.fixed"
             ? `risolto da: ${escapeValue(event.fixedBy ?? "(non indicato)")}`
             : `superato da un fallimento piu' recente o non piu' rilevante`;
-    const body = `INDICE
-${uniqTerms.map((t, i) => `${i + 1} = ${t}`).join("\n")}
-
-DEFINIZIONI
-${def.join("\n")}
-
-RELAZIONI
-${rel}
-
+    const body = `INDICE
+${uniqTerms.map((t, i) => `${i + 1} = ${t}`).join("\n")}
+
+DEFINIZIONI
+${def.join("\n")}
+
+RELAZIONI
+${rel}
+
 OUTPUT: ${where} ${action} (status=${event.status}); ${lesson}; richiamabile via recall.`;
     return {
         room,

package/dist/vascend/vision.js

@@ -353,23 +353,23 @@ export function buildVisionBlock(v) {
         .filter(Boolean)
         .join(" ");
     const comp = visionCompleteness(v);
-    return `[VASCEND_VISION]
-INDICE
-1 = obiettivo
-2 = valore
-3 = funzionalita
-4 = pronto-produzione
-
-DEFINIZIONI
-@obiettivo[finale]: "${q(v.goal)}"
-@valore[perche]: "${q(valLine || "(non specificato)")}"
-${featDefs.length ? featDefs.join("\n") : "@funzionalita[nessuna]: -"}
-${rpDefs.length ? rpDefs.join("\n") : "@pronto[nessun-criterio]: -"}
-
-RELAZIONI
-@R-goal: @obiettivo[finale] -> @valore[perche]  [ il lavoro esiste per realizzare questo valore ]
-@R-feat: funzionalita[CORE] -> @obiettivo[finale]  [ le core sono indispensabili all'obiettivo ]
-@R-rp: @pronto -> consegna  [ spedibile sse ogni CORE e' built e ogni criterio e' MET ]
-
+    return `[VASCEND_VISION]
+INDICE
+1 = obiettivo
+2 = valore
+3 = funzionalita
+4 = pronto-produzione
+
+DEFINIZIONI
+@obiettivo[finale]: "${q(v.goal)}"
+@valore[perche]: "${q(valLine || "(non specificato)")}"
+${featDefs.length ? featDefs.join("\n") : "@funzionalita[nessuna]: -"}
+${rpDefs.length ? rpDefs.join("\n") : "@pronto[nessun-criterio]: -"}
+
+RELAZIONI
+@R-goal: @obiettivo[finale] -> @valore[perche]  [ il lavoro esiste per realizzare questo valore ]
+@R-feat: funzionalita[CORE] -> @obiettivo[finale]  [ le core sono indispensabili all'obiettivo ]
+@R-rp: @pronto -> consegna  [ spedibile sse ogni CORE e' built e ogni criterio e' MET ]
+
 OUTPUT: questa e' la Vision condivisa del task; pronto-per-produzione=${comp.productionReady} (core ${comp.coreBuilt}/${comp.coreTotal}, readiness ${comp.readinessMet}/${comp.readinessTotal}).`;
 }

package/dist/vendor/computer-use/README.md

@@ -1,7 +1,7 @@
-# Backend Computer Use incorporato
-
-Snapshot dei moduli nativi del workspace Vascend Horizon (`vascend-terminal/src/main`), incorporato per rendere Talos CLI indipendente da Electron e dal repository esterno.
-
-I file JavaScript mantengono CommonJS e il codice upstream. Dipendenze: soltanto built-in Node e PowerShell/Windows UI Automation. Non aggiungere dipendenze runtime. Il consenso, la serializzazione, l'isolamento sessioni e la conversione immagini sono gestiti da `src/tools/computer-use.ts`. I tool RAC che richiedono l'host non vengono esposti.
-
-`node scripts/copy-computer-use.mjs` copia questi asset in `dist/vendor/computer-use` durante la build. Aggiornare lo snapshot in modo esplicito, rivedendo dipendenze e test; nessun caricamento dal repository fratello in produzione.
+# Backend Computer Use incorporato
+
+Snapshot dei moduli nativi del workspace Vascend Horizon (`vascend-terminal/src/main`), incorporato per rendere Talos CLI indipendente da Electron e dal repository esterno.
+
+I file JavaScript mantengono CommonJS e il codice upstream. Dipendenze: soltanto built-in Node e PowerShell/Windows UI Automation. Non aggiungere dipendenze runtime. Il consenso, la serializzazione, l'isolamento sessioni e la conversione immagini sono gestiti da `src/tools/computer-use.ts`. I tool RAC che richiedono l'host non vengono esposti.
+
+`node scripts/copy-computer-use.mjs` copia questi asset in `dist/vendor/computer-use` durante la build. Aggiornare lo snapshot in modo esplicito, rivedendo dipendenze e test; nessun caricamento dal repository fratello in produzione.

package/dist/vendor/computer-use/computer-desktop.js

@@ -1,211 +1,211 @@
-'use strict';
-
-// Inventario del desktop per Computer Use: applicazioni, processi e finestre.
-// Sta fuori dal modulo dei tool perche' e' una fonte dati con regole proprie
-// (fusione di due enumerazioni Win32, icone locali che non devono mai entrare
-// nel contesto del modello, fotografia breve riusata da processes e attach).
-
-const crypto = require('crypto');
-const { integer, cleanWindow, cleanProcess } = require('./computer-observe');
-
-const KNOWN_APPLICATIONS = Object.freeze({
-  claude: 'Claude Desktop', code: 'Visual Studio Code', chrome: 'Google Chrome',
-  msedge: 'Microsoft Edge', firefox: 'Firefox', slack: 'Slack', teams: 'Microsoft Teams',
-  notion: 'Notion', discord: 'Discord', spotify: 'Spotify', explorer: 'Esplora file',
-});
-
-function applicationName(process, windows) {
-  const normalized = String(process || '').trim().toLocaleLowerCase();
-  if (KNOWN_APPLICATIONS[normalized]) return KNOWN_APPLICATIONS[normalized];
-  const titled = (Array.isArray(windows) ? windows : []).find((row) => row.visible && row.title)
-    || (Array.isArray(windows) ? windows : []).find((row) => row.title);
-  if (titled && titled.title) return titled.title.slice(0, 120);
-  const raw = String(process || 'Applicazione').replace(/[-_]+/g, ' ').trim();
-  return raw ? raw.charAt(0).toLocaleUpperCase() + raw.slice(1) : 'Applicazione';
-}
-
-function safeIconDataUrl(value) {
-  const icon = String(value || '');
-  return icon.length <= 32768 && /^data:image\/png;base64,[a-z0-9+/=]+$/i.test(icon) ? icon : '';
-}
-
-// Il percorso dell'eseguibile serve solo all'host per estrarre l'icona: non
-// lascia mai questo processo.
-function publicProcess(value) {
-  const { _executablePath, ...safe } = value && typeof value === 'object' ? value : {};
-  return safe;
-}
-
-function publicApplication(value) {
-  const { icon, _iconProcess, ...safe } = value && typeof value === 'object' ? value : {};
-  return safe;
-}
-
-function uiApplication(value) {
-  const { _iconProcess, ...safe } = value && typeof value === 'object' ? value : {};
-  return safe;
-}
-
-function publicTarget(value) {
-  const { icon, _iconProcess, ...safe } = value && typeof value === 'object' ? value : {};
-  return Object.keys(safe).length ? safe : null;
-}
-
-function mergeProcessWindows(windows, processes) {
-  const byId = new Map((Array.isArray(windows) ? windows : []).map((row) => [row.windowId, row]));
-  for (const process of Array.isArray(processes) ? processes : []) {
-    if (!process.windowId || !process.bounds || byId.has(process.windowId)) continue;
-    const row = cleanWindow({
-      windowId: process.windowId,
-      processId: process.processId,
-      process: process.process,
-      title: process.title || process.process,
-      bounds: process.bounds,
-      visible: process.visible,
-      minimized: process.minimized,
-    });
-    if (row) byId.set(row.windowId, row);
-  }
-  return [...byId.values()].sort((a, b) => Number(b.visible) - Number(a.visible)
-    || Number(a.minimized) - Number(b.minimized)
-    || a.process.localeCompare(b.process) || a.title.localeCompare(b.title)).slice(0, 240);
-}
-
-function createDesktopInventory({ listWindows, listProcesses, resolveProcessIcon, cacheMs = 2500 } = {}) {
-  let cache = null;
-  const iconCache = new Map();
-
-  const windowsNow = async () => {
-    let rows = [];
-    try { rows = await listWindows(); } catch (_) { rows = []; }
-    return (Array.isArray(rows) ? rows : []).map(cleanWindow).filter(Boolean).slice(0, 240);
-  };
-
-  const processesNow = async (windows) => {
-    let rows = [];
-    try { rows = listProcesses ? await listProcesses() : windows; } catch (_) { rows = []; }
-    const byId = new Map();
-    for (const raw of Array.isArray(rows) ? rows : []) {
-      const row = cleanProcess(raw);
-      if (row) byId.set(row.processId, row);
-    }
-    // EnumWindows e' piu autorevole sul collegamento tra HWND e PID: fonde le
-    // due fonti e promuove in cima le applicazioni realmente collegabili.
-    for (const win of Array.isArray(windows) ? windows : []) {
-      const previous = byId.get(win.processId);
-      byId.set(win.processId, {
-        processId: win.processId,
-        process: win.process || previous && previous.process || 'processo',
-        title: win.title || previous && previous.title || '',
-        windowId: win.windowId,
-        hasWindow: true,
-        bounds: win.bounds,
-        visible: win.visible,
-        minimized: win.minimized,
-        responding: previous ? previous.responding : true,
-        _executablePath: previous ? previous._executablePath : '',
-      });
-    }
-    return [...byId.values()].sort((a, b) => Number(b.hasWindow) - Number(a.hasWindow)
-      || Number(b.visible) - Number(a.visible)
-      || a.process.localeCompare(b.process) || a.processId - b.processId).slice(0, 512);
-  };
-
-  const applicationsNow = async (processes, windows) => {
-    const groups = new Map();
-    for (const process of Array.isArray(processes) ? processes : []) {
-      const key = String(process.process || '').trim().toLocaleLowerCase();
-      if (!key) continue;
-      if (!groups.has(key)) groups.set(key, { process: process.process, processes: [], windows: [] });
-      groups.get(key).processes.push(process);
-    }
-    for (const win of Array.isArray(windows) ? windows : []) {
-      const key = String(win.process || '').trim().toLocaleLowerCase();
-      if (!key) continue;
-      if (!groups.has(key)) groups.set(key, { process: win.process, processes: [], windows: [] });
-      groups.get(key).windows.push(win);
-    }
-    const applications = [...groups.entries()].map(([key, group]) => {
-      const processIds = [...new Set(group.processes.map((row) => row.processId)
-        .concat(group.windows.map((row) => row.processId)).filter(Boolean))];
-      const windowIds = [...new Set(group.windows.map((row) => row.windowId).filter(Boolean))];
-      const titles = [...new Set(group.windows.map((row) => row.title).filter(Boolean))].slice(0, 8);
-      return {
-        applicationId: 'app-' + crypto.createHash('sha256').update(key).digest('hex').slice(0, 10),
-        name: applicationName(group.process, group.windows),
-        process: group.process,
-        processIds,
-        instanceCount: processIds.length,
-        windowIds,
-        windowCount: windowIds.length,
-        titles,
-        controllable: windowIds.length > 0,
-        visible: group.windows.some((row) => row.visible),
-        minimized: group.windows.some((row) => row.minimized),
-        _iconProcess: group.processes.find((row) => row.hasWindow) || group.processes[0] || null,
-      };
-    }).sort((a, b) => Number(b.controllable) - Number(a.controllable)
-      || Number(b.visible) - Number(a.visible)
-      || a.name.localeCompare(b.name)).slice(0, 240);
-    return applications;
-  };
-
-  // Estrarre l'icona di ogni processo richiede accesso al relativo eseguibile e
-  // rendeva computer_processes lento anche quando l'utente cercava una sola app.
-  // Risolviamo soltanto le applicazioni effettivamente mostrate/collegate e
-  // riutilizziamo il risultato per tutto il run.
-  const hydrateApplicationIcons = async (rows) => {
-    if (!resolveProcessIcon) return rows;
-    await Promise.all((Array.isArray(rows) ? rows : []).map(async (application) => {
-      if (!application || application.icon || !application._iconProcess) return;
-      const process = application._iconProcess;
-      const key = String(process._executablePath || process.process || process.processId || '').toLocaleLowerCase();
-      if (key && iconCache.has(key)) {
-        application.icon = iconCache.get(key);
-        return;
-      }
-      let icon = '';
-      try { icon = safeIconDataUrl(await resolveProcessIcon(process)); } catch (_) { icon = ''; }
-      application.icon = icon;
-      if (key) iconCache.set(key, icon);
-    }));
-    return rows;
-  };
-
-  // computer_processes e computer_attach sono normalmente consecutivi. Una
-  // seconda enumerazione Win32/PowerShell immediata aggiungeva vari secondi
-  // senza aumentare la precisione; riusiamo solo una fotografia molto breve.
-  const targetsNow = async (progress) => {
-    if (cache && Date.now() - cache.capturedAt < integer(cacheMs, 0, 60000, 2500)) {
-      if (typeof progress === 'function') progress({ phase: 'windows', windows: cache.value.windows });
-      return cache.value;
-    }
-    const enumerated = await windowsNow();
-    if (typeof progress === 'function') progress({ phase: 'windows', windows: enumerated });
-    const processes = await processesNow(enumerated);
-    const windows = mergeProcessWindows(enumerated, processes);
-    const applications = await applicationsNow(processes, windows);
-    const value = { applications, processes: processes.map(publicProcess), windows };
-    cache = { capturedAt: Date.now(), value };
-    return value;
-  };
-
-  return {
-    windowsNow,
-    targetsNow,
-    hydrateApplicationIcons,
-    invalidate: () => { cache = null; },
-  };
-}
-
-module.exports = {
-  KNOWN_APPLICATIONS,
-  applicationName,
-  safeIconDataUrl,
-  publicProcess,
-  publicApplication,
-  uiApplication,
-  publicTarget,
-  mergeProcessWindows,
-  createDesktopInventory,
-};
+'use strict';
+
+// Inventario del desktop per Computer Use: applicazioni, processi e finestre.
+// Sta fuori dal modulo dei tool perche' e' una fonte dati con regole proprie
+// (fusione di due enumerazioni Win32, icone locali che non devono mai entrare
+// nel contesto del modello, fotografia breve riusata da processes e attach).
+
+const crypto = require('crypto');
+const { integer, cleanWindow, cleanProcess } = require('./computer-observe');
+
+const KNOWN_APPLICATIONS = Object.freeze({
+  claude: 'Claude Desktop', code: 'Visual Studio Code', chrome: 'Google Chrome',
+  msedge: 'Microsoft Edge', firefox: 'Firefox', slack: 'Slack', teams: 'Microsoft Teams',
+  notion: 'Notion', discord: 'Discord', spotify: 'Spotify', explorer: 'Esplora file',
+});
+
+function applicationName(process, windows) {
+  const normalized = String(process || '').trim().toLocaleLowerCase();
+  if (KNOWN_APPLICATIONS[normalized]) return KNOWN_APPLICATIONS[normalized];
+  const titled = (Array.isArray(windows) ? windows : []).find((row) => row.visible && row.title)
+    || (Array.isArray(windows) ? windows : []).find((row) => row.title);
+  if (titled && titled.title) return titled.title.slice(0, 120);
+  const raw = String(process || 'Applicazione').replace(/[-_]+/g, ' ').trim();
+  return raw ? raw.charAt(0).toLocaleUpperCase() + raw.slice(1) : 'Applicazione';
+}
+
+function safeIconDataUrl(value) {
+  const icon = String(value || '');
+  return icon.length <= 32768 && /^data:image\/png;base64,[a-z0-9+/=]+$/i.test(icon) ? icon : '';
+}
+
+// Il percorso dell'eseguibile serve solo all'host per estrarre l'icona: non
+// lascia mai questo processo.
+function publicProcess(value) {
+  const { _executablePath, ...safe } = value && typeof value === 'object' ? value : {};
+  return safe;
+}
+
+function publicApplication(value) {
+  const { icon, _iconProcess, ...safe } = value && typeof value === 'object' ? value : {};
+  return safe;
+}
+
+function uiApplication(value) {
+  const { _iconProcess, ...safe } = value && typeof value === 'object' ? value : {};
+  return safe;
+}
+
+function publicTarget(value) {
+  const { icon, _iconProcess, ...safe } = value && typeof value === 'object' ? value : {};
+  return Object.keys(safe).length ? safe : null;
+}
+
+function mergeProcessWindows(windows, processes) {
+  const byId = new Map((Array.isArray(windows) ? windows : []).map((row) => [row.windowId, row]));
+  for (const process of Array.isArray(processes) ? processes : []) {
+    if (!process.windowId || !process.bounds || byId.has(process.windowId)) continue;
+    const row = cleanWindow({
+      windowId: process.windowId,
+      processId: process.processId,
+      process: process.process,
+      title: process.title || process.process,
+      bounds: process.bounds,
+      visible: process.visible,
+      minimized: process.minimized,
+    });
+    if (row) byId.set(row.windowId, row);
+  }
+  return [...byId.values()].sort((a, b) => Number(b.visible) - Number(a.visible)
+    || Number(a.minimized) - Number(b.minimized)
+    || a.process.localeCompare(b.process) || a.title.localeCompare(b.title)).slice(0, 240);
+}
+
+function createDesktopInventory({ listWindows, listProcesses, resolveProcessIcon, cacheMs = 2500 } = {}) {
+  let cache = null;
+  const iconCache = new Map();
+
+  const windowsNow = async () => {
+    let rows = [];
+    try { rows = await listWindows(); } catch (_) { rows = []; }
+    return (Array.isArray(rows) ? rows : []).map(cleanWindow).filter(Boolean).slice(0, 240);
+  };
+
+  const processesNow = async (windows) => {
+    let rows = [];
+    try { rows = listProcesses ? await listProcesses() : windows; } catch (_) { rows = []; }
+    const byId = new Map();
+    for (const raw of Array.isArray(rows) ? rows : []) {
+      const row = cleanProcess(raw);
+      if (row) byId.set(row.processId, row);
+    }
+    // EnumWindows e' piu autorevole sul collegamento tra HWND e PID: fonde le
+    // due fonti e promuove in cima le applicazioni realmente collegabili.
+    for (const win of Array.isArray(windows) ? windows : []) {
+      const previous = byId.get(win.processId);
+      byId.set(win.processId, {
+        processId: win.processId,
+        process: win.process || previous && previous.process || 'processo',
+        title: win.title || previous && previous.title || '',
+        windowId: win.windowId,
+        hasWindow: true,
+        bounds: win.bounds,
+        visible: win.visible,
+        minimized: win.minimized,
+        responding: previous ? previous.responding : true,
+        _executablePath: previous ? previous._executablePath : '',
+      });
+    }
+    return [...byId.values()].sort((a, b) => Number(b.hasWindow) - Number(a.hasWindow)
+      || Number(b.visible) - Number(a.visible)
+      || a.process.localeCompare(b.process) || a.processId - b.processId).slice(0, 512);
+  };
+
+  const applicationsNow = async (processes, windows) => {
+    const groups = new Map();
+    for (const process of Array.isArray(processes) ? processes : []) {
+      const key = String(process.process || '').trim().toLocaleLowerCase();
+      if (!key) continue;
+      if (!groups.has(key)) groups.set(key, { process: process.process, processes: [], windows: [] });
+      groups.get(key).processes.push(process);
+    }
+    for (const win of Array.isArray(windows) ? windows : []) {
+      const key = String(win.process || '').trim().toLocaleLowerCase();
+      if (!key) continue;
+      if (!groups.has(key)) groups.set(key, { process: win.process, processes: [], windows: [] });
+      groups.get(key).windows.push(win);
+    }
+    const applications = [...groups.entries()].map(([key, group]) => {
+      const processIds = [...new Set(group.processes.map((row) => row.processId)
+        .concat(group.windows.map((row) => row.processId)).filter(Boolean))];
+      const windowIds = [...new Set(group.windows.map((row) => row.windowId).filter(Boolean))];
+      const titles = [...new Set(group.windows.map((row) => row.title).filter(Boolean))].slice(0, 8);
+      return {
+        applicationId: 'app-' + crypto.createHash('sha256').update(key).digest('hex').slice(0, 10),
+        name: applicationName(group.process, group.windows),
+        process: group.process,
+        processIds,
+        instanceCount: processIds.length,
+        windowIds,
+        windowCount: windowIds.length,
+        titles,
+        controllable: windowIds.length > 0,
+        visible: group.windows.some((row) => row.visible),
+        minimized: group.windows.some((row) => row.minimized),
+        _iconProcess: group.processes.find((row) => row.hasWindow) || group.processes[0] || null,
+      };
+    }).sort((a, b) => Number(b.controllable) - Number(a.controllable)
+      || Number(b.visible) - Number(a.visible)
+      || a.name.localeCompare(b.name)).slice(0, 240);
+    return applications;
+  };
+
+  // Estrarre l'icona di ogni processo richiede accesso al relativo eseguibile e
+  // rendeva computer_processes lento anche quando l'utente cercava una sola app.
+  // Risolviamo soltanto le applicazioni effettivamente mostrate/collegate e
+  // riutilizziamo il risultato per tutto il run.
+  const hydrateApplicationIcons = async (rows) => {
+    if (!resolveProcessIcon) return rows;
+    await Promise.all((Array.isArray(rows) ? rows : []).map(async (application) => {
+      if (!application || application.icon || !application._iconProcess) return;
+      const process = application._iconProcess;
+      const key = String(process._executablePath || process.process || process.processId || '').toLocaleLowerCase();
+      if (key && iconCache.has(key)) {
+        application.icon = iconCache.get(key);
+        return;
+      }
+      let icon = '';
+      try { icon = safeIconDataUrl(await resolveProcessIcon(process)); } catch (_) { icon = ''; }
+      application.icon = icon;
+      if (key) iconCache.set(key, icon);
+    }));
+    return rows;
+  };
+
+  // computer_processes e computer_attach sono normalmente consecutivi. Una
+  // seconda enumerazione Win32/PowerShell immediata aggiungeva vari secondi
+  // senza aumentare la precisione; riusiamo solo una fotografia molto breve.
+  const targetsNow = async (progress) => {
+    if (cache && Date.now() - cache.capturedAt < integer(cacheMs, 0, 60000, 2500)) {
+      if (typeof progress === 'function') progress({ phase: 'windows', windows: cache.value.windows });
+      return cache.value;
+    }
+    const enumerated = await windowsNow();
+    if (typeof progress === 'function') progress({ phase: 'windows', windows: enumerated });
+    const processes = await processesNow(enumerated);
+    const windows = mergeProcessWindows(enumerated, processes);
+    const applications = await applicationsNow(processes, windows);
+    const value = { applications, processes: processes.map(publicProcess), windows };
+    cache = { capturedAt: Date.now(), value };
+    return value;
+  };
+
+  return {
+    windowsNow,
+    targetsNow,
+    hydrateApplicationIcons,
+    invalidate: () => { cache = null; },
+  };
+}
+
+module.exports = {
+  KNOWN_APPLICATIONS,
+  applicationName,
+  safeIconDataUrl,
+  publicProcess,
+  publicApplication,
+  uiApplication,
+  publicTarget,
+  mergeProcessWindows,
+  createDesktopInventory,
+};