@vascend/talos 0.1.0

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

@@ -0,0 +1,2136 @@
+'use strict';
+
+// Computer Use locale per Horizon: qui vivono le DEFINIZIONI degli strumenti e
+// la politica (consenso, validazione, verifica). Il layer nativo — PowerShell,
+// user32, UI Automation — sta in computer-scripts.js, l'osservazione pura in
+// computer-observe.js, l'inventario del desktop in computer-desktop.js.
+//
+// Tre principi, imparati dagli usi reali:
+//  1. Si agisce sui CONTROLLI, non sui pixel. Un click stimato da un'immagine
+//     sbaglia bersaglio appena la finestra si sposta; Invoke/SetValue di UI
+//     Automation colpiscono l'elemento e lo portano anche in vista.
+//  2. Si osserva per INTENTO. Il tree di una app reale ha centinaia di nodi:
+//     l'agente chiede cosa cerca e riceve righe compatte, non inventari.
+//  3. Ogni azione RIPORTA il proprio esito. Chiudere con "verifica tu" costava
+//     due chiamate per ogni passo: adesso l'azione porta con se' il delta.
+
+const crypto = require('crypto');
+const Native = require('./computer-scripts');
+const Observe = require('./computer-observe');
+const Desktop = require('./computer-desktop');
+const { EXTENSION_ID, SERVER_CAPABILITIES } = require('./rac/protocol.js');
+const { normalizeAtomicOperations } = require('./rac/atomic-input.js');
+const { creaParser: creaRacPreviewParser } = require('./rac/parser.js');
+const { LIMITI: RAC_LIMITI } = require('./rac/grammatica.js');
+
+const { MAX_TEXT, PASTE_THRESHOLD, keyCodes, keyChords } = Native;
+const { integer, cleanBounds, cleanElement, compactElement, selectorFor, pointerFor,
+  filterElements, similarity, diffElements, describeChanges, searchedTargets,
+  startMenuMatches, ok, warn, fail } = Observe;
+const { applicationName, publicProcess, publicApplication, uiApplication, publicTarget } = Desktop;
+
+const MAX_WAIT_MS = 10000;
+const MAX_CONDITION_WAIT_MS = 20000;
+const MAX_LAUNCH_WAIT_MS = 20000;
+const MAX_BATCH_STEPS = 12;
+const MAX_BATCH_DELAY_MS = 20000;
+// Ispezione e azione successiva avvengono a meno di un secondo di distanza e
+// camminavano il tree due volte. Ogni mutazione invalida la cache.
+const TREE_CACHE_MS = 1200;
+
+function computerUseTools(options = {}) {
+  const captureDesktop = options.captureDesktop;
+  const desktopInfo = typeof options.desktopInfo === 'function' ? options.desktopInfo : Native.defaultDesktopInfo;
+  const performAction = typeof options.performAction === 'function' ? options.performAction : Native.defaultAction;
+  const listWindows = typeof options.listWindows === 'function' ? options.listWindows : Native.defaultWindows;
+  // Se l'integrazione fornisce le proprie fonti (test, adapter), non apriamo
+  // canali nativi a sua insaputa: i processi si ricavano dalle finestre e i
+  // percorsi UI Automation / avvio applicazioni restano disattivati, con
+  // degradazione sui percorsi a coordinate.
+  const adapted = typeof options.listWindows === 'function';
+  const listProcesses = typeof options.listProcesses === 'function'
+    ? options.listProcesses
+    : (adapted ? null : Native.defaultProcesses);
+  const inspectUI = typeof options.inspectUI === 'function' ? options.inspectUI : Native.defaultUiElements;
+  const uiAction = typeof options.uiAction === 'function'
+    ? options.uiAction
+    : (typeof options.inspectUI === 'function' ? null : Native.defaultUiAction);
+  const launchApp = typeof options.launchApp === 'function'
+    ? options.launchApp
+    : (adapted ? null : Native.defaultLaunch);
+  const openPath = typeof options.openPath === 'function'
+    ? options.openPath
+    : (adapted ? null : Native.defaultOpenPath);
+  const listInstalledApps = typeof options.listInstalledApps === 'function'
+    ? options.listInstalledApps
+    : (adapted ? null : Native.defaultStartMenuApps);
+  const onStateEvent = typeof options.onStateEvent === 'function' ? options.onStateEvent : () => {};
+  const reactiveHost = options.reactiveHost && typeof options.reactiveHost.open === 'function'
+    ? options.reactiveHost : null;
+  const reactiveToolStream = options.reactiveToolStream
+    && typeof options.reactiveToolStream.execute === 'function'
+    ? options.reactiveToolStream : null;
+  const reactiveFastLane = options.reactiveFastLane
+    && typeof options.reactiveFastLane.setGoal === 'function'
+    ? options.reactiveFastLane : null;
+  const externalControllerEnabled = options.externalControllerEnabled === true && !!reactiveFastLane;
+  const racStrictMode = options.racStrictMode === true;
+  const allowLegacyRac = !racStrictMode || options.allowLegacyRac === true;
+  const consentMode = options.consentMode === 'always' || options.consentMode === 'once'
+    ? options.consentMode : '';
+  // Pipeline visual-token (iniettata dal main): inversione dei frame per il
+  // modello, mappa adattiva dei patch, pacchetto temporale. Nei test resta
+  // assente e ogni percorso degrada al comportamento classico.
+  const visualFrame = options.visualFrame
+    && typeof options.visualFrame.pngPerModello === 'function' ? options.visualFrame : null;
+  if (typeof captureDesktop !== 'function') return [];
+
+  const desktop = Desktop.createDesktopInventory({
+    listWindows,
+    listProcesses,
+    resolveProcessIcon: typeof options.resolveProcessIcon === 'function' ? options.resolveProcessIcon : null,
+  });
+
+  const resumedTarget = reactiveHost && typeof reactiveHost.getTargetDescriptor === 'function'
+    ? reactiveHost.getTargetDescriptor() : null;
+  let runtimeAuthorized = !!consentMode;
+  let lastSnapshot = null;
+  // Affinita di sessione: il controller RAC puo sopravvivere a un turno e
+  // conserva quale finestra era collegata. Il nuovo run rilegge comunque la
+  // finestra prima di catturare/agire e non eredita snapshot o target UIA.
+  let attachedTarget = resumedTarget && /^\d+$/.test(String(resumedTarget.windowId || '')) ? {
+    windowId: String(resumedTarget.windowId),
+    title: String(resumedTarget.windowTitle || resumedTarget.title || ''),
+    bounds: resumedTarget.windowBounds || resumedTarget.bounds || { x: 0, y: 0, width: 0, height: 0 },
+    processId: Number(resumedTarget.processId) || 0,
+    process: String(resumedTarget.process || ''),
+    applicationId: String(resumedTarget.applicationId || ''),
+    applicationName: String(resumedTarget.applicationName || resumedTarget.process || resumedTarget.windowTitle || ''),
+    visible: true,
+    minimized: false,
+  } : null;
+  let targetCache = new Map();
+  let treeCache = null;
+  // Il controller puo restare caldo tra due turni. Non riutilizziamo mai il
+  // vecchio frame, ma continuiamo la sua sequenza per evitare che un nuovo
+  // checkpoint venga rifiutato come replay se i due turni si sovrappongono.
+  const resumedObservation = reactiveHost && typeof reactiveHost.getObservation === 'function'
+    ? reactiveHost.getObservation() : null;
+  const resumedObservationSequence = Number(resumedObservation && resumedObservation.observationId);
+  let observationSequence = Number.isSafeInteger(resumedObservationSequence)
+    && resumedObservationSequence >= 0 ? resumedObservationSequence : 0;
+  let currentObservation = null;
+  let lastObservationError = null;
+  let atomicFailure = { code: '', count: 0 };
+
+  const approve = async (ctx, detail) => {
+    if (!ctx || typeof ctx.confirm !== 'function') return false;
+    return !!(await ctx.confirm('computer_use', detail));
+  };
+
+  const authorized = async (ctx, detail) => {
+    // L'avviso visibile del composer e' il gate primario. Manteniamo il vecchio
+    // confirm come fallback per integrazioni che invocano i tool senza grant.
+    if (runtimeAuthorized) return true;
+    runtimeAuthorized = await approve(ctx, detail);
+    return runtimeAuthorized;
+  };
+
+  const stateEvent = (event) => { try { onStateEvent(event); } catch (_) { /* indicatore best-effort */ } };
+  const inputPreview = (operations) => {
+    const preview = { sequence: [] };
+    for (const operation of Array.isArray(operations) ? operations : []) {
+      if (operation.type === 'shortcut') {
+        preview.keyboard = { ...(preview.keyboard || {}), keys: operation.keys.slice(0, 4) };
+        preview.sequence.push({ type: 'shortcut', keys: operation.keys.slice(0, 4) });
+      } else if (operation.type === 'text') {
+        preview.keyboard = { ...(preview.keyboard || {}), characterCount: operation.text.length };
+        preview.sequence.push({ type: 'text', characterCount: operation.text.length });
+      } else if (operation.type === 'mouse') {
+        preview.mouse = { dx: operation.dx, dy: operation.dy, scroll: operation.scroll };
+        preview.sequence.push({ type: 'mouse', dx: operation.dx, dy: operation.dy, scroll: operation.scroll });
+      } else if (operation.type === 'click') {
+        preview.mouse = { ...(preview.mouse || {}), button: operation.button };
+        preview.sequence.push({ type: 'click', button: operation.button });
+      }
+    }
+    return preview;
+  };
+  const racCommandPreview = (command) => {
+    const parser = creaRacPreviewParser();
+    const events = [...parser.push(String(command || '')), ...parser.fine()];
+    const mouseByObservation = new Map();
+    const sequence = [];
+    for (const event of events) {
+      if (!event || event.tipo !== 'chunk' || !event.chunk) continue;
+      const chunk = event.chunk;
+      if (chunk.tipo === 'mouse') {
+        mouseByObservation.set(String(chunk.observationId), {
+          dx: chunk.dx, dy: chunk.dy, scroll: chunk.scroll,
+        });
+        continue;
+      }
+      if (chunk.tipo !== 'keyset') continue;
+      const mouse = mouseByObservation.get(String(chunk.observationId)) || {};
+      sequence.push({
+        type: 'frame',
+        frame: Number(chunk.indice) + 1,
+        durationMs: RAC_LIMITI.CHUNK_MS,
+        keys: Array.isArray(chunk.tasti) ? chunk.tasti.slice(0, 4) : [],
+        mouse: {
+          dx: Math.trunc((Number(mouse.dx) || 0) / RAC_LIMITI.CHUNK_PER_AZIONE),
+          dy: Math.trunc((Number(mouse.dy) || 0) / RAC_LIMITI.CHUNK_PER_AZIONE),
+          scroll: Math.trunc((Number(mouse.scroll) || 0) / RAC_LIMITI.CHUNK_PER_AZIONE),
+        },
+      });
+    }
+    const current = sequence[0] || {};
+    return {
+      sequence,
+      ...(current.keys && current.keys.length ? { keyboard: { keys: current.keys } } : {}),
+      ...(current.mouse ? { mouse: current.mouse } : {}),
+      concurrent: true,
+      frameDurationMs: RAC_LIMITI.CHUNK_MS,
+    };
+  };
+  const invalidateVisualState = (reason = 'computer_state_changed', notifyHost = true) => {
+    lastSnapshot = null;
+    treeCache = null;
+    currentObservation = null;
+    if (notifyHost && reactiveHost && typeof reactiveHost.invalidateObservation === 'function') {
+      void reactiveHost.invalidateObservation(reason);
+    }
+  };
+  const denied = (what) => fail('NOT_AUTHORIZED', `${what} non autorizzato.`,
+    ['Chiedi all utente di attivare Computer Use dal composer, poi riprova.']);
+
+  const checkpointObservation = async (input = {}) => {
+    if (!reactiveHost || typeof reactiveHost.checkpoint !== 'function' || !attachedTarget) {
+      lastObservationError = { code: 'RAC_HOST_UNAVAILABLE' };
+      return null;
+    }
+    const observationId = reactiveHost && typeof reactiveHost.allocateObservationId === 'function'
+      ? String(reactiveHost.allocateObservationId()) : String(++observationSequence);
+    const allocated = Number(observationId);
+    if (Number.isSafeInteger(allocated)) observationSequence = Math.max(observationSequence, allocated);
+    const observation = {
+      observationId,
+      windowId: String(attachedTarget.windowId || ''),
+      capturedAt: Number(input.capturedAt) || Date.now(),
+      monotonicAt: Number(input.monotonicAt) || Number(process.hrtime.bigint()) / 1e6,
+      checksum: String(input.checksum || ''),
+      width: Number(input.width) || 0,
+      height: Number(input.height) || 0,
+      bounds: input.bounds && typeof input.bounds === 'object' ? input.bounds : attachedTarget.bounds,
+      affine: input.affine && typeof input.affine === 'object' ? input.affine : null,
+      source: String(input.source || 'computer_use'),
+    };
+    let result = await reactiveHost.checkpoint(observation);
+    // Compatibilita con host gia caldi o aggiornati durante lo sviluppo: un
+    // safety stop/lease scaduta non deve trasformare tutte le osservazioni
+    // successive in null. Riarmiamo il target e riproviamo lo stesso keyframe.
+    if (result && ['SAFETY_STOP', 'SESSION_CLOSED', 'SESSION_EXPIRED'].includes(String(result.code || ''))
+      && typeof reactiveHost.rearmTarget === 'function') {
+      const rearmed = await reactiveHost.rearmTarget('checkpoint_retry');
+      if (rearmed && rearmed.ok === true) result = await reactiveHost.checkpoint(observation);
+    }
+    if (!result || result.ok !== true) {
+      lastObservationError = {
+        code: String(result && result.code || 'OBSERVATION_CHECKPOINT_FAILED'),
+        error: String(result && result.error || ''),
+      };
+      return null;
+    }
+    lastObservationError = null;
+    currentObservation = result.observation || observation;
+    return currentObservation;
+  };
+
+  const visualObservation = async (shot, source) => {
+    if (!shot || !shot.data) return null;
+    const checksum = crypto.createHash('sha256')
+      .update(Buffer.from(String(shot.data), 'base64')).digest('hex');
+    return checkpointObservation({
+      capturedAt: Date.now(), monotonicAt: Number(process.hrtime.bigint()) / 1e6, checksum,
+      width: shot.width, height: shot.height, bounds: shot.bounds,
+      affine: shot.affine, source,
+    });
+  };
+
+  // Dopo una traiettoria RAC il frame successivo deve entrare nello stesso
+  // risultato del tool. In precedenza currentObservation veniva azzerata e il
+  // planner era costretto a un computer_inspect separato: quello trasformava il
+  // loop reattivo in un giro LLM -> tool da diversi secondi.
+  const capturePostActionObservation = async () => {
+    if (!attachedTarget) return null;
+    const alive = await refreshAttached();
+    if (!alive || !attachedTarget) return null;
+    const shot = await captureDesktop({
+      windowId: attachedTarget.windowId,
+      windowTitle: attachedTarget.title,
+      windowBounds: attachedTarget.bounds,
+    });
+    if (!shot || !shot.data) return null;
+    const bounds = shot.bounds && typeof shot.bounds === 'object'
+      ? shot.bounds : attachedTarget.bounds;
+    lastSnapshot = {
+      id: 'snap-' + crypto.randomUUID(), capturedAt: Date.now(),
+      width: Number(shot.width) || 1, height: Number(shot.height) || 1, bounds,
+    };
+    const observation = await visualObservation({ ...shot, bounds }, 'computer_control_post_action');
+    if (observation) lastSnapshot.observationId = observation.observationId;
+    stateEvent({ type: 'snapshot', attached: attachedTarget, bounds, reactive: true });
+    return observation ? { shot, bounds, observation } : null;
+  };
+
+  const semanticObservation = async (rows, source = 'computer_inspect') => {
+    const checksum = crypto.createHash('sha256')
+      .update(JSON.stringify((Array.isArray(rows) ? rows : []).map(compactElement))).digest('hex');
+    return checkpointObservation({
+      capturedAt: Date.now(), monotonicAt: Number(process.hrtime.bigint()) / 1e6, checksum,
+      width: attachedTarget && attachedTarget.bounds && attachedTarget.bounds.width,
+      height: attachedTarget && attachedTarget.bounds && attachedTarget.bounds.height,
+      bounds: attachedTarget && attachedTarget.bounds, source,
+    });
+  };
+
+  // La lettura del tree ha DUE esiti diversi che non vanno confusi: una
+  // finestra senza controlli e una lettura non riuscita. Trattarli allo stesso
+  // modo rendeva Computer Use cieco — su Spotify un carattere di controllo nei
+  // nomi rompeva il JSON e il tool rispondeva "nessun controllo", spingendo il
+  // modello a tirare a indovinare sulle coordinate.
+  const readTree = async ({ force = false, includeText = false } = {}) => {
+    const scope = (attachedTarget && attachedTarget.windowId || '') + (includeText ? '+text' : '');
+    if (!force && treeCache && treeCache.scope === scope && Date.now() - treeCache.at < TREE_CACHE_MS) {
+      return treeCache.rows;
+    }
+    let response = null;
+    try { response = await inspectUI({ ...(attachedTarget || {}), includeText }); } catch (error) {
+      response = { ok: false, code: 'NATIVE_ERROR', error: String(error && error.message || error) };
+    }
+    // Gli adapter storici (e i test) ritornano un array puro: resta valido.
+    const rows = Array.isArray(response) ? response
+      : (response && Array.isArray(response.rows) ? response.rows : []);
+    const failure = !Array.isArray(response) && response && response.ok === false
+      ? { code: String(response.code || 'NATIVE_ERROR'), error: String(response.error || 'Lettura dei controlli non riuscita.') }
+      : null;
+    const cleaned = rows
+      .map((row, index) => cleanElement(row, index, attachedTarget && attachedTarget.windowId || ''))
+      .filter(Boolean).slice(0, 320);
+    treeCache = { rows: cleaned, at: Date.now(), scope, failure };
+    if (targetCache.size > 1200) targetCache = new Map();
+    for (const row of cleaned) targetCache.set(row.targetId, row);
+    return cleaned;
+  };
+
+  const lastReadFailure = () => treeCache && treeCache.failure ? treeCache.failure : null;
+
+  // Una sola scansione UIA valida tutti i target di una sequenza: prima ogni
+  // passaggio rilanciava PowerShell, moltiplicando la latenza proprio quando il
+  // modello aveva correttamente programmato un batch.
+  const resolveTargets = async (targetIds) => {
+    const ids = [...new Set((Array.isArray(targetIds) ? targetIds : [targetIds])
+      .map((value) => String(value || '')).filter((value) => targetCache.has(value)))];
+    const resolved = new Map();
+    if (!ids.length) return resolved;
+    // La cache descrive il momento dell inspect, non necessariamente quello
+    // dell azione. Una lettura fresca impedisce che un popup o un rerender
+    // facciano sopravvivere un target ormai rimosso.
+    const current = await readTree({ force: true });
+    for (const id of ids) {
+      const expected = targetCache.get(id);
+      let best = null; let bestScore = -1;
+      for (const row of current) {
+        const score = similarity(expected, row);
+        if (score > bestScore) { best = row; bestScore = score; }
+      }
+      // Un controllo che non esiste piu' non deve essere riutilizzato soltanto
+      // perche' era presente nella scansione precedente. Popup, navigazioni e
+      // rerender cambiano spesso il tree fra due passaggi: consegnare il target
+      // vecchio faceva finire tastiera e mouse sul controllo sbagliato.
+      if (bestScore >= 5) resolved.set(id, best);
+    }
+    return resolved;
+  };
+
+  const resolveTarget = async (targetId) => (await resolveTargets([targetId])).get(String(targetId || '')) || null;
+
+  const verification = async (baseline, verify, freshTree = false) => {
+    if (verify === 'none' || !baseline || !attachedTarget) {
+      return { verified: false, verificationRequired: true };
+    }
+    // Chi ha gia' riletto il tree DOPO l'azione (la verifica del testo scritto)
+    // non paga una seconda camminata.
+    const after = freshTree && treeCache ? treeCache.rows : await readTree({ force: true });
+    const failure = lastReadFailure();
+    if (failure) {
+      return {
+        verified: false,
+        verificationRequired: true,
+        verificationError: failure.error,
+      };
+    }
+    const delta = diffElements(baseline, after);
+    const changed = delta.changeCount > 0;
+    return {
+      // Un delta vuoto prova soltanto che il tree e' rimasto uguale. Non prova
+      // che il click, Invio o la navigazione abbiano raggiunto l'obiettivo.
+      verified: changed,
+      verificationRequired: !changed,
+      changeCount: delta.changeCount,
+      ...(delta.changes.length ? { changes: delta.changes } : {}),
+      observation: describeChanges(delta),
+    };
+  };
+
+  const wantsVerification = (input) => {
+    const requested = String(input && input.verify || '').toLowerCase();
+    if (requested === 'none') return 'none';
+    if (requested === 'delta') return 'delta';
+    return attachedTarget && treeCache && treeCache.rows.length ? 'delta' : 'none';
+  };
+
+  const baselineFor = (verify) => verify === 'delta' && treeCache ? treeCache.rows : null;
+
+  const actionOutcome = async (name, result, { pointer, baseline, verify, extra = {}, freshTree = false } = {}) => {
+    stateEvent({
+      type: 'action', phase: result && result.ok === true ? 'complete' : 'error', action: name,
+      ...(pointer ? { pointer } : {}), attached: attachedTarget,
+    });
+    if (!result || result.ok !== true) {
+      invalidateVisualState();
+      return fail(String(result && result.code || 'ACTION_FAILED'),
+        String(result && result.error || 'Azione non riuscita.'),
+        ['computer_inspect per rileggere i controlli, poi riprova con il target aggiornato'],
+        { action: name, ...extra });
+    }
+    const checked = await verification(baseline, verify, freshTree);
+    lastSnapshot = null;
+    currentObservation = null;
+    if (reactiveHost && typeof reactiveHost.invalidateObservation === 'function') {
+      await reactiveHost.invalidateObservation('computer_action_completed');
+    }
+    const verifiedObservation = treeCache && Array.isArray(treeCache.rows)
+      ? await semanticObservation(treeCache.rows, 'computer_action_verification') : null;
+    const summary = checked.verified
+      ? `${name}: ${checked.observation}.`
+      : verify === 'delta'
+        ? `${name} eseguito, ma il risultato non e stato confermato.`
+        : `${name} eseguito.`;
+    const envelope = checked.verified || verify === 'none' ? ok : warn;
+    return envelope(summary,
+      {
+        action: name,
+        ...extra,
+        ...checked,
+        observationId: verifiedObservation && verifiedObservation.observationId || null,
+        note: checked.verified
+          ? 'Esito verificato rileggendo i controlli: nessuno screenshot necessario.'
+          : 'Il comando e stato inviato, ma non c e evidenza che l obiettivo sia stato raggiunto. Verifica lo stato prima di proseguire.',
+      },
+      checked.verified ? [] : ['computer_inspect per confermare lo stato']);
+  };
+
+  const nativeRequest = (element, request) => ({
+    windowId: attachedTarget && attachedTarget.windowId || '',
+    selector: selectorFor(element),
+    ...request,
+  });
+
+  const nativeBlocked = (native) => !!native
+    && (native.code === 'TARGET_GONE' || native.code === 'PASSWORD' || native.code === 'DISABLED');
+
+  // Percorso nativo con ripiego a coordinate, condiviso da azioni singole e
+  // batch: prima il pattern UI Automation, poi il click sui bounds appena
+  // riletti dal tree vivo (piu' precisi di quelli in cache).
+  const nativeOrPointer = async (element, pointer, request, fallback) => {
+    const native = await uiAction(nativeRequest(element, request));
+    if (native && native.ok === true) return { ok: true, method: String(native.method || request.action) };
+    if (nativeBlocked(native)) return native;
+    const fresh = cleanBounds(native && native.bounds);
+    const spot = fresh ? pointerFor({ bounds: fresh }) : pointer;
+    if (!spot) return native && native.error ? native : { ok: false, error: 'Azione non riuscita.' };
+    const result = await fallback(spot);
+    return result && result.ok === true ? { ...result, method: 'Pointer' } : result;
+  };
+
+  // Il testo e' arrivato nel campo? true/false quando il controllo espone un
+  // valore leggibile, null quando non c'e' nulla da confrontare (in quel caso
+  // resta valida la verifica per delta). Confronto tollerante: le app spesso
+  // normalizzano spazi o completano da sole.
+  const textLanded = async (element, text) => {
+    const expected = String(text || '').trim().toLocaleLowerCase();
+    if (!expected) return null;
+    // Lettura FRESCA: subito dopo l'input la cache del tree e' vecchia di
+    // millisecondi ma descrive lo stato precedente.
+    const rows = await readTree({ force: true });
+    let best = null; let bestScore = -1;
+    for (const row of rows) {
+      const score = similarity(element, row);
+      if (score > bestScore) { best = row; bestScore = score; }
+    }
+    const current = bestScore >= 5 ? best : null;
+    if (!current) return null;
+    const before = String(element && element.value || '').trim().toLocaleLowerCase();
+    const value = String(current.value || '').trim().toLocaleLowerCase();
+    if (!value && !before) return null;
+    if (value.includes(expected)) return true;
+    // Il caso che ingannava: il vecchio valore ("montagem") e' contenuto nel
+    // testo nuovo ("montagem rugada"). Campo invariato = testo non arrivato.
+    if (value === before) return false;
+    // Il campo e' cambiato ma non contiene tutto: lo accettiamo solo se e' un
+    // prefisso credibile di quello che volevamo (app che troncano o normalizzano).
+    return value.length >= 3 && expected.startsWith(value);
+  };
+
+  // Su un campo di testo "invoke" finiva su ExpandCollapse, cioe' apriva e al
+  // colpo dopo CHIUDEVA il pannello di ricerca portandosi via il cursore. Su un
+  // campo si clicca, come farebbe una persona: e' l'unico gesto che sposta il
+  // fuoco anche nel DOM delle app Chromium. Un mode esplicito vince sempre.
+  const TEXT_ENTRY_TYPES = Object.freeze(['Edit', 'ComboBox', 'SearchBox', 'Document']);
+
+  const activateMode = (element, requested) => {
+    const mode = String(requested || 'invoke').toLowerCase();
+    if (mode !== 'invoke') return mode;
+    const textField = TEXT_ENTRY_TYPES.includes(String(element && element.type || ''))
+      || (Array.isArray(element && element.actions) && element.actions.includes('setValue'));
+    return textField ? 'click' : 'invoke';
+  };
+
+  const clickAt = (spot, input = {}) => performAction('click', {
+    x: spot.x, y: spot.y, windowId: attachedTarget && attachedTarget.windowId,
+    button: String(input.button || 'left'), clicks: integer(input.clicks, 1, 3, 1),
+  });
+
+  const fillAt = (spot, { text, clear, submit }) => performAction('fill', {
+    x: spot.x, y: spot.y, windowId: attachedTarget && attachedTarget.windowId,
+    text, ...(clear ? { clear: true } : {}), submit: submit === true,
+  });
+
+  const refreshAttached = async () => {
+    if (!attachedTarget) return true;
+    const current = (await desktop.windowsNow()).find((row) => row.windowId === attachedTarget.windowId);
+    if (!current) {
+      attachedTarget = null; targetCache = new Map(); invalidateVisualState();
+      if (reactiveHost && typeof reactiveHost.clearTarget === 'function') reactiveHost.clearTarget();
+      return false;
+    }
+    attachedTarget = {
+      ...current,
+      applicationId: attachedTarget.applicationId || '',
+      applicationName: attachedTarget.applicationName || '',
+      icon: attachedTarget.icon || '',
+    };
+    return true;
+  };
+
+  const attachWindow = async (match, applications) => {
+    const application = (Array.isArray(applications) ? applications : [])
+      .find((row) => row.process.toLocaleLowerCase() === match.process.toLocaleLowerCase());
+    if (application) await desktop.hydrateApplicationIcons([application]);
+    attachedTarget = {
+      ...match,
+      applicationId: application && application.applicationId || '',
+      applicationName: application && application.name || applicationName(match.process, [match]),
+      icon: application && application.icon || '',
+    };
+    targetCache = new Map();
+    // armTarget e' il reset autorevole. Evitiamo una invalidate fire-and-
+    // forget che poteva arrivare dopo arm/checkpoint e cancellare il frame
+    // appena creato.
+    invalidateVisualState('target_rearming', false);
+    // Un target nel tray o minimizzato deve diventare realmente catturabile
+    // prima dello snapshot; l'attach e' gia' coperto dal consenso esplicito.
+    const focus = await performAction('focusWindow', { windowId: match.windowId });
+    if (focus && focus.ok === false) {
+      attachedTarget = null;
+      if (reactiveHost && typeof reactiveHost.clearTarget === 'function') reactiveHost.clearTarget();
+      return fail('FOREGROUND_LOST', String(focus.error || 'Non riesco a ripristinare la finestra selezionata.'),
+        ['Chiedi all utente di portare la finestra in primo piano, poi richiama computer_attach']);
+    }
+    // Una finestra minimizzata viene enumerata con bounds fittizi (-25600) e
+    // minimized: true. Restituire quella fotografia DOPO averla ripristinata
+    // faceva credere al modello che l'attach non avesse funzionato e lo
+    // costringeva a un secondo attach identico. Si rilegge SOLO quando c'era
+    // davvero qualcosa da ripristinare: una finestra gia' visibile non paga
+    // una seconda enumerazione.
+    if (match.minimized === true || match.bounds.x <= -20000) {
+      for (const delay of [80, 260]) {
+        desktop.invalidate();
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        if (!(await refreshAttached())) {
+          return fail('WINDOW_CLOSED', 'La finestra e stata chiusa durante il collegamento.',
+            ['computer_processes per scegliere un nuovo target']);
+        }
+        if (!attachedTarget.minimized && attachedTarget.bounds.x > -20000) break;
+      }
+    }
+    if (reactiveHost) {
+      if (typeof reactiveHost.armTarget === 'function') {
+        const armed = await reactiveHost.armTarget({
+          windowId: attachedTarget.windowId,
+          windowTitle: attachedTarget.title,
+          windowBounds: attachedTarget.bounds,
+        });
+        if (armed && armed.ok === false) {
+          lastObservationError = {
+            code: String(armed.code || 'RAC_ARM_FAILED'),
+            error: String(armed.error || ''),
+          };
+        }
+      } else if (typeof reactiveHost.setTarget === 'function') {
+        reactiveHost.setTarget(attachedTarget.windowId);
+      }
+    }
+    let observation = null;
+    try {
+      const shot = await captureDesktop({
+        windowId: attachedTarget.windowId,
+        windowTitle: attachedTarget.title,
+        windowBounds: attachedTarget.bounds,
+        racObservation: true,
+      });
+      observation = await visualObservation(shot, 'computer_attach');
+    } catch (_) { /* l'attach semantico resta valido, RAC richiedera uno snapshot */ }
+    stateEvent({ type: 'attach', attached: attachedTarget });
+    if (externalControllerEnabled && typeof reactiveFastLane.arm === 'function') {
+      try { await reactiveFastLane.arm(); } catch (_) { /* stato esposto da computer_reactive_status */ }
+    }
+    const attachNext = externalControllerEnabled
+      ? ['computer_reactive_goal con il risultato finale richiesto']
+      : ['computer_control con observationId e grammatica ACTION; continua con il nextObservationId restituito'];
+    return ok(`Collegato a ${attachedTarget.applicationName || attachedTarget.title || attachedTarget.process}.`,
+      {
+        attached: publicTarget(attachedTarget),
+        observationId: observation && observation.observationId || null,
+        ...(!observation && lastObservationError ? { racObservationError: lastObservationError } : {}),
+        note: externalControllerEnabled
+          ? 'Finestra collegata al controller visuale esterno opzionale.'
+          : 'Finestra collegata. Il modello corrente e il controller RAC: usa computer_control e il nextObservationId restituito.',
+      },
+      attachNext);
+  };
+
+  // Coordinate valide solo se ancorate allo screenshot corrente: il modello
+  // ragiona sui pixel dell'immagine ricevuta, non sul monitor reale.
+  const snapshotPointer = (input) => {
+    if (!lastSnapshot) {
+      return { error: fail('NO_SNAPSHOT', 'Serve un computer_snapshot aggiornato prima di usare coordinate.',
+        ['computer_inspect per agire senza coordinate', 'computer_snapshot con include_image true se serve vedere']) };
+    }
+    if (input && input.snapshot_id && input.snapshot_id !== lastSnapshot.id) {
+      return { error: fail('STALE_SNAPSHOT', 'Lo screenshot indicato non e piu quello corrente.',
+        ['computer_snapshot per acquisirne uno nuovo']) };
+    }
+    if (Date.now() - lastSnapshot.capturedAt > 90000) {
+      invalidateVisualState();
+      return { error: fail('STALE_SNAPSHOT', 'Lo screenshot e troppo vecchio.',
+        ['computer_snapshot per acquisirne uno nuovo prima di agire']) };
+    }
+    const sourceX = Number(input && input.x); const sourceY = Number(input && input.y);
+    if (!Number.isFinite(sourceX) || !Number.isFinite(sourceY)) {
+      return { error: fail('BAD_INPUT', 'Coordinate non valide.', ['Passa x e y in pixel dello screenshot corrente']) };
+    }
+    if (sourceX < 0 || sourceY < 0 || sourceX > lastSnapshot.width || sourceY > lastSnapshot.height) {
+      return { error: fail('OUT_OF_BOUNDS', 'Le coordinate sono fuori dallo screenshot corrente.',
+        ['Rileggi lo screenshot e usa coordinate al suo interno']) };
+    }
+    // Se la cattura e' ridimensionata, convertiamo alle coordinate reali.
+    return {
+      pointer: {
+        x: Math.round(lastSnapshot.bounds.x + (sourceX * lastSnapshot.bounds.width / lastSnapshot.width)),
+        y: Math.round(lastSnapshot.bounds.y + (sourceY * lastSnapshot.bounds.height / lastSnapshot.height)),
+      },
+    };
+  };
+
+  const missingTarget = (hint) => fail('TARGET_UNKNOWN',
+    'Questo target_id non appartiene a una lettura corrente.',
+    [hint || 'computer_inspect per rileggere i controlli e ottenere target_id validi']);
+
+  const rearmReactiveTarget = async (reason = 'rac_recovery') => {
+    currentObservation = null;
+    lastObservationError = null;
+    if (!reactiveHost || typeof reactiveHost.rearmTarget !== 'function') return null;
+    const rearmed = await reactiveHost.rearmTarget(reason);
+    if (!rearmed || rearmed.ok !== true) {
+      lastObservationError = {
+        code: String(rearmed && rearmed.code || 'RAC_REARM_FAILED'),
+        error: String(rearmed && rearmed.error || ''),
+      };
+      return null;
+    }
+    return capturePostActionObservation().catch(() => null);
+  };
+
+  // MCP-RAC CLI: il modello emette direttamente la grammatica ACTION. Il
+  // valore della stringa viene letto dai delta JSON del provider e ogni
+  // segmento delimitato da `;` puo essere committato prima che la tool call sia
+  // terminata. Non esiste un percorso steps implicito quando il protocollo e'
+  // obbligatorio: un errore di grammatica deve essere visibile e correggibile.
+  const executeRacCommand = async (command, ctx, toolName = 'computer_control') => {
+    const stream = String(command || '');
+    if (!stream) {
+      return JSON.stringify(fail('RAC_COMMAND_REQUIRED', 'Serve un comando MCP-RAC ACTION completo.',
+        ['Usa l observationId corrente e la grammatica indicata da computer_control']));
+    }
+    if (!reactiveToolStream) {
+      return JSON.stringify(fail('RAC_UNAVAILABLE', 'Il canale MCP-RAC non e disponibile in questo run.',
+        ['Riavvia Horizon e riprova nella modalita Work o Code']));
+    }
+    if (!attachedTarget || !/^\d+$/.test(String(attachedTarget.windowId || ''))) {
+      await reactiveToolStream.discard('no_attached_window');
+      return JSON.stringify(fail('NO_ATTACHED_WINDOW', 'MCP-RAC richiede una finestra collegata.',
+        ['computer_processes e computer_attach, poi computer_control']));
+    }
+    if (!currentObservation || !/^\d+$/.test(String(currentObservation.observationId || ''))) {
+      await reactiveToolStream.discard('observation_required');
+      return JSON.stringify(fail('OBSERVATION_REQUIRED', 'MCP-RAC richiede una osservazione autorevole corrente.',
+        racStrictMode
+          ? ['computer_control_reset per ottenere un observationId fresco, poi computer_control']
+          : ['computer_snapshot oppure computer_inspect, poi computer_control']));
+    }
+    const allowed = await authorized(ctx, 'Esegui il comando MCP-RAC nella finestra collegata');
+    if (!allowed) {
+      await reactiveToolStream.discard('consent_denied');
+      return JSON.stringify(denied('Controllo MCP-RAC'));
+    }
+    const presentedInput = racCommandPreview(stream);
+    stateEvent({ type: 'action', phase: 'start', action: toolName, attached: attachedTarget,
+      input: presentedInput });
+    // Ring a 5 Hz durante l'azione: i frame catturati mentre l'ACTION esegue
+    // diventano UN Temporal Visual Packet (frame finale + timeline + zone
+    // cambiate) allegato al risultato: una sola osservazione temporale del
+    // movimento invece di piu' chiamate visive. I frame RAC arrivano gia'
+    // invertiti e normalizzati 1280x720 dal main.
+    const motionFrames = [];
+    let motionTimer = null;
+    if (visualFrame && typeof visualFrame.pacchettoDaPngList === 'function' && attachedTarget) {
+      const catturaMovimento = async () => {
+        if (motionFrames.length >= 10 || !attachedTarget) return;
+        try {
+          const frame = await captureDesktop({
+            windowId: attachedTarget.windowId,
+            windowTitle: attachedTarget.title,
+            windowBounds: attachedTarget.bounds,
+            racObservation: true,
+          });
+          if (frame && frame.data) motionFrames.push(String(frame.data));
+        } catch (_) { /* un frame perso non ferma l'azione */ }
+      };
+      void catturaMovimento();
+      motionTimer = setInterval(catturaMovimento, 200);
+      try { motionTimer.unref(); } catch (_) { /* timer di processo */ }
+    }
+    const fermaMovimento = () => {
+      if (motionTimer) clearInterval(motionTimer);
+      motionTimer = null;
+    };
+    try {
+      const result = await reactiveToolStream.execute(stream, {
+        signal: ctx && ctx.signal,
+        tool: toolName,
+      });
+      if (!result || result.ok !== true) {
+        fermaMovimento();
+        const recovered = await rearmReactiveTarget('rac_action_failed');
+        stateEvent({ type: 'action', phase: 'error', action: toolName, attached: attachedTarget,
+          input: presentedInput });
+        return JSON.stringify(fail('RAC_STOPPED', `MCP-RAC arrestato: ${String(result && result.error || 'errore sconosciuto')}.`,
+          recovered
+            ? ['Continua con computer_control usando observationId']
+            : (racStrictMode
+              ? ['computer_control_reset per riarmare RAC']
+              : ['computer_control_reset per riarmare RAC',
+                'computer_inspect e computer_batch come fallback UI Automation']),
+          { rearmed: !!recovered, observationId: recovered && recovered.observation.observationId || null }));
+      }
+      // La ACTION conclusa non autorizza una seconda traiettoria cieca. Cattura
+      // subito il frame successivo e lo restituisce nella medesima tool result,
+      // evitando il giro screenshot/inspect osservato nelle sessioni reali.
+      currentObservation = null;
+      const nextFrame = await capturePostActionObservation().catch(() => null);
+      fermaMovimento();
+      if (!nextFrame) currentObservation = null;
+      // Il movimento in UNA immagine: se il ring ha almeno due frame, il media
+      // per il modello diventa il Temporal Visual Packet (frame finale +
+      // timeline + zone cambiate); la UI (_meta) resta il frame reale pulito.
+      const motionPacket = motionFrames.length >= 2 && visualFrame
+        && typeof visualFrame.pacchettoDaPngList === 'function'
+        ? visualFrame.pacchettoDaPngList(motionFrames, { intervalloMs: 200 })
+        : null;
+      stateEvent({ type: 'action', phase: 'complete', action: toolName, attached: attachedTarget,
+        input: presentedInput });
+      const structuredContent = ok('Comando MCP-RAC completato; input rilasciati.', {
+        action: toolName,
+        mode: 'reactive',
+        transport: result.transport,
+        actionObservationId: result.observationId || null,
+        observationId: nextFrame && nextFrame.observation.observationId || null,
+        nextObservationId: nextFrame && nextFrame.observation.observationId || null,
+        firstDispatchAt: result.firstDispatchAt || null,
+        telemetry: result.telemetry || null,
+        capabilities: result.capabilities || null,
+        ...(motionPacket ? {
+          temporal_packet: motionPacket.metadati,
+          temporal_packet_note: motionPacket.nota,
+          ...(visualFrame.attiva() ? { inverted: true } : {}),
+        } : {}),
+      }, nextFrame
+        ? ['Continua direttamente con computer_control usando nextObservationId; non chiamare inspect o snapshot.']
+        : ['La cattura automatica non e riuscita: usa computer_snapshot o computer_inspect prima della prossima ACTION.']);
+      if (toolName !== 'computer_control') return JSON.stringify(structuredContent);
+      return {
+        output: JSON.stringify(structuredContent),
+        structuredContent,
+        ...(nextFrame ? {
+          _meta: { 'vascend/computer-use': { image: {
+            type: 'image', mimeType: 'image/png', data: String(nextFrame.shot.data),
+          } } },
+        } : {}),
+        ...(motionPacket
+          ? { media: [{ mime: 'image/png', data: String(motionPacket.data), source: 'computer-temporal-packet' }] }
+          : (nextFrame
+            ? { media: [{ mime: 'image/png', data: String(nextFrame.shot.data), source: 'computer-control-next-frame' }] }
+            : {})),
+      };
+    } catch (error) {
+      fermaMovimento();
+      await reactiveToolStream.interrupt(String(error && error.message || 'reactive_error'));
+      const recovered = await rearmReactiveTarget('rac_exception');
+      stateEvent({ type: 'action', phase: 'error', action: toolName, attached: attachedTarget,
+        input: presentedInput });
+      return JSON.stringify(fail('RAC_STOPPED', `MCP-RAC arrestato: ${String(error && error.message || error)}.`,
+        recovered
+          ? ['Continua con computer_control usando observationId']
+          : (racStrictMode
+            ? ['computer_control_reset per riarmare RAC']
+            : ['computer_control_reset per riarmare RAC', 'computer_batch come fallback UI Automation']),
+        { rearmed: !!recovered, observationId: recovered && recovered.observation.observationId || null }));
+    }
+  };
+
+  // Per tastiera e mouse non chiediamo al modello di compilare manualmente una
+  // frase in keyset da 33 ms. Le operazioni restano nel medesimo host RAC,
+  // vincolate a finestra e observationId, ma Ctrl+A + testo diventa una sola
+  // chiamata deterministica invece di una catena di tentativi e screenshot.
+  const executeRacAtomicInput = async (operations, ctx) => {
+    const normalized = normalizeAtomicOperations(operations);
+    if (!normalized.ok) {
+      return JSON.stringify(fail(normalized.code, normalized.error,
+        ['Usa operations con type shortcut, text, mouse o click.']));
+    }
+    if (!reactiveHost || typeof reactiveHost.atomicInput !== 'function') {
+      return JSON.stringify(fail('RAC_UNAVAILABLE', 'Il controllo nativo di tastiera e mouse non e disponibile.',
+        ['Riavvia Horizon per caricare il nuovo host RAC.']));
+    }
+    if (!attachedTarget || !/^\d+$/.test(String(attachedTarget.windowId || ''))) {
+      return JSON.stringify(fail('NO_ATTACHED_WINDOW', 'Collega prima la finestra da controllare.',
+        ['computer_processes e computer_attach']));
+    }
+    if (!currentObservation || !/^\d+$/.test(String(currentObservation.observationId || ''))) {
+      return JSON.stringify(fail('OBSERVATION_REQUIRED', 'Serve una osservazione autorevole corrente.',
+        ['computer_control_reset per ottenere un observationId fresco']));
+    }
+    const allowed = await authorized(ctx, 'Usa tastiera e mouse nella finestra collegata');
+    if (!allowed) return JSON.stringify(denied('Controllo MCP-RAC'));
+    if (reactiveToolStream) await reactiveToolStream.discard('atomic_input');
+    const presentedInput = inputPreview(normalized.operations);
+    stateEvent({ type: 'action', phase: 'start', action: 'computer_control', attached: attachedTarget,
+      input: presentedInput });
+    const actionObservationId = String(currentObservation.observationId);
+    const result = await reactiveHost.atomicInput({
+      windowId: String(attachedTarget.windowId),
+      observationId: actionObservationId,
+      operations: normalized.operations,
+    });
+    if (!result || result.ok !== true) {
+      const code = String(result && result.code || 'RAC_INPUT_FAILED');
+      atomicFailure = { code, count: atomicFailure.code === code ? atomicFailure.count + 1 : 1 };
+      const recoverable = ['STALE_OBSERVATION', 'OBSERVATION_REQUIRED', 'SESSION_EXPIRED', 'SAFETY_STOP'].includes(code);
+      const recovered = recoverable && atomicFailure.count === 1
+        ? await rearmReactiveTarget('rac_atomic_input_failed') : null;
+      stateEvent({ type: 'action', phase: 'error', action: 'computer_control', attached: attachedTarget,
+        input: presentedInput });
+      const deterministic = !recoverable;
+      return JSON.stringify(fail(code,
+        String(result && result.error || 'Input nativo non eseguito.'),
+        recovered ? ['Continua una sola volta con computer_control usando il nuovo observationId']
+          : deterministic
+            ? ['Non ripetere la stessa azione e non acquisire altri screenshot: segnala il guasto nativo.']
+            : ['computer_control_reset una sola volta'],
+        { observationId: recovered && recovered.observation.observationId || null,
+          retryable: !!recovered, repeatedFailureCount: atomicFailure.count,
+          circuitOpen: deterministic || atomicFailure.count > 1 }));
+    }
+    atomicFailure = { code: '', count: 0 };
+    currentObservation = null;
+    const nextFrame = await capturePostActionObservation().catch(() => null);
+    if (!nextFrame) currentObservation = null;
+    stateEvent({ type: 'action', phase: 'complete', action: 'computer_control', attached: attachedTarget,
+      input: presentedInput });
+    const structuredContent = ok('Input RAC eseguito con tastiera e mouse nativi.', {
+      action: 'computer_control', mode: 'reactive', transport: 'native-atomic',
+      operationCount: result.operationCount,
+      actionObservationId,
+      observationId: nextFrame && nextFrame.observation.observationId || null,
+      nextObservationId: nextFrame && nextFrame.observation.observationId || null,
+      telemetry: result.telemetry || null,
+      capabilities: result.capabilities || null,
+    }, nextFrame
+      ? ['Continua con computer_control usando il frame e nextObservationId restituiti.']
+      : ['computer_control_reset per acquisire una nuova osservazione.']);
+    return {
+      output: JSON.stringify(structuredContent), structuredContent,
+      ...(nextFrame ? {
+        _meta: { 'vascend/computer-use': { image: {
+          type: 'image', mimeType: 'image/png', data: String(nextFrame.shot.data),
+        } } },
+        media: [{ mime: 'image/png', data: String(nextFrame.shot.data), source: 'computer-control-next-frame' }],
+      } : {}),
+    };
+  };
+
+  const tools = [
+    {
+      name: 'computer_processes',
+      direct: true,
+      description: 'Cerca applicazioni, processi e finestre reali del desktop, incluse quelle minimizzate o nel tray. Passa sempre query quando l utente nomina un app (es. Spotify o Claude): il risultato e ordinato per corrispondenza esatta e non dipende dall ordine o dal troncamento dell elenco generale. Poi usa computer_attach con il window_id restituito; se l app non risulta avviata usa computer_launch. Non legge memoria o command line dei processi.',
+      inputSchema: { type: 'object', properties: {
+        query: { type: 'string', description: 'Nome app/processo o parte del titolo, ad esempio Spotify, spotify.exe o Claude.' },
+        limit: { type: 'number', description: 'Numero massimo di risultati per sezione (1-50, default 20 con query).' },
+      } },
+      handler: async (input, ctx) => {
+        const allowed = await authorized(ctx, 'Visualizza le applicazioni e le finestre aperte sul computer');
+        if (!allowed) return JSON.stringify(denied('Accesso a Computer Use'));
+        stateEvent({ type: 'processes', phase: 'start' });
+        const { applications, processes, windows } = await desktop.targetsNow((progress) => {
+          stateEvent({ type: 'processes', ...progress, windowCount: progress.windows.length });
+        });
+        const query = String(input && input.query || '').trim().slice(0, 160);
+        const limit = integer(input && input.limit, 1, 50, query ? 20 : 24);
+        const matchedApplications = searchedTargets(applications, query, limit,
+          (row) => [row.name, row.process, row.titles]);
+        const matchedProcesses = searchedTargets(processes, query, query ? limit : Math.min(48, limit * 2),
+          (row) => [row.process, row.title]);
+        const matchedWindows = searchedTargets(windows, query, query ? limit : Math.min(48, limit * 2),
+          (row) => [row.process, row.title]);
+        // Le icone sono UI-only e relativamente costose da estrarre dagli exe:
+        // basta anticipare quelle dei primi risultati controllabili. L'app scelta
+        // viene comunque idratata sempre durante computer_attach.
+        await desktop.hydrateApplicationIcons(matchedApplications
+          .filter((application) => application.controllable).slice(0, query ? 8 : 6));
+        stateEvent({
+          type: 'processes', phase: 'complete', query,
+          applicationCount: matchedApplications.length, processCount: matchedProcesses.length,
+          windowCount: matchedWindows.length, totalApplicationCount: applications.length,
+          totalProcessCount: processes.length, totalWindowCount: windows.length,
+          applications: matchedApplications.map(uiApplication), processes: matchedProcesses, windows: matchedWindows,
+        });
+        const matched = matchedApplications.length + matchedProcesses.length + matchedWindows.length > 0;
+        const payload = {
+          trust: 'UNTRUSTED_DESKTOP_DATA',
+          query,
+          matched,
+          attached: publicTarget(attachedTarget),
+          applicationCount: matchedApplications.length,
+          processCount: matchedProcesses.length,
+          windowCount: matchedWindows.length,
+          totalApplicationCount: applications.length,
+          totalProcessCount: processes.length,
+          totalWindowCount: windows.length,
+          applications: matchedApplications.map(publicApplication),
+          processes: matchedProcesses,
+          windows: matchedWindows,
+        };
+        if (query && !matched) {
+          return JSON.stringify(warn(`Nessun processo o finestra corrisponde a "${query}".`,
+            { ...payload, hint: `Nessun processo o finestra corrisponde a "${query}". Verifica che l applicazione sia avviata.` },
+            [`computer_launch con app "${query}" per avviarla`, 'computer_processes senza query per vedere cosa e aperto']));
+        }
+        return JSON.stringify(ok(query
+          ? `${matchedApplications.length} applicazioni corrispondono a "${query}".`
+          : `${applications.length} applicazioni e ${windows.length} finestre rilevate.`,
+        payload, ['computer_attach con il window_id scelto']));
+      },
+    },
+    {
+      name: 'computer_launch',
+      description: 'Avvia una applicazione gia installata cercandola fra le scorciatoie del menu Start e, quando la finestra compare, la collega da sola. Usalo quando computer_processes non trova l app perche non e in esecuzione: senza questo passo la catena si interrompe. Non installa nulla e non esegue comandi arbitrari.',
+      inputSchema: { type: 'object', properties: {
+        app: { type: 'string', description: 'Nome dell applicazione, ad esempio Spotify, Blocco note, Visual Studio Code.' },
+        wait_ms: { type: 'number', description: 'Attesa della comparsa della finestra (1000-20000, default 9000).' },
+      }, required: ['app'] },
+      handler: async (input, ctx) => {
+        const app = String(input && input.app || '').trim().slice(0, 120);
+        if (!app) return JSON.stringify(fail('BAD_INPUT', 'Nome applicazione mancante.', ['Indica app, ad esempio "Spotify"']));
+        if (!launchApp) {
+          return JSON.stringify(fail('UNSUPPORTED', 'Questa integrazione non puo avviare applicazioni.',
+            ['computer_processes per collegare una applicazione gia aperta']));
+        }
+        const allowed = await authorized(ctx, `Avvia l applicazione ${app} sul computer`);
+        if (!allowed) return JSON.stringify(denied('Avvio di una applicazione'));
+        const before = new Set((await desktop.windowsNow()).map((row) => row.windowId));
+        let candidates = [];
+        if (listInstalledApps) {
+          let entries = [];
+          try { entries = await listInstalledApps(); } catch (_) { entries = []; }
+          candidates = startMenuMatches(entries, app, 4);
+        }
+        stateEvent({ type: 'launch', phase: 'start', app });
+        const launched = await launchApp({ target: candidates.length ? candidates[0].path : app });
+        if (!launched || launched.ok !== true) {
+          stateEvent({ type: 'launch', phase: 'error', app });
+          return JSON.stringify(fail('LAUNCH_FAILED', String(launched && launched.error || `Non riesco ad avviare ${app}.`),
+            ['computer_processes per cercarla con un altro nome', 'Chiedi all utente di aprirla manualmente'],
+            candidates.length ? { candidates: candidates.map((row) => row.name) } : {}));
+        }
+        const waitMs = integer(input && input.wait_ms, 1000, MAX_LAUNCH_WAIT_MS, 9000);
+        const deadline = Date.now() + waitMs;
+        let fresh = [];
+        while (Date.now() < deadline && !(ctx && ctx.signal && ctx.signal.aborted)) {
+          await new Promise((resolve) => setTimeout(resolve, 700));
+          desktop.invalidate();
+          const rows = await desktop.windowsNow();
+          fresh = searchedTargets(rows.filter((row) => !before.has(row.windowId)), app, 6,
+            (row) => [row.process, row.title]);
+          if (fresh.length) break;
+          // Alcune applicazioni riusano una finestra esistente invece di
+          // crearne una: se ne resta una sola che corrisponde, e' il target.
+          const existing = searchedTargets(rows.filter((row) => row.visible), app, 6,
+            (row) => [row.process, row.title]);
+          if (existing.length === 1) { fresh = existing; break; }
+        }
+        stateEvent({ type: 'launch', phase: 'complete', app, windowCount: fresh.length });
+        if (!fresh.length) {
+          return JSON.stringify(warn(`${app} avviata, ma nessuna finestra e ancora comparsa.`,
+            { app, launched: true },
+            ['computer_wait con for_title per attenderla', 'computer_processes con query per collegarla']));
+        }
+        if (fresh.length > 1) {
+          return JSON.stringify(warn(`${app} avviata: ${fresh.length} finestre disponibili.`,
+            { app, launched: true,
+              candidates: fresh.map((row) => ({ windowId: row.windowId, title: row.title, process: row.process })) },
+            ['computer_attach con il window_id scelto']));
+        }
+        const { applications } = await desktop.targetsNow();
+        const attached = await attachWindow(fresh[0], applications);
+        return JSON.stringify(attached.ok
+          ? { ...attached, app, launched: true, summary: `${app} avviata e collegata.` }
+          : attached);
+      },
+    },
+    {
+      name: 'computer_attach',
+      direct: true,
+      description: 'Collega Computer Use a una applicazione, finestra o processo rilevato. Ripristina anche una finestra minimizzata/nascosta. Ispezione semantica, azioni e screenshot restano vincolati a questa finestra finche non usi computer_detach.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          application_id: { type: 'string', description: 'application_id restituito in applications da computer_processes; e la scelta consigliata.' },
+          window_id: { type: 'string', description: 'window_id restituito da computer_processes (scelta piu precisa).' },
+          process_id: { type: 'number', description: 'process_id restituito da computer_processes.' },
+          process_name: { type: 'string', description: 'Nome del processo restituito da computer_processes, ad esempio claude.' },
+          title: { type: 'string', description: 'Parte del titolo per distinguere piu finestre dello stesso processo.' },
+        },
+      },
+      handler: async (input, ctx) => {
+        const allowed = await authorized(ctx, 'Collega Computer Use a una applicazione o finestra visibile');
+        if (!allowed) return JSON.stringify(denied('Accesso a Computer Use'));
+        const { applications, windows: rows } = await desktop.targetsNow();
+        const applicationId = String(input && input.application_id || '');
+        const windowId = String(input && input.window_id || '');
+        const processId = integer(input && input.process_id, 0, 2147483647);
+        const processName = String(input && input.process_name || '').trim().toLocaleLowerCase();
+        const title = String(input && input.title || '').trim().toLocaleLowerCase();
+        const selected = applications.find((row) => applicationId && row.applicationId === applicationId);
+        let candidates = windowId ? rows.filter((row) => row.windowId === windowId)
+          : selected ? rows.filter((row) => selected.windowIds.includes(row.windowId))
+            : processId ? rows.filter((row) => row.processId === processId)
+              : processName ? rows.filter((row) => row.process.toLocaleLowerCase() === processName)
+                : [];
+        if (title) candidates = candidates.filter((row) => row.title.toLocaleLowerCase().includes(title));
+        candidates.sort((a, b) => Number(b.visible) - Number(a.visible)
+          || Number(a.minimized) - Number(b.minimized) || a.title.localeCompare(b.title));
+        if (!windowId && candidates.length > 1) {
+          return JSON.stringify(fail('AMBIGUOUS_TARGET',
+            'Questa applicazione espone piu finestre. Scegli il window_id preciso; nessuna finestra e stata portata in primo piano.',
+            ['computer_attach con window_id preso da candidates'],
+            { candidates: candidates.slice(0, 12).map((row) => ({
+              windowId: row.windowId, processId: row.processId, process: row.process,
+              title: row.title, visible: row.visible, minimized: row.minimized,
+            })) }));
+        }
+        if (!candidates.length) {
+          return JSON.stringify(fail('NO_WINDOW', 'Il processo esiste ma non espone una finestra controllabile.',
+            ['computer_launch per aprire l applicazione', 'computer_processes per rileggere i target disponibili']));
+        }
+        return JSON.stringify(await attachWindow(candidates[0],
+          selected ? [selected, ...applications] : applications));
+      },
+    },
+    {
+      name: 'computer_open_path',
+      direct: true,
+      description: 'Apre una cartella assoluta in Esplora file e verifica semanticamente il percorso realmente mostrato. Usa questo strumento quando l utente chiede di aprire o mostrare una cartella: non simulare Ctrl+L, F4 o digitazione nella barra degli indirizzi. Se Computer Use e gia collegato a Esplora file, naviga quella finestra; altrimenti apre una finestra dedicata.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Percorso assoluto della cartella, ad esempio C:\\Users\\nome\\Desktop\\progetto.' },
+        },
+        required: ['path'],
+      },
+      handler: async (input, ctx) => {
+        const requestedPath = String(input && input.path || '').trim();
+        const allowed = await authorized(ctx, `Apri in Esplora file la cartella ${requestedPath || 'richiesta'}`);
+        if (!allowed) return JSON.stringify(denied('Apertura cartella'));
+        if (!openPath) {
+          return JSON.stringify(fail('UNAVAILABLE', 'La navigazione semantica delle cartelle non e disponibile in questo ambiente.',
+            ['computer_processes per collegare Esplora file']));
+        }
+        stateEvent({ type: 'action', phase: 'start', action: 'computer_open_path', attached: attachedTarget });
+        const result = await openPath({
+          path: requestedPath,
+          windowId: attachedTarget && String(attachedTarget.process || '').toLocaleLowerCase() === 'explorer'
+            ? attachedTarget.windowId : '',
+        });
+        if (!result || result.ok !== true || result.verified !== true) {
+          stateEvent({ type: 'action', phase: 'error', action: 'computer_open_path', attached: attachedTarget });
+          invalidateVisualState();
+          return JSON.stringify(fail(String(result && result.code || 'PATH_NOT_CONFIRMED'),
+            String(result && result.error || 'Esplora file non ha confermato la cartella richiesta.'),
+            ['computer_processes con query "Esplora file" per rileggere lo stato'],
+            { requestedPath, currentPath: String(result && result.currentPath || '') }));
+        }
+        desktop.invalidate();
+        const rows = await desktop.windowsNow();
+        const match = rows.find((row) => row.windowId === String(result.windowId || ''));
+        if (match) {
+          attachedTarget = {
+            ...match,
+            applicationId: attachedTarget && attachedTarget.applicationId || '',
+            applicationName: 'Esplora file',
+            icon: attachedTarget && attachedTarget.icon || '',
+          };
+        }
+        targetCache = new Map();
+        invalidateVisualState();
+        stateEvent({ type: 'action', phase: 'complete', action: 'computer_open_path', attached: attachedTarget });
+        return JSON.stringify(ok(`Cartella aperta e verificata: ${result.path}.`, {
+          action: 'computer_open_path',
+          verified: true,
+          verificationRequired: false,
+          path: result.path,
+          attached: publicTarget(attachedTarget),
+        }));
+      },
+    },
+    {
+      name: 'computer_detach',
+      description: 'Rimuove il collegamento alla finestra/processo e torna al desktop generale.',
+      inputSchema: { type: 'object', properties: {} },
+      handler: async () => {
+        const previous = attachedTarget;
+        attachedTarget = null; targetCache = new Map(); invalidateVisualState('computer_detach', false);
+        if (reactiveHost) {
+          if (typeof reactiveHost.disarmTarget === 'function') await reactiveHost.disarmTarget();
+          else if (typeof reactiveHost.clearTarget === 'function') reactiveHost.clearTarget();
+        }
+        if (reactiveFastLane && typeof reactiveFastLane.disarm === 'function') {
+          await reactiveFastLane.disarm('computer_detach');
+        }
+        stateEvent({ type: 'detach', attached: previous });
+        return JSON.stringify(ok('Collegamento rimosso.', { detached: publicTarget(previous) },
+          ['computer_processes per scegliere un altro target']));
+      },
+    },
+    {
+      name: 'computer_snapshot',
+      description: 'Fallback visuale: cattura il desktop o la finestra collegata. Per impostazione predefinita l immagine resta nella UI e NON viene inviata al modello. Imposta include_image=true solo quando computer_inspect non espone il controllo necessario o serve comprendere un contenuto puramente visuale. Non acquisire screenshot dopo ogni click.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          display: { type: 'string', description: 'ID o indice del monitor; omesso usa il monitor principale.' },
+          include_image: { type: 'boolean', description: 'Invia i pixel al modello. Default false; abilitalo soltanto se UI Automation non basta.' },
+          original_colors: { type: 'boolean', description: 'true per ricevere i colori REALI invece del frame invertito per visual token (default: invertito). Usalo quando devi nominare i colori.' },
+          patch_map: { type: 'boolean', description: 'true per ricevere anche la mappa adattiva dei visual token: DOM di div con data-x/y/w/h/color (zone uniformi = un blocco, dettaglio dove serve). Leggi posizione e colore dai data-*, non dai pixel.' },
+          patch_size: { type: 'number', description: 'Lato minimo in px dei blocchi della mappa adattiva (4-128, default 16).' },
+        },
+      },
+      handler: async (input, ctx) => {
+        if (ctx && ctx.signal && ctx.signal.aborted) return 'operazione interrotta';
+        // Il modello a volte passa "true" come stringa: uno schema booleano non
+        // deve trasformare quel dettaglio in "non hai visto la schermata".
+        const wantsImage = !!input && (input.include_image === true
+          || String(input.include_image).trim().toLowerCase() === 'true');
+        const allowed = await authorized(ctx, attachedTarget
+          ? `Acquisisci la schermata della finestra ${attachedTarget.title || attachedTarget.process || 'collegata'}`
+          : 'Acquisisci una schermata del desktop');
+        if (!allowed) return JSON.stringify(denied('Accesso a Computer Use'));
+        // Tre letture native in fila costavano quasi due secondi PRIMA di
+        // catturare: enumerazione finestre, cattura, stato del desktop. La
+        // cattura usa i bounds noti (sono quelli dei pixel che riprende), la
+        // verifica che la finestra esista ancora corre in parallelo, e lo stato
+        // generale del desktop non si chiede affatto quando si e' collegati: la
+        // finestra la conosciamo gia'.
+        const captureInput = attachedTarget
+          ? { ...(input || {}), windowId: attachedTarget.windowId, windowTitle: attachedTarget.title, windowBounds: attachedTarget.bounds }
+          : (input || {});
+        const [alive, shot, info] = await Promise.all([
+          attachedTarget ? refreshAttached() : Promise.resolve(true),
+          captureDesktop(captureInput),
+          attachedTarget ? Promise.resolve({}) : desktopInfo(),
+        ]);
+        if (!alive) {
+          return JSON.stringify(fail('WINDOW_CLOSED', 'La finestra collegata e stata chiusa.',
+            ['computer_processes per scegliere un nuovo target']));
+        }
+        if (!shot || !shot.data) {
+          return JSON.stringify(fail('CAPTURE_FAILED', String(shot && shot.error || 'Screenshot non disponibile.'),
+            ['computer_processes per verificare che la finestra sia ancora aperta']));
+        }
+        const bounds = shot.bounds && typeof shot.bounds === 'object'
+          ? shot.bounds : (attachedTarget && attachedTarget.bounds)
+            || { x: 0, y: 0, width: Number(shot.width) || 0, height: Number(shot.height) || 0 };
+        lastSnapshot = {
+          id: 'snap-' + crypto.randomUUID(), capturedAt: Date.now(),
+          width: Number(shot.width) || 1, height: Number(shot.height) || 1, bounds,
+        };
+        const observation = await visualObservation({ ...shot, bounds }, 'computer_snapshot');
+        if (observation) lastSnapshot.observationId = observation.observationId;
+        stateEvent({ type: 'snapshot', attached: attachedTarget, bounds });
+        // Copia per il MODELLO: inversione visual-token a geometria intatta.
+        // L'immagine della UI (_meta) resta SEMPRE quella reale.
+        const originalColors = !!input && (input.original_colors === true
+          || String(input.original_colors).trim().toLowerCase() === 'true');
+        const modelFrame = wantsImage && visualFrame
+          ? visualFrame.pngPerModello(shot.data, { invertiColori: !originalColors })
+          : { data: String(shot.data), inverted: false };
+        // Mappa adattiva dei visual token: il DOM con posizione e colore come
+        // dati, per leggere lo schermo matematicamente invece che dai pixel.
+        const wantsPatchMap = !!input && (input.patch_map === true
+          || String(input.patch_map).trim().toLowerCase() === 'true');
+        const patchMap = wantsPatchMap && visualFrame && typeof visualFrame.mappaAdattivaDaPng === 'function'
+          ? visualFrame.mappaAdattivaDaPng(shot.data, {
+            latoMinimo: Number(input && input.patch_size) || 16,
+            titolo: 'Mappa visual token dello schermo',
+          })
+          : null;
+        const structuredContent = {
+          ok: true,
+          status: observation || !reactiveHost ? 'success' : 'degraded',
+          summary: wantsImage
+            ? (attachedTarget
+              ? `Schermata di ${attachedTarget.title || attachedTarget.process} allegata.`
+              : 'Schermata del desktop allegata.')
+            : 'Schermata catturata per la UI, non inviata al modello.',
+          snapshotId: lastSnapshot.id,
+          observationId: observation && observation.observationId || null,
+          ...(!observation && lastObservationError ? { racObservationError: lastObservationError } : {}),
+          capturedAt: new Date(lastSnapshot.capturedAt).toISOString(),
+          trust: 'UNTRUSTED_DESKTOP_DATA',
+          attached: publicTarget(attachedTarget),
+          display: shot.display || '',
+          width: Number(shot.width) || 0,
+          height: Number(shot.height) || 0,
+          desktopBounds: bounds,
+          coordinateSpace: 'Passa snapshot_id e coordinate dei pixel di questa immagine; Horizon le convalida e converte nel monitor reale.',
+          ...info,
+          // Senza questa formulazione il modello leggeva "schermata acquisita" e
+          // DESCRIVEVA uno schermo che non aveva mai ricevuto, inventando il
+          // contenuto. Il divieto deve stare nel risultato, non nella
+          // descrizione del tool.
+          note: wantsImage
+            ? ('Immagine inoltrata al modello come dato non fidato: analizzala.'
+              + (modelFrame.inverted ? ' ' + (visualFrame && visualFrame.NOTA_INVERSIONE || '') : ''))
+            : 'Immagine mostrata nella UI e non inoltrata al modello: NON hai visto questa schermata, quindi non descriverne ne dedurne il contenuto. Per leggere la finestra usa computer_inspect; per vedere davvero i pixel richiama con include_image=true.',
+          ...(modelFrame.inverted ? { inverted: true } : {}),
+          ...(patchMap ? {
+            visual_token_map: String(patchMap.html || '').slice(0, 24000),
+            visual_token_blocks: patchMap.scomposizione.blocchi.length,
+          } : {}),
+          nextActions: observation || !reactiveHost
+            ? ['computer_inspect per agire su target stabili invece che su coordinate']
+            : ['computer_control_reset per riarmare RAC',
+              'computer_inspect e computer_batch restano disponibili come fallback UI Automation'],
+        };
+        return {
+          output: JSON.stringify(structuredContent),
+          structuredContent,
+          _meta: { 'vascend/computer-use': { image: { type: 'image', mimeType: 'image/png', data: String(shot.data) } } },
+          ...(wantsImage
+            ? { media: [{ mime: 'image/png', data: String(modelFrame.data), source: 'computer-snapshot' }] }
+            : {}),
+        };
+      },
+    },
+    {
+      name: 'computer_inspect',
+      direct: true,
+      description: 'Legge i controlli reali della finestra collegata tramite Windows UI Automation e assegna target_id stabili. E il percorso predefinito e veloce. Filtra sempre: query cerca per nome o valore, types limita ai ruoli utili, include_text aggiunge le etichette e ti fa LEGGERE la finestra senza screenshot. Dopo questa chiamata raggruppa activate, fill, key e wait in un solo computer_batch.',
+      inputSchema: { type: 'object', properties: {
+        query: { type: 'string', description: 'Testo cercato in nome, valore o automation id, ad esempio Cerca o Salva.' },
+        types: { type: 'array', items: { type: 'string' }, description: 'Ruoli UIA da tenere, ad esempio ["Button","Edit"].' },
+        interactive_only: { type: 'boolean', description: 'Solo controlli agibili (default true).' },
+        include_text: { type: 'boolean', description: 'Include le etichette di testo: serve per leggere il contenuto.' },
+        limit: { type: 'number', description: 'Massimo di controlli restituiti (1-320, default 60).' },
+        refresh: { type: 'boolean', description: 'Forza una nuova lettura del tree invece della cache di un secondo.' },
+      } },
+      handler: async (input, ctx) => {
+        const allowed = await authorized(ctx, 'Leggi i controlli interattivi della finestra collegata');
+        if (!allowed) return JSON.stringify(denied('Accesso a Computer Use'));
+        const includeText = input && input.include_text === true;
+        const rows = await readTree({ force: input && input.refresh === true, includeText });
+        const selection = filterElements(rows, {
+          query: input && input.query,
+          types: input && input.types,
+          interactiveOnly: !(input && input.interactive_only === false) && !includeText,
+          limit: input && input.limit,
+        });
+        const targets = selection.rows.map(compactElement);
+        const observation = await semanticObservation(selection.rows);
+        stateEvent({ type: 'inspect', attached: attachedTarget, targetCount: targets.length, targets: selection.rows });
+        const query = String(input && input.query || '').trim();
+        const failure = lastReadFailure();
+        if (failure && !selection.total) {
+          // Non dire "nessun controllo" quando la lettura non e' riuscita: il
+          // modello concluderebbe che l'applicazione non e' pilotabile e
+          // passerebbe a tirare a indovinare sulle coordinate.
+          return JSON.stringify(fail(failure.code, `Lettura dei controlli non riuscita: ${failure.error}`,
+            ['computer_inspect con refresh true per ritentare la lettura',
+              'computer_snapshot con include_image true se serve capire visivamente la finestra'],
+            { attached: publicTarget(attachedTarget), observationId: observation && observation.observationId || null,
+              ...(!observation && lastObservationError ? { racObservationError: lastObservationError } : {}), targetCount: 0, targets: [] }));
+        }
+        if (!targets.length) {
+          return JSON.stringify(warn(query
+            ? `Nessun controllo corrisponde a "${query}" su ${selection.total} letti.`
+            : 'Nessun controllo agibile nella finestra collegata.',
+          { trust: 'UNTRUSTED_DESKTOP_DATA', attached: publicTarget(attachedTarget), observationId: observation && observation.observationId || null,
+            ...(!observation && lastObservationError ? { racObservationError: lastObservationError } : {}), targetCount: 0, totalCount: selection.total, targets: [] },
+          [selection.total ? 'computer_inspect senza query oppure con interactive_only false' : 'computer_wait con for_text per attendere il caricamento',
+            'computer_snapshot con include_image true se il contenuto e solo visuale']));
+        }
+        const inspectEnvelope = !observation && reactiveHost ? warn : ok;
+        return JSON.stringify(inspectEnvelope(`${targets.length} controlli disponibili${query ? ` per "${query}"` : ''}${selection.truncated ? `, altri ${selection.truncated} oltre il limite` : ''}.`,
+          {
+            trust: 'UNTRUSTED_DESKTOP_DATA',
+            attached: publicTarget(attachedTarget),
+            observationId: observation && observation.observationId || null,
+            ...(!observation && lastObservationError ? { racObservationError: lastObservationError } : {}),
+            targetCount: targets.length,
+            totalCount: selection.total,
+            ...(selection.truncated ? { truncated: selection.truncated } : {}),
+            targets,
+          },
+          // Dire "altri N oltre il limite" senza dire COME prenderli spingeva il
+          // modello a inventarsi una paginazione (output_page su un id mai
+          // emesso). Il modo per averli e' uno solo: chiedere meglio.
+          [...(selection.truncated
+            ? [`computer_inspect con una query piu precisa, oppure limit fino a 320, per i restanti ${selection.truncated}`]
+            : []),
+            ...(!observation && reactiveHost ? ['computer_control_reset per riarmare RAC'] : []),
+            'computer_batch se i passi sono due o piu', 'computer_activate o computer_fill per un singolo passo']));
+      },
+    },
+    {
+      name: 'computer_activate',
+      direct: true,
+      description: 'Agisce su un controllo di computer_inspect con i pattern nativi di UI Automation (Invoke, Toggle, Select, Expand): colpisce l elemento anche se va portato in vista, senza spostare il puntatore dell utente, e ripiega su un click a coordinate solo se il controllo non espone alcun pattern. Riporta da solo che cosa e cambiato nella finestra.',
+      inputSchema: { type: 'object', properties: {
+        target_id: { type: 'string' },
+        mode: { type: 'string', enum: ['invoke', 'toggle', 'select', 'expand', 'collapse', 'focus', 'click'],
+          description: 'Default invoke: sceglie il pattern giusto da solo. click forza il puntatore.' },
+        button: { type: 'string', description: 'left, right o middle, solo per il percorso a click.' },
+        clicks: { type: 'number', description: '1, 2 o 3, solo per il percorso a click.' },
+        verify: { type: 'string', enum: ['delta', 'none'], description: 'delta (default) rilegge la finestra e riporta i cambiamenti.' },
+      }, required: ['target_id'] },
+      handler: async (input, ctx) => {
+        const allowed = await authorized(ctx, 'Attiva un controllo nella finestra collegata');
+        if (!allowed) return JSON.stringify(denied('Azione sul computer'));
+        const target = await resolveTarget(input && input.target_id);
+        if (!target) return JSON.stringify(missingTarget());
+        if (!target.enabled) {
+          return JSON.stringify(fail('DISABLED', `Il controllo "${target.name || target.type}" e disabilitato.`,
+            ['computer_inspect per trovare il passo che lo abilita']));
+        }
+        const mode = activateMode(target, input && input.mode);
+        const verify = wantsVerification(input);
+        const baseline = baselineFor(verify);
+        const pointer = pointerFor(target);
+        const extra = { target: { targetId: input.target_id, name: target.name, type: target.type } };
+        stateEvent({ type: 'action', phase: 'start', action: 'computer_activate',
+          attached: attachedTarget, ...(pointer ? { pointer } : {}) });
+        if (uiAction && mode !== 'click') {
+          const result = await nativeOrPointer(target, pointer, { action: mode },
+            (spot) => clickAt(spot, input || {}));
+          return JSON.stringify(await actionOutcome('computer_activate', result, {
+            pointer, baseline, verify, extra: { ...extra, ...(result && result.method ? { method: result.method } : {}) },
+          }));
+        }
+        if (!pointer) {
+          return JSON.stringify(fail('NO_BOUNDS', 'Il controllo non ha una posizione utilizzabile.',
+            ['computer_inspect con refresh true, poi riprova']));
+        }
+        return JSON.stringify(await actionOutcome('computer_activate', await clickAt(pointer, input || {}), {
+          pointer, baseline, verify, extra,
+        }));
+      },
+    },
+    {
+      name: 'computer_fill',
+      direct: true,
+      description: 'Scrive in un campo di computer_inspect: prende il focus tramite UI Automation e digita Unicode con ritmo umano nella stessa operazione atomica. I testi lunghi passano dagli appunti (poi ripristinati) invece di sforare il timeout. Con clear svuota il campo prima. Non usarlo per password, codici o segreti.',
+      inputSchema: { type: 'object', properties: {
+        target_id: { type: 'string' },
+        text: { type: 'string' },
+        submit: { type: 'boolean', description: 'Premi Invio dopo la scrittura.' },
+        clear: { type: 'boolean', description: 'Svuota il campo (CTRL+A) prima di scrivere.' },
+        verify: { type: 'string', enum: ['delta', 'none'] },
+      }, required: ['target_id', 'text'] },
+      handler: async (input, ctx) => {
+        const text = String(input && input.text || '').slice(0, MAX_TEXT);
+        const allowed = await authorized(ctx, `Compila un campo della finestra collegata con ${text.length} caratteri${input && input.submit === true ? ' e invia' : ''}`);
+        if (!allowed) return JSON.stringify(denied('Azione sul computer'));
+        if (!text) return JSON.stringify(fail('BAD_INPUT', 'Testo mancante.', ['Passa text con il contenuto da scrivere']));
+        const target = await resolveTarget(input && input.target_id);
+        if (!target) return JSON.stringify(missingTarget('computer_inspect con types ["Edit"] per trovare il campo'));
+        if (!target.enabled) {
+          return JSON.stringify(fail('DISABLED', `Il campo "${target.name || target.type}" e disabilitato.`,
+            ['computer_inspect per rileggere lo stato']));
+        }
+        if (target.isPassword) {
+          return JSON.stringify(fail('PASSWORD', 'Computer Use non compila password, codici o campi segreti.',
+            ['Chiedi all utente di digitare la credenziale personalmente']));
+        }
+        const verify = wantsVerification(input);
+        const baseline = baselineFor(verify);
+        const pointer = pointerFor(target);
+        const clear = input && input.clear === true;
+        const submit = input && input.submit === true;
+        const extra = { target: { targetId: input.target_id, name: target.name, type: target.type },
+          characterCount: text.length };
+        stateEvent({ type: 'action', phase: 'start', action: 'computer_fill',
+          attached: attachedTarget, input: { keyboard: { characterCount: text.length,
+            ...(clear ? { keys: ['Ctrl', 'A'] } : {}) } }, ...(pointer ? { pointer } : {}) });
+        if (uiAction) {
+          const action = text.length > PASTE_THRESHOLD ? 'paste' : 'type';
+          // Scala di tentativi VERIFICATI. SetFocus di UI Automation sposta il
+          // fuoco della finestra ma non sempre quello del DOM: nelle app
+          // Chromium/CEF (Spotify) i caratteri finivano nel nulla e il tool
+          // rispondeva "ok". Ogni tentativo viene ora confermato rileggendo il
+          // valore del campo; il click reale e' il rimedio, non il primo colpo.
+          let result = await nativeOrPointer(target, pointer, { action, value: text, clear, submit },
+            (spot) => fillAt(spot, { text, clear, submit }));
+          let written = await textLanded(target, text);
+          if (result && result.ok === true && written === false) {
+            const retry = pointer
+              ? await fillAt(pointer, { text, clear, submit })
+              : await uiAction(nativeRequest(target, { action: 'setValue', value: text, clear, submit }));
+            if (retry && retry.ok === true) {
+              result = { ...retry, method: pointer ? 'Click+Type' : 'SetValue' };
+              written = await textLanded(target, text);
+            }
+          }
+          if (result && result.ok === true && written === false) {
+            stateEvent({ type: 'action', phase: 'error', action: 'computer_fill',
+              attached: attachedTarget, ...(pointer ? { pointer } : {}) });
+            invalidateVisualState();
+            return JSON.stringify(fail('NO_TEXT_WRITTEN',
+              `Il campo "${target.name || target.type}" non ha ricevuto il testo: la finestra ha accettato l input ma il valore non e cambiato.`,
+              ['computer_activate con mode click sul campo, poi computer_type per scrivere nella finestra attiva',
+                'computer_snapshot con include_image true per vedere dove e finito il cursore'],
+              { ...extra, method: String(result.method || action) }));
+          }
+          return JSON.stringify(await actionOutcome('computer_fill', result, {
+            pointer, baseline, verify, freshTree: written !== null,
+            extra: { ...extra, ...(result && result.method ? { method: result.method } : {}),
+              ...(written === true ? { textConfirmed: true } : {}) },
+          }));
+        }
+        if (!pointer) {
+          return JSON.stringify(fail('NO_BOUNDS', 'Il campo non ha una posizione utilizzabile.',
+            ['computer_inspect con refresh true']));
+        }
+        // Focus + click + digitazione avvengono nello stesso processo nativo:
+        // meno latenza e nessun input consegnato per errore a un'altra app.
+        return JSON.stringify(await actionOutcome('computer_fill', await fillAt(pointer, { text, clear, submit }), {
+          pointer, baseline, verify, extra,
+        }));
+      },
+    },
+    {
+      name: 'computer_key',
+      description: 'Invia scorciatoie alla finestra collegata o attiva. Accetta una SEQUENZA in una sola chiamata (["CTRL+A","DELETE"]) e repeat per ripeterla: usalo per non ripetere la stessa tool call. Conosce anche i tasti multimediali (MEDIAPLAY, MEDIANEXT, VOLUMEUP) e invia i tasti estesi con il flag corretto.',
+      inputSchema: { type: 'object', properties: {
+        keys: { type: 'array', items: { type: 'string' }, description: 'Esempio: ["CTRL+L"], ["CTRL+A","DELETE"], ["ALT","TAB"].' },
+        repeat: { type: 'number', description: 'Ripetizioni della sequenza (1-40, default 1).' },
+        verify: { type: 'string', enum: ['delta', 'none'] },
+      }, required: ['keys'] },
+      handler: async (input, ctx) => {
+        const chords = keyChords(input && input.keys);
+        if (!chords.length) {
+          return JSON.stringify(fail('BAD_INPUT', 'Scorciatoia non valida.',
+            ['Usa nomi di tasti riconosciuti, ad esempio ["CTRL+S"] o ["ENTER"]']));
+        }
+        const repeat = integer(input && input.repeat, 1, 40, 1);
+        const allowed = await authorized(ctx, `Invia ${chords.length > 1 ? `una sequenza di ${chords.length} scorciatoie` : 'una scorciatoia'}${repeat > 1 ? ` x${repeat}` : ''}`);
+        if (!allowed) return JSON.stringify(denied('Azione sul computer'));
+        const verify = wantsVerification(input);
+        const baseline = baselineFor(verify);
+        stateEvent({ type: 'action', phase: 'start', action: 'computer_key', attached: attachedTarget,
+          input: { keyboard: { keys: chords.flat().slice(0, 4) } } });
+        const result = await performAction('key', {
+          keys: input.keys, ...(repeat > 1 ? { repeat } : {}),
+          ...(attachedTarget && attachedTarget.windowId ? { windowId: attachedTarget.windowId } : {}),
+        });
+        return JSON.stringify(await actionOutcome('computer_key', result, {
+          baseline, verify, extra: { chordCount: chords.length, ...(repeat > 1 ? { repeat } : {}) },
+        }));
+      },
+    },
+    {
+      name: 'computer_scroll',
+      description: 'Scorre la finestra collegata. Con target_id scorre sopra un controllo di computer_inspect e non serve nessuno screenshot; in alternativa passa snapshot_id con le coordinate. Importo positivo sale, negativo scende; axis horizontal per lo scorrimento laterale.',
+      inputSchema: { type: 'object', properties: {
+        target_id: { type: 'string', description: 'Controllo sopra cui posizionare il puntatore, da computer_inspect.' },
+        snapshot_id: { type: 'string', description: 'snapshotId di computer_snapshot, se usi le coordinate.' },
+        x: { type: 'number' }, y: { type: 'number' },
+        amount: { type: 'number', description: 'Positivo sale, negativo scende (default -600).' },
+        axis: { type: 'string', enum: ['vertical', 'horizontal'] },
+        verify: { type: 'string', enum: ['delta', 'none'] },
+      } },
+      handler: async (input, ctx) => {
+        const amount = integer(input && input.amount, -12000, 12000, -600);
+        const axis = String(input && input.axis || '').toLowerCase() === 'horizontal' ? 'horizontal' : 'vertical';
+        const targetId = String(input && input.target_id || '');
+        let pointer = null;
+        if (targetId) {
+          const target = await resolveTarget(targetId);
+          if (!target) return JSON.stringify(missingTarget());
+          pointer = pointerFor(target);
+        } else {
+          const coordinates = snapshotPointer(input);
+          if (coordinates.error) return JSON.stringify(coordinates.error);
+          pointer = coordinates.pointer;
+        }
+        if (!pointer) {
+          return JSON.stringify(fail('BAD_INPUT', 'Serve un target_id oppure snapshot_id con coordinate.',
+            ['computer_inspect per un target stabile']));
+        }
+        const allowed = await authorized(ctx, `Scorri di ${amount} a ${pointer.x},${pointer.y}`);
+        if (!allowed) return JSON.stringify(denied('Azione sul computer'));
+        const verify = wantsVerification(input);
+        const baseline = baselineFor(verify);
+        stateEvent({ type: 'action', phase: 'start', action: 'computer_scroll', attached: attachedTarget, pointer,
+          input: { mouse: { scroll: amount, dx: axis === 'horizontal' ? amount : 0,
+            dy: axis === 'vertical' ? amount : 0 } } });
+        const result = await performAction('scroll', {
+          x: pointer.x, y: pointer.y, amount, ...(axis === 'horizontal' ? { axis } : {}),
+          ...(attachedTarget && attachedTarget.windowId ? { windowId: attachedTarget.windowId } : {}),
+        });
+        return JSON.stringify(await actionOutcome('computer_scroll', result, {
+          pointer, baseline, verify, extra: { amount, axis },
+        }));
+      },
+    },
+    {
+      name: 'computer_click',
+      description: 'Fallback a coordinate: fa click usando esclusivamente lo screenshot piu recente. Preferisci computer_inspect + computer_activate, che non sbagliano bersaglio se la finestra si sposta.',
+      inputSchema: { type: 'object', properties: {
+        snapshot_id: { type: 'string', description: 'snapshotId restituito da computer_snapshot.' },
+        x: { type: 'number', description: 'Coordinata X nello screenshot piu recente.' },
+        y: { type: 'number', description: 'Coordinata Y nello screenshot piu recente.' },
+        button: { type: 'string', description: 'left, right oppure middle' },
+        clicks: { type: 'number', description: '1, 2 oppure 3' },
+        verify: { type: 'string', enum: ['delta', 'none'] },
+      }, required: ['snapshot_id', 'x', 'y'] },
+      handler: async (input, ctx) => {
+        const coordinates = snapshotPointer(input);
+        if (coordinates.error) return JSON.stringify(coordinates.error);
+        const pointer = coordinates.pointer;
+        const button = String(input && input.button || 'left').toLowerCase();
+        const clicks = integer(input && input.clicks, 1, 3, 1);
+        const allowed = await authorized(ctx, `Click ${button} a ${pointer.x},${pointer.y}`);
+        if (!allowed) return JSON.stringify(denied('Azione sul computer'));
+        const verify = wantsVerification(input);
+        const baseline = baselineFor(verify);
+        stateEvent({ type: 'action', phase: 'start', action: 'computer_click', attached: attachedTarget, pointer,
+          input: { mouse: { button, clicks } } });
+        const result = await performAction('click', {
+          ...pointer,
+          ...(button !== 'left' ? { button } : {}),
+          ...(clicks > 1 ? { clicks } : {}),
+          ...(attachedTarget && attachedTarget.windowId ? { windowId: attachedTarget.windowId } : {}),
+        });
+        return JSON.stringify(await actionOutcome('computer_click', result, { pointer, baseline, verify }));
+      },
+    },
+    {
+      name: 'computer_drag',
+      description: 'Trascina il puntatore da un punto a un altro: slider, riordino, selezione, ridimensionamento. Accetta target_id di partenza e arrivo da computer_inspect, oppure coordinate dell ultimo snapshot. Il movimento e interpolato, cosi i controlli che ignorano un salto secco lo vedono.',
+      inputSchema: { type: 'object', properties: {
+        from_target_id: { type: 'string' }, to_target_id: { type: 'string' },
+        snapshot_id: { type: 'string' },
+        x: { type: 'number' }, y: { type: 'number' },
+        to_x: { type: 'number' }, to_y: { type: 'number' },
+        verify: { type: 'string', enum: ['delta', 'none'] },
+      } },
+      handler: async (input, ctx) => {
+        const point = async (targetId, coordX, coordY) => {
+          if (targetId) {
+            const target = await resolveTarget(targetId);
+            return target ? pointerFor(target) : null;
+          }
+          const coordinates = snapshotPointer({ ...(input || {}), x: coordX, y: coordY });
+          return coordinates.error ? null : coordinates.pointer;
+        };
+        const from = await point(String(input && input.from_target_id || ''), input && input.x, input && input.y);
+        const to = await point(String(input && input.to_target_id || ''), input && input.to_x, input && input.to_y);
+        if (!from || !to) {
+          return JSON.stringify(fail('BAD_INPUT', 'Servono un punto di partenza e uno di arrivo validi.',
+            ['computer_inspect per ottenere i target', 'computer_snapshot se usi le coordinate']));
+        }
+        const allowed = await authorized(ctx, `Trascina da ${from.x},${from.y} a ${to.x},${to.y}`);
+        if (!allowed) return JSON.stringify(denied('Azione sul computer'));
+        const verify = wantsVerification(input);
+        const baseline = baselineFor(verify);
+        stateEvent({ type: 'action', phase: 'start', action: 'computer_drag', attached: attachedTarget, pointer: from,
+          input: { mouse: { drag: true, dx: to.x - from.x, dy: to.y - from.y } } });
+        const result = await performAction('drag', {
+          x: from.x, y: from.y, toX: to.x, toY: to.y,
+          ...(attachedTarget && attachedTarget.windowId ? { windowId: attachedTarget.windowId } : {}),
+        });
+        return JSON.stringify(await actionOutcome('computer_drag', result, {
+          pointer: to, baseline, verify, extra: { from, to },
+        }));
+      },
+    },
+    {
+      name: 'computer_type',
+      description: 'Fallback: digita testo nella finestra ATTIVA senza passare da un campo identificato. Preferisci computer_fill. I testi lunghi passano dagli appunti. Non usarlo mai per password o segreti.',
+      inputSchema: { type: 'object', properties: {
+        text: { type: 'string' },
+        submit: { type: 'boolean', description: 'Premi Invio dopo la digitazione.' },
+        verify: { type: 'string', enum: ['delta', 'none'] },
+      }, required: ['text'] },
+      handler: async (input, ctx) => {
+        const text = String(input && input.text || '').slice(0, MAX_TEXT);
+        if (!text) return JSON.stringify(fail('BAD_INPUT', 'Testo mancante.', ['Passa text con il contenuto da digitare']));
+        const allowed = await authorized(ctx, `Digita ${text.length} caratteri nella finestra attiva${input && input.submit === true ? ' e premi Invio' : ''}`);
+        if (!allowed) return JSON.stringify(denied('Azione sul computer'));
+        const verify = wantsVerification(input);
+        const baseline = baselineFor(verify);
+        stateEvent({ type: 'action', phase: 'start', action: 'computer_type', attached: attachedTarget,
+          input: { keyboard: { characterCount: text.length,
+            ...(input && input.submit === true ? { keys: ['Enter'] } : {}) } } });
+        const result = await performAction('type', {
+          text, submit: input && input.submit === true,
+          ...(attachedTarget && attachedTarget.windowId ? { windowId: attachedTarget.windowId } : {}),
+        });
+        return JSON.stringify(await actionOutcome('computer_type', result, {
+          baseline, verify, extra: { characterCount: text.length },
+        }));
+      },
+    },
+    {
+      name: 'computer_wait',
+      description: 'Attende. Senza condizione e una pausa fissa; con for_text o for_title attende che un controllo o un titolo COMPAIA (o scompaia con absent) e restituisce subito i target trovati, senza un giro di computer_inspect. Preferisci sempre la condizione alla pausa cieca. In una sequenza inserisci wait direttamente in computer_batch.',
+      inputSchema: { type: 'object', properties: {
+        ms: { type: 'number', description: 'Pausa fissa in millisecondi (100-10000).' },
+        for_text: { type: 'string', description: 'Nome o valore del controllo atteso nella finestra collegata.' },
+        for_title: { type: 'string', description: 'Parte del titolo atteso nella finestra collegata.' },
+        absent: { type: 'boolean', description: 'Attende che la condizione NON sia piu vera, ad esempio uno spinner che scompare.' },
+        timeout_ms: { type: 'number', description: 'Tempo massimo di attesa della condizione (500-20000, default 8000).' },
+      } },
+      handler: async (input, ctx) => {
+        const forText = String(input && input.for_text || '').trim().slice(0, 160);
+        const forTitle = String(input && input.for_title || '').trim().slice(0, 160);
+        const pause = (ms) => new Promise((resolve) => {
+          const timer = setTimeout(resolve, ms);
+          if (ctx && ctx.signal) ctx.signal.addEventListener('abort', () => { clearTimeout(timer); resolve(); }, { once: true });
+        });
+        if (!forText && !forTitle) {
+          const ms = integer(input && input.ms, 100, MAX_WAIT_MS, 1000);
+          await pause(ms);
+          return JSON.stringify(ok(`Attesa di ${ms} ms completata.`, { waitedMs: ms },
+            ['computer_inspect per leggere lo stato aggiornato']));
+        }
+        const absent = input && input.absent === true;
+        const timeoutMs = integer(input && input.timeout_ms, 500, MAX_CONDITION_WAIT_MS, 8000);
+        const startedAt = Date.now();
+        let attempts = 0;
+        while (Date.now() - startedAt < timeoutMs && !(ctx && ctx.signal && ctx.signal.aborted)) {
+          attempts += 1;
+          if (forTitle) {
+            const alive = await refreshAttached();
+            const title = alive && attachedTarget ? String(attachedTarget.title || '') : '';
+            if ((alive && title.toLocaleLowerCase().includes(forTitle.toLocaleLowerCase())) !== absent) {
+              return JSON.stringify(ok(absent ? `Il titolo non contiene piu "${forTitle}".` : `Il titolo contiene "${forTitle}".`,
+                { waitedMs: Date.now() - startedAt, attempts, title },
+                ['computer_inspect per i controlli disponibili adesso']));
+            }
+          }
+          if (forText) {
+            const selection = filterElements(await readTree({ force: true, includeText: true }),
+              { query: forText, limit: 8 });
+            if ((selection.rows.length > 0) !== absent) {
+              return JSON.stringify(ok(absent
+                ? `"${forText}" non e piu presente nella finestra.`
+                : `"${forText}" e comparso: ${selection.rows.length} controlli corrispondono.`,
+              {
+                waitedMs: Date.now() - startedAt, attempts,
+                trust: 'UNTRUSTED_DESKTOP_DATA',
+                targetCount: selection.rows.length,
+                ...(selection.rows.length ? { targets: selection.rows.map(compactElement) } : {}),
+              },
+              selection.rows.length
+                ? ['computer_activate o computer_fill con il target_id trovato']
+                : ['Prosegui con il passo successivo']));
+            }
+          }
+          await pause(650);
+        }
+        return JSON.stringify(fail('TIMEOUT',
+          absent ? `"${forText || forTitle}" e ancora presente dopo ${timeoutMs} ms.`
+            : `"${forText || forTitle}" non e comparso entro ${timeoutMs} ms.`,
+          ['computer_inspect senza query per capire in che stato e la finestra',
+            'computer_snapshot con include_image true se il contenuto e solo visuale'],
+          { waitedMs: Date.now() - startedAt, attempts }));
+      },
+    },
+    {
+      name: 'computer_reactive_goal',
+      direct: true,
+      _meta: { [EXTENSION_ID]: SERVER_CAPABILITIES },
+      description: 'Assegna un solo obiettivo completo al controller visuale full-duplex di Horizon. E il percorso operativo obbligatorio: il controller riceve frame a 5 Hz e produce azioni incrementali fino a goal_complete, senza una nuova tool call per ogni movimento. Richiede prima computer_attach. Se il controller non e raggiungibile, fermati e segnala RAC_CONTROLLER_REQUIRED: non usare computer_control, computer_batch, inspect o screenshot come sostituti.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          goal: { type: 'string', minLength: 1, maxLength: 12000,
+            description: 'Obiettivo operativo chiaro, senza istruzioni motorie o observationId.' },
+        },
+        required: ['goal'],
+        additionalProperties: false,
+      },
+      handler: async (input, ctx) => {
+        if (!reactiveFastLane) {
+          return JSON.stringify(fail('RAC_CONTROLLER_REQUIRED', 'Il controller visuale full-duplex non e configurato.',
+            ['Configura e avvia VASCEND_RAC_CONTROLLER_URL, poi ripeti computer_reactive_goal']));
+        }
+        if (!attachedTarget) {
+          return JSON.stringify(fail('NO_ATTACHED_WINDOW', 'Collega prima la finestra da controllare.',
+            ['computer_processes e computer_attach']));
+        }
+        const allowed = await authorized(ctx, 'Avvia il controllo visuale reattivo sulla finestra collegata');
+        if (!allowed) return JSON.stringify(denied('Controllo visuale reattivo'));
+        const goal = String(input && input.goal || '').trim();
+        if (!goal) return JSON.stringify(fail('RAC_GOAL_REQUIRED', 'Serve un obiettivo operativo non vuoto.'));
+        const connection = typeof reactiveFastLane.waitUntilConnected === 'function'
+          ? await reactiveFastLane.waitUntilConnected()
+          : await reactiveFastLane.start();
+        const connectedState = reactiveFastLane.state();
+        const connectionReady = connection && connection.ok === true
+          || connectedState.controller && connectedState.controller.connected === true;
+        const armed = connectionReady
+          ? await reactiveFastLane.arm()
+          : { ok: false, code: 'RAC_CONTROLLER_REQUIRED' };
+        const state = reactiveFastLane.state();
+        if (state.controller && state.controller.connected && typeof reactiveFastLane.runGoal === 'function') {
+          const outcome = await reactiveFastLane.runGoal(goal, {
+            attached: publicTarget(attachedTarget), signal: ctx && ctx.signal,
+          });
+          return JSON.stringify((outcome.ok ? ok : warn)(
+            outcome.ok ? 'Obiettivo completato dal controller visuale.' : 'Il controller visuale ha interrotto l obiettivo.',
+            { goal, armed, outcome, fastLane: reactiveFastLane.state() },
+          ));
+        }
+        return JSON.stringify(fail('RAC_CONTROLLER_REQUIRED',
+          'Il controller visuale full-duplex non e raggiungibile; nessuna azione legacy e stata eseguita.',
+          ['Avvia il controller configurato', 'computer_reactive_status per verificare la connessione',
+            'Ripeti computer_reactive_goal quando connected=true'],
+          { goalAccepted: false, armed, connection, fastLane: state }));
+      },
+    },
+    {
+      name: 'computer_reactive_status',
+      direct: true,
+      description: 'Restituisce connessione, pump osservazioni, memoria breve e p50/p95 del controller full-duplex senza modificare il desktop.',
+      inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+      handler: async () => {
+        if (!reactiveFastLane) return JSON.stringify(fail('RAC_CONTROLLER_REQUIRED',
+          'Fast lane non configurato.',
+          ['Configura VASCEND_RAC_CONTROLLER_URL per il ciclo visuale full-duplex.'],
+          { fastLane: null }));
+        const fastLane = reactiveFastLane.state();
+        if (!fastLane.controller || fastLane.controller.connected !== true) {
+          return JSON.stringify(fail('RAC_CONTROLLER_REQUIRED',
+            'Il runtime RAC e caricato, ma il controller visuale non e collegato.',
+            ['Avvia il controller indicato da fastLane.controller.url',
+              'Ripeti computer_reactive_status finche connected=true'],
+            { fastLane }));
+        }
+        return JSON.stringify(ok('Controller full-duplex collegato.', { fastLane }));
+      },
+    },
+    {
+      name: 'computer_control_reset',
+      direct: true,
+      description: 'Riattiva il canale MCP-RAC sulla finestra gia collegata, rilascia ogni input residuo e restituisce un observationId fresco. Usalo dopo RAC_STOPPED; non serve fare detach/attach.',
+      inputSchema: { type: 'object', properties: {} },
+      handler: async (_input, ctx) => {
+        if (!attachedTarget) {
+          return JSON.stringify(fail('NO_ATTACHED_WINDOW', 'Nessuna finestra collegata da riarmare.',
+            ['computer_processes e computer_attach']));
+        }
+        const allowed = await authorized(ctx, 'Riattiva MCP-RAC sulla finestra collegata');
+        if (!allowed) return JSON.stringify(denied('Riarmo MCP-RAC'));
+        if (reactiveToolStream) await reactiveToolStream.discard('explicit_rearm');
+        const frame = await rearmReactiveTarget('computer_control_reset');
+        if (!frame) {
+          return JSON.stringify(fail('RAC_REARM_FAILED', 'Il target resta collegato, ma non e stato possibile creare un nuovo keyframe RAC.',
+            racStrictMode
+              ? ['Riprova computer_control_reset; se fallisce segnala RAC_REARM_FAILED']
+              : ['computer_inspect e computer_batch come fallback UI Automation'],
+            { attached: publicTarget(attachedTarget), racObservationError: lastObservationError }));
+        }
+        const structuredContent = ok('MCP-RAC riattivato con una nuova osservazione autorevole.', {
+          attached: publicTarget(attachedTarget), observationId: frame.observation.observationId, rearmed: true,
+        }, ['Continua con computer_control usando observationId.']);
+        return {
+          output: JSON.stringify(structuredContent), structuredContent,
+          _meta: { 'vascend/computer-use': { image: {
+            type: 'image', mimeType: 'image/png', data: String(frame.shot.data),
+          } } },
+          media: [{ mime: 'image/png', data: String(frame.shot.data), source: 'computer-control-rearm' }],
+        };
+      },
+    },
+    {
+      name: 'computer_control',
+      direct: true,
+      _meta: { [EXTENSION_ID]: SERVER_CAPABILITIES },
+      description: 'Canale MCP-RAC model-native primario per vera tastiera e mouse Windows. Per digitare o sostituire testo usa SEMPRE operations, in una sola chiamata: `[{"type":"shortcut","keys":["Ctrl","A"]},{"type":"text","text":"We are ready very soon"}]`. Il runtime esegue Ctrl+A e poi scrive l intera stringa come eventi Unicode nativi: non compilare lettere in keyset e non fare correzioni a tentativi. Per muovere o cliccare usa operations di tipo mouse (`dx`, `dy`, `scroll`) e click (`button`: left/right/middle). Usa command soltanto per traiettorie motorie reattive a 30 Hz. Formato command: ACTION <observationId_corrente> ttl=250, newline, <dx> <dy> <scroll> ; <K1> ; <K2> ; <K3> ; <K4> ; <K5> ; <K6> ;, newline, END. Ogni K e lo stato fisico completo per 33 ms: ripeti W nei K consecutivi per mantenerla premuta; aggiungi Ctrl nello stesso K per Ctrl+W; ometti un tasto per rilasciarlo e usa _ per rilasciarli tutti. Il movimento mouse viene distribuito sugli stessi sei K ed e quindi simultaneo ai tasti. Mouse ±1000, scroll ±5; token case-sensitive A-Z, 0-9, Shift, Ctrl, Alt, Space, Tab, Esc, LB, RB, MB e _. Le combinazioni usano spazi, mai +. Il risultato include il frame successivo. Se retryable=false o circuitOpen=true fermati: non ripetere, non fare reset e non acquisire altri screenshot.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          command: {
+            type: 'string',
+            description: 'Uno o piu blocchi MCP-RAC consecutivi. Ogni blocco inizia con ACTION, contiene esattamente mouse + sei keyset delimitati da ; e termina con END.',
+          },
+          operations: {
+            type: 'array', minItems: 1, maxItems: 12,
+            description: 'Percorso preferito per input discreti. Mantiene l ordine: per sostituire testo usa shortcut Ctrl+A seguito da text nella stessa chiamata.',
+            items: {
+              type: 'object',
+              properties: {
+                type: { type: 'string', enum: ['shortcut', 'text', 'mouse', 'click'] },
+                keys: { type: 'array', minItems: 1, maxItems: 4, items: { type: 'string' } },
+                text: { type: 'string', minLength: 1, maxLength: 4000 },
+                dx: { type: 'integer', minimum: -1000, maximum: 1000 },
+                dy: { type: 'integer', minimum: -1000, maximum: 1000 },
+                scroll: { type: 'integer', minimum: -5, maximum: 5 },
+                button: { type: 'string', enum: ['left', 'right', 'middle'] },
+              },
+              required: ['type'],
+              additionalProperties: false,
+            },
+          },
+        },
+        additionalProperties: false,
+      },
+      handler: async (input, ctx) => Array.isArray(input && input.operations)
+        ? executeRacAtomicInput(input.operations, ctx)
+        : executeRacCommand(input && input.command, ctx, 'computer_control'),
+    },
+    {
+      name: 'computer_batch',
+      direct: true,
+      _meta: { [EXTENSION_ID]: SERVER_CAPABILITIES },
+      description: 'Fallback Computer Use per sequenze UI Automation quando computer_reactive_goal e computer_control non possono completare una azione. Per due o piu azioni usa steps. Il campo legacy reactive_stream resta compatibile ma non e il percorso predefinito: usa esclusivamente l observationId autorevole restituito dall ultimo computer_attach, computer_snapshot o computer_inspect; non inventarlo. Il runtime lo esegue incrementalmente mentre si formano gli argomenti nativi della tool call. Grammatica esatta: ACTION <observationId_corrente> ttl=250\\n<dx> <dy> <scroll> ; <keyset> ; <keyset> ; <keyset> ; <keyset> ; <keyset> ; <keyset> ;\\nEND. Un keyset vuoto e _, i token ammessi sono A-Z, 0-9, Shift, Ctrl, Alt, Space, Tab, Esc. Richiede prima computer_attach. Massimo 12 steps e 20 secondi di attese.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          reactive_stream: {
+            type: 'string',
+            description: 'Canale RAC interno e incrementale. Se presente deve essere la prima e unica proprieta della tool call e rispettare esattamente la grammatica descritta dal tool.',
+          },
+          steps: {
+            type: 'array', minItems: 1, maxItems: MAX_BATCH_STEPS,
+            items: {
+              type: 'object',
+              properties: {
+                action: { type: 'string', enum: ['activate', 'fill', 'click', 'type', 'key', 'scroll', 'wait'] },
+                target_id: { type: 'string', description: 'Target UIA corrente, necessario per activate, fill e scroll.' },
+                mode: { type: 'string', enum: ['invoke', 'toggle', 'select', 'expand', 'collapse', 'focus', 'click'],
+                  description: 'Per activate: come agire sul controllo. Default invoke, che su un campo di testo diventa click.' },
+                snapshot_id: { type: 'string', description: 'Snapshot corrente, necessario per click visuale senza target UIA.' },
+                x: { type: 'number', description: 'X nello snapshot per click visuale.' },
+                y: { type: 'number', description: 'Y nello snapshot per click visuale.' },
+                button: { type: 'string', description: 'left, right o middle per click.' },
+                clicks: { type: 'number', description: '1, 2 o 3 per click.' },
+                text: { type: 'string', description: 'Testo non sensibile per fill o type.' },
+                submit: { type: 'boolean' },
+                clear: { type: 'boolean', description: 'Svuota il campo prima di scrivere.' },
+                keys: { type: 'array', items: { type: 'string' } },
+                amount: { type: 'number', description: 'Scorrimento: positivo sale, negativo scende.' },
+                delay_ms: { type: 'number', description: 'Attesa prima del passaggio, 0-5000 ms.' },
+              },
+              required: ['action'],
+            },
+          },
+          stop_on_error: { type: 'boolean', description: 'Interrompe la sequenza al primo errore; predefinito true.' },
+        },
+      },
+      handler: async (input, ctx) => {
+        const reactiveStream = String(input && input.reactive_stream || '');
+        if (reactiveStream) {
+          return executeRacCommand(reactiveStream, ctx, 'computer_batch');
+        }
+        if (reactiveToolStream) await reactiveToolStream.discard('normal_computer_batch');
+        const rawSteps = Array.isArray(input && input.steps) ? input.steps : [];
+        if (!rawSteps.length || rawSteps.length > MAX_BATCH_STEPS) {
+          return JSON.stringify(fail('BAD_INPUT', `La sequenza deve contenere da 1 a ${MAX_BATCH_STEPS} passaggi.`,
+            ['Spezza il piano in piu chiamate computer_batch']));
+        }
+        const supported = new Set(['activate', 'fill', 'click', 'type', 'key', 'scroll', 'wait']);
+        const needsTarget = new Set(['activate', 'fill', 'scroll']);
+        const steps = rawSteps.map((raw) => ({
+          action: String(raw && raw.action || '').trim().toLocaleLowerCase(),
+          targetId: String(raw && raw.target_id || '').trim(),
+          snapshotId: String(raw && raw.snapshot_id || '').trim(),
+          x: Number(raw && raw.x),
+          y: Number(raw && raw.y),
+          button: String(raw && raw.button || 'left').toLocaleLowerCase(),
+          clicks: integer(raw && raw.clicks, 1, 3, 1),
+          text: String(raw && raw.text || ''),
+          submit: raw && raw.submit === true,
+          clear: raw && raw.clear === true,
+          mode: String(raw && raw.mode || '').toLocaleLowerCase(),
+          keys: Array.isArray(raw && raw.keys) ? raw.keys.map((key) => String(key)).slice(0, 6) : [],
+          amount: integer(raw && raw.amount, -12000, 12000, -600),
+          delayMs: integer(raw && raw.delay_ms, 0, 5000, 0),
+        }));
+        if (steps.some((step) => !supported.has(step.action))) {
+          return JSON.stringify(fail('BAD_INPUT', 'La sequenza contiene una azione non supportata.',
+            ['Usa solo activate, fill, click, type, key, scroll o wait']));
+        }
+        if (steps.some((step) => needsTarget.has(step.action) && !step.targetId)) {
+          return JSON.stringify(fail('BAD_INPUT', 'Ogni passaggio activate/fill/scroll richiede un target_id da computer_inspect.',
+            ['computer_inspect per ottenere i target, poi riprova la sequenza']));
+        }
+        if (steps.some((step) => ['fill', 'type'].includes(step.action) && (!step.text || step.text.length > MAX_TEXT))) {
+          return JSON.stringify(fail('BAD_INPUT', `Ogni testo deve contenere da 1 a ${MAX_TEXT} caratteri.`,
+            ['Correggi il passaggio fill/type']));
+        }
+        const visualPointers = new Map();
+        for (let index = 0; index < steps.length; index += 1) {
+          const step = steps[index];
+          if (step.action !== 'click') continue;
+          const coordinates = snapshotPointer({ snapshot_id: step.snapshotId, x: step.x, y: step.y });
+          if (coordinates.error) return JSON.stringify(coordinates.error);
+          visualPointers.set(index, coordinates.pointer);
+        }
+        if (steps.some((step) => step.action === 'key' && !keyChords(step.keys).length)) {
+          return JSON.stringify(fail('BAD_INPUT', 'La sequenza contiene una scorciatoia non valida.',
+            ['Usa nomi di tasti riconosciuti']));
+        }
+        const totalDelayMs = steps.reduce((sum, step) => sum + step.delayMs, 0);
+        if (totalDelayMs > MAX_BATCH_DELAY_MS) {
+          return JSON.stringify(fail('BAD_INPUT', `Le attese programmate non possono superare ${MAX_BATCH_DELAY_MS / 1000} secondi complessivi.`,
+            ['Riduci i delay_ms o spezza la sequenza']));
+        }
+        const allowed = await authorized(ctx, `Esegui una sequenza programmata di ${steps.length} passaggi sul computer`);
+        if (!allowed) return JSON.stringify(denied('Sequenza Computer Use'));
+
+        const baseline = attachedTarget && treeCache ? treeCache.rows : null;
+        const batchTargets = await resolveTargets(steps.map((step) => step.targetId).filter(Boolean));
+        const batchId = 'batch-' + crypto.randomUUID();
+        const stopOnError = !(input && input.stop_on_error === false);
+        stateEvent({ type: 'batch', phase: 'planned', batchId, stepCount: steps.length,
+          attached: attachedTarget,
+          steps: steps.map((step, index) => ({
+            index: index + 1,
+            action: 'computer_' + step.action,
+            ...(step.targetId ? { targetId: step.targetId } : {}),
+            ...(['fill', 'type'].includes(step.action) ? { characterCount: step.text.length, submit: step.submit } : {}),
+            ...(step.action === 'click' ? { pointer: visualPointers.get(index), button: step.button, clicks: step.clicks } : {}),
+            ...(step.action === 'key' ? { keys: step.keys } : {}),
+            ...(step.action === 'scroll' ? { amount: step.amount } : {}),
+            ...(step.delayMs ? { delayMs: step.delayMs } : {}),
+          })) });
+
+        const results = [];
+        let aborted = false;
+        const waitFor = (ms) => new Promise((resolve) => {
+          if (!ms || ctx && ctx.signal && ctx.signal.aborted) { resolve(); return; }
+          const timer = setTimeout(resolve, ms);
+          if (ctx && ctx.signal) ctx.signal.addEventListener('abort', () => { clearTimeout(timer); resolve(); }, { once: true });
+        });
+
+        for (let index = 0; index < steps.length; index += 1) {
+          const step = steps[index];
+          if (ctx && ctx.signal && ctx.signal.aborted) { aborted = true; break; }
+          if (step.delayMs) {
+            stateEvent({ type: 'batch_step', phase: 'scheduled', batchId, stepIndex: index + 1,
+              stepCount: steps.length, action: 'computer_' + step.action, delayMs: step.delayMs,
+              attached: attachedTarget });
+            await waitFor(step.delayMs);
+            if (ctx && ctx.signal && ctx.signal.aborted) { aborted = true; break; }
+          }
+
+          let result = { ok: false, error: 'Passaggio non eseguito.' };
+          const target = needsTarget.has(step.action) ? batchTargets.get(step.targetId) || null : null;
+          const pointer = target ? pointerFor(target) : visualPointers.get(index) || null;
+          stateEvent({ type: 'batch_step', phase: 'start', batchId, stepIndex: index + 1,
+            stepCount: steps.length, action: 'computer_' + step.action,
+            ...(pointer ? { pointer } : {}), attached: attachedTarget });
+
+          if (needsTarget.has(step.action) && (!target || !target.enabled)) {
+            result = { ok: false, error: 'Il controllo non e piu disponibile o abilitato.' };
+          } else if (step.action === 'fill' && target.isPassword) {
+            result = { ok: false, error: 'Computer Use non compila password o campi segreti in una sequenza.' };
+          } else if (step.action === 'activate') {
+            // Il mode chiesto dal modello va RISPETTATO, e su un campo di testo
+            // il default diventa un click: il batch continuava a usare
+            // ExpandCollapse, quindi apriva e poi RICHIUDEVA il pannello di
+            // ricerca mentre la ricevuta diceva "activate ok".
+            const mode = activateMode(target, step.mode);
+            result = uiAction && mode !== 'click'
+              ? await nativeOrPointer(target, pointer, { action: mode }, (spot) => clickAt(spot))
+              : await clickAt(pointer);
+          } else if (step.action === 'fill') {
+            const fillRequest = { text: step.text, clear: step.clear, submit: step.submit };
+            result = uiAction
+              ? await nativeOrPointer(target, pointer, {
+                action: step.text.length > PASTE_THRESHOLD ? 'paste' : 'type',
+                value: step.text, clear: step.clear, submit: step.submit,
+              }, (spot) => fillAt(spot, fillRequest))
+              : await fillAt(pointer, fillRequest);
+            // Anche in sequenza una scrittura va confermata: "5 di 5 completati"
+            // con il campo invariato e' la ricevuta che ha fatto girare a vuoto
+            // interi giri di verifiche.
+            if (result && result.ok === true && (await textLanded(target, step.text)) === false) {
+              const retry = pointer ? await fillAt(pointer, fillRequest) : null;
+              const landed = retry && retry.ok === true ? await textLanded(target, step.text) : false;
+              result = landed === false
+                ? { ok: false, code: 'NO_TEXT_WRITTEN', error: 'Il campo non ha ricevuto il testo.' }
+                : { ...(retry || result), method: 'Click+Type' };
+            }
+          } else if (step.action === 'click') {
+            result = await clickAt(pointer, { button: step.button, clicks: step.clicks });
+          } else if (step.action === 'type') {
+            result = await performAction('type', {
+              text: step.text, submit: step.submit,
+              ...(attachedTarget && attachedTarget.windowId ? { windowId: attachedTarget.windowId } : {}),
+            });
+          } else if (step.action === 'scroll') {
+            result = await performAction('scroll', {
+              x: pointer.x, y: pointer.y, amount: step.amount,
+              ...(attachedTarget && attachedTarget.windowId ? { windowId: attachedTarget.windowId } : {}),
+            });
+          } else if (step.action === 'key') {
+            result = await performAction('key', {
+              keys: step.keys,
+              ...(attachedTarget && attachedTarget.windowId ? { windowId: attachedTarget.windowId } : {}),
+            });
+          } else if (step.action === 'wait') {
+            result = { ok: true, waitedMs: step.delayMs };
+          }
+
+          const stepOk = !!(result && result.ok === true);
+          const receipt = { index: index + 1, action: 'computer_' + step.action, ok: stepOk,
+            ...(stepOk && result.method ? { method: result.method } : {}),
+            ...(stepOk ? {} : { error: String(result && result.error || 'Passaggio non riuscito.') }) };
+          results.push(receipt);
+          stateEvent({ type: 'batch_step', phase: stepOk ? 'complete' : 'error', batchId,
+            stepIndex: index + 1, stepCount: steps.length, action: receipt.action,
+            ...(pointer ? { pointer } : {}), attached: attachedTarget,
+            ...(stepOk ? {} : { error: receipt.error }) });
+          if (!stepOk && stopOnError) break;
+        }
+
+        // Le coordinate erano tutte ancorate allo stesso snapshot e sono state
+        // validate prima di iniziare: invalidiamo solo al termine del batch.
+        lastSnapshot = null;
+
+        const errorCount = results.filter((result) => !result.ok).length;
+        const completedCount = results.filter((result) => result.ok).length;
+        stateEvent({ type: 'batch', phase: aborted ? 'aborted' : errorCount ? 'error' : 'complete',
+          batchId, stepCount: steps.length, completedCount, errorCount, attached: attachedTarget });
+        const checked = await verification(baseline, aborted ? 'none' : 'delta');
+        const payload = {
+          batchId, aborted, stepCount: steps.length, completedCount, errorCount, steps: results, ...checked,
+          note: checked.verified
+            ? 'Esito verificato rileggendo i controlli: nessuno screenshot necessario.'
+            : 'Sequenza terminata. Se serve una verifica, usa una sola computer_inspect finale; evita screenshot intermedi.',
+        };
+        const summary = checked.verified
+          ? `${completedCount} di ${steps.length} passaggi eseguiti: ${checked.observation}.`
+          : `${completedCount} di ${steps.length} passaggi eseguiti, risultato finale non confermato.`;
+        if (!aborted && errorCount === 0) {
+          const envelope = checked.verified ? ok : warn;
+          return JSON.stringify(envelope(summary, payload,
+            checked.verified ? [] : [
+              'computer_inspect per confermare lo stato finale',
+              'Non dichiarare completato il compito finche la postcondizione non e visibile',
+            ]));
+        }
+        return JSON.stringify(fail(aborted ? 'ABORTED' : 'STEP_FAILED', summary,
+          ['computer_inspect per rileggere i controlli e ripartire dal passaggio non riuscito'], payload));
+      },
+    },
+  ];
+
+  // Vecchie sessioni possono ricordare il nome iniziale del tool. L'alias evita
+  // una tool call fallita, ma indirizza chiaramente i nuovi piani al nome
+  // canonico computer_snapshot.
+  const snapshotTool = tools.find((tool) => tool.name === 'computer_snapshot');
+  if (snapshotTool) tools.push({
+    ...snapshotTool,
+    name: 'computer_screenshot',
+    description: 'Alias di compatibilita per computer_snapshot. Preferisci computer_snapshot nei nuovi piani.',
+  });
+
+  // Nelle superfici Horizon migrate il modello non puo ricadere per inerzia
+  // nel protocollo precedente. Il fallback puo essere riabilitato soltanto
+  // dall'operatore con VASCEND_RAC_LEGACY_FALLBACK=1.
+  const strictAllowed = new Set([
+    'computer_processes', 'computer_launch', 'computer_attach', 'computer_open_path',
+    'computer_detach', 'computer_control', 'computer_control_reset',
+  ]);
+  if (externalControllerEnabled) {
+    strictAllowed.add('computer_reactive_goal');
+    strictAllowed.add('computer_reactive_status');
+  }
+  const exposedTools = allowLegacyRac ? tools : tools.filter((tool) => strictAllowed.has(tool.name));
+  /* Nessuna superficie `ui`: Computer Use NON apre piu' una scheda Anteprima.
+     Il lavoro si segue dove sta il resto del run — la riga viva nella tendina
+     delle tool call — invece che in un pannello a fianco che nel caso peggiore
+     restava fermo su "In preparazione". */
+  return exposedTools.map((tool) => ({
+    ...tool,
+    ...(tool._meta && typeof tool._meta === 'object' ? { _meta: tool._meta } : {}),
+    annotations: {
+      ...(tool.annotations && typeof tool.annotations === 'object' ? tool.annotations : {}),
+      openWorldHint: true,
+    },
+  }));
+}
+
+module.exports = {
+  VK: Native.VK,
+  MAX_TEXT,
+  MAX_BATCH_STEPS,
+  MAX_BATCH_DELAY_MS,
+  keyCodes,
+  keyChords,
+  runPowerShell: Native.runPowerShell,
+  defaultAction: Native.defaultAction,
+  defaultWindows: Native.defaultWindows,
+  defaultProcesses: Native.defaultProcesses,
+  defaultUiElements: Native.defaultUiElements,
+  defaultUiAction: Native.defaultUiAction,
+  defaultLaunch: Native.defaultLaunch,
+  computerUseTools,
+};