talos-code 0.0.1 → 0.1.0

package/vendor/harness-ui/src/modifica-ancorata.mjs

@@ -0,0 +1,177 @@
+/*
+ * ⛔⛔⛔ PO-12 — L'ATTREZZO DI MODIFICA. Owner, 09/09/2026: «oltre alle modifiche file da terminale,
+ * dare al modello un tool di edit esattamente come Claude Code da CLI, e praticamente come fanno
+ * tutti gli altri». Approvato il 10/09 al posto della via A di D3, per la ragione scritta più sotto.
+ *
+ * IL PROBLEMA, misurato nel nostro kernel: l'unico attrezzo di scrittura è `scrivi`, che si dichiara
+ * al modello così, verbatim: «Writes one file of the workspace, **replacing it entirely**. Read it
+ * first: the whole content is required.» Quindi per cambiare una riga in un file di 2.000 il modello
+ * ne rigenera 2.000, in uscita, dove i token costano di più; e il resto del file passa dalla sua
+ * memoria invece che dal disco.
+ * ⛔ E c'è la seconda metà, che è la ragione per cui questo pezzo viene PRIMA della prenotazione dei
+ *   file (D3-A): con una riscrittura totale, due sotto-agenti che toccano lo stesso file si
+ *   cancellano a vicenda PER COSTRUZIONE. Con una modifica ancorata al testo, la seconda fallisce da
+ *   sola — nessuna dichiarazione da chiedere al modello, nessuna buona volontà su cui contare.
+ *
+ * RICERCA 10/09/2026, prima di scrivere:
+ *  · Claude Code, attrezzo `Edit` (repovive.com; gist dell'implementazione interna): `old_string`
+ *    deve comparire **esattamente una volta**; se compare più volte l'edit è respinto come ambiguo.
+ *    La ragione, verbatim: «an ambiguous match on a common string like "return null" could corrupt
+ *    logic in the wrong function… rather than silently picking one occurrence… the tool refuses to
+ *    apply an ambiguous edit and surfaces the ambiguity back».
+ *  · Hermes Agent v0.21, `tools/fuzzy_match.py` (letto nel sorgente): stessa unicità, ma il rifiuto
+ *    ELENCA le posizioni trovate — «Found N matches… Provide more context to make it unique, or use
+ *    replace_all=True. Matches: …» — e il matching ha strati di tolleranza sugli spazi.
+ *  · Codex, `codex-rs/apply-patch/src/seek_sequence.rs` (letto nel sorgente): ⛔ NON ha nessun
+ *    controllo di ambiguità — `seek_sequence` restituisce la PRIMA occorrenza e si ferma. È il
+ *    comportamento più pericoloso dei tre, ed è quello che qui non si imita.
+ *  · morphllm.com, «Error Editing File» e arxiv 2603.05344 («Building Effective AI Coding Agents»):
+ *    cambiare SOLO l'attrezzo di modifica — senza toccare modello né prompt — ha migliorato 15 LLM
+ *    di 5-14 punti percentuali sui banchi di coding, fino a 10× sui modelli più deboli, con **~20%
+ *    di token di uscita in meno** perché smettono di bruciare giri in ritentativi. E i sistemi che
+ *    funzionano meglio convergono su: strati di corrispondenza con ripieghi, messaggi d'errore
+ *    AZIONABILI, e indirizzamento che tollera gli spazi — «none of which Claude Code's Edit tool
+ *    currently implements».
+ *
+ * ⇒ Il nostro +1, che nessuno dei tre ha per intero: unicità obbligatoria (come Claude Code), il
+ *   rifiuto che dice DOVE sono le altre occorrenze (come Hermes), i ripieghi sugli spazi (come
+ *   Hermes) ma con la STRATEGIA DICHIARATA nell'esito — chi legge sa se ha corrisposto il testo
+ *   esatto o una sua versione tollerata — e mai, in nessun caso, la prima occorrenza in silenzio.
+ */
+
+/** Le strategie, dalla più severa alla più tollerante. Nessuna di esse indovina: tutte confrontano. */
+const STRATEGIE = Object.freeze([
+  { nome: 'esatta', descrizione: 'il testo combacia carattere per carattere', normalizza: (t) => t },
+  {
+    nome: 'spazi-in-coda',
+    descrizione: 'combacia ignorando gli spazi a fine riga',
+    normalizza: (t) => t.split('\n').map((r) => r.replace(/[ \t]+$/u, '')).join('\n'),
+  },
+  {
+    nome: 'rientro',
+    descrizione: 'combacia ignorando il rientro a inizio riga',
+    normalizza: (t) => t.split('\n').map((r) => r.replace(/^[ \t]+/u, '').replace(/[ \t]+$/u, '')).join('\n'),
+  },
+]);
+
+/** Riga e colonna (da 1) di un indice dentro il testo. Serve a DIRE dove, non solo quante. */
+export function posizioneDi(testo, indice) {
+  const prima = String(testo).slice(0, indice);
+  const riga = prima.split('\n').length;
+  const colonna = indice - (prima.lastIndexOf('\n') + 1) + 1;
+  return { riga, colonna };
+}
+
+/** Tutte le occorrenze di `ago` in `pagliaio`, senza sovrapposizioni. */
+function occorrenze(pagliaio, ago) {
+  const trovate = [];
+  if (!ago) return trovate;
+  let da = 0;
+  for (;;) {
+    const i = pagliaio.indexOf(ago, da);
+    if (i < 0) return trovate;
+    trovate.push(i);
+    da = i + ago.length;
+  }
+}
+
+export class ModificaError extends Error {
+  constructor(message, code, dettagli = {}) {
+    super(message);
+    this.name = 'ModificaError';
+    this.code = code;
+    Object.assign(this, dettagli);
+  }
+}
+
+/**
+ * Sostituisce `vecchio` con `nuovo` dentro `contenuto`.
+ * @returns {{contenuto:string, strategia:string, occorrenze:number, riga:number}}
+ * @throws {ModificaError} e non applica NIENTE: un file si tocca solo quando si sa dove.
+ */
+export function modificaAncorata(contenuto, vecchio, nuovo, { tutte = false } = {}) {
+  const testo = String(contenuto ?? '');
+  const cerca = String(vecchio ?? '');
+  const metti = String(nuovo ?? '');
+
+  if (cerca === '') {
+    throw new ModificaError('Il testo da sostituire è vuoto: dimmi che cosa cercare.', 'MODIFICA_VUOTA');
+  }
+  if (cerca === metti) {
+    throw new ModificaError('Il testo nuovo è identico a quello vecchio: non c\'è niente da cambiare.', 'MODIFICA_IDENTICA');
+  }
+  /*
+   * ⛔ Solo spazi: combacerebbe ovunque, e «ovunque» non è un'ancora. Hermes rifiuta lo stesso caso
+   *   («old_string is only whitespace»), e per la stessa ragione.
+   */
+  if (cerca.trim() === '') {
+    throw new ModificaError('Il testo da sostituire è fatto solo di spazi: serve qualcosa che lo distingua.', 'MODIFICA_SOLO_SPAZI');
+  }
+
+  for (const strategia of STRATEGIE) {
+    /*
+     * ⛔ Una strategia che cambia la LUNGHEZZA del testo non può dire dove sostituire nell'originale:
+     *   si cerca sul testo normalizzato solo per CONTARE, e si applica sull'originale solo quando la
+     *   normalizzazione non ha spostato niente (cioè sulla strategia esatta o quando il file non ha
+     *   spazi da normalizzare). È la stessa trappola delle citazioni elise del Context Engine.
+     */
+    const testoN = strategia.normalizza(testo);
+    const cercaN = strategia.normalizza(cerca);
+    if (cercaN === '') continue;
+    const trovate = occorrenze(testoN, cercaN);
+    if (trovate.length === 0) continue;
+
+    if (trovate.length > 1 && !tutte) {
+      const dove = trovate.slice(0, 5).map((i) => {
+        const p = posizioneDi(testoN, i);
+        return `riga ${p.riga}`;
+      });
+      throw new ModificaError(
+        `Quel testo compare ${trovate.length} volte (${dove.join(', ')}${trovate.length > 5 ? ', e altre' : ''}): `
+        + 'aggiungi qualche riga intorno per renderlo unico, oppure chiedi di sostituirle tutte.',
+        'MODIFICA_AMBIGUA',
+        { occorrenze: trovate.length, righe: trovate.map((i) => posizioneDi(testoN, i).riga) },
+      );
+    }
+    /*
+     * ⛔ `tutte` vale solo sulla corrispondenza ESATTA: sostituire ovunque basandosi su una
+     *   somiglianza è il modo più veloce di rovinare un file in molti punti insieme. Stessa guardia
+     *   di Hermes («replace_all only applies to exact matches»).
+     */
+    if (tutte && strategia.nome !== 'esatta') {
+      throw new ModificaError(
+        'Non trovo quel testo esatto, e «tutte le occorrenze» vale solo sul testo esatto: '
+        + 'rileggi il file e copia il punto com\'è.',
+        'MODIFICA_TUTTE_NON_ESATTA',
+      );
+    }
+    if (strategia.nome !== 'esatta' && testoN.length !== testo.length) {
+      throw new ModificaError(
+        `Ho trovato quel testo ${strategia.descrizione}, ma il file ha spazi che spostano le posizioni: `
+        + 'rileggilo e copia il punto com\'è, spazi compresi.',
+        'MODIFICA_POSIZIONE_INCERTA',
+        { strategia: strategia.nome },
+      );
+    }
+
+    const indice = trovate[0];
+    const risultato = tutte
+      ? testo.split(cerca).join(metti)
+      : testo.slice(0, indice) + metti + testo.slice(indice + cerca.length);
+    return {
+      contenuto: risultato,
+      strategia: strategia.nome,
+      occorrenze: tutte ? trovate.length : 1,
+      riga: posizioneDi(testo, indice).riga,
+    };
+  }
+
+  /*
+   * ⛔ Non trovato: il messaggio deve essere AZIONABILE (la ricerca del 10/09 dice che è ciò che fa
+   *   smettere i cicli di ritentativo). Si dice che cosa fare, non solo che è andata male.
+   */
+  throw new ModificaError(
+    'Non trovo quel testo nel file: rileggilo e copia il punto esatto da cambiare, con qualche riga intorno.',
+    'MODIFICA_NON_TROVATA',
+  );
+}

package/vendor/harness-ui/src/native-provider-adapter.mjs

@@ -0,0 +1,205 @@
+import { generateText, streamText, jsonSchema, stepCountIs } from 'ai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createOpenAI } from '@ai-sdk/openai';
+
+import { ID_NATIVI_SDK, fornitore } from './provider-registry.mjs';
+import { tokenDaCache, tokenScrittiInCache } from './usage-cache.mjs';
+
+// Only this adapter knows the SDK message format. The kernel owns tool execution.
+export function stripNativeMetadata(messages) {
+  return messages.map(({ talos_provider_state, ...message }) => message);
+}
+
+export function toNativeMessages(messages, { provider, model }) {
+  const toolNames = new Map(messages.flatMap(m => (m.tool_calls ?? []).map(t => [t.id, t.function.name])));
+  return messages.map(message => {
+    if (message.role === 'system' || message.role === 'developer') return { role: 'system', content: message.content };
+    if (message.role === 'tool') {
+      const toolName = toolNames.get(message.tool_call_id);
+      if (!toolName) throw new Error('Risultato di strumento senza chiamata corrispondente.');
+      return { role: 'tool', content: [{ type: 'tool-result', toolCallId: message.tool_call_id, toolName, output: { type: 'text', value: typeof message.content === 'string' ? message.content : JSON.stringify(message.content) } }] };
+    }
+    const state = message.talos_provider_state;
+    if (message.role === 'assistant' && state?.version === 1 && state.provider === provider && state.model === model && Array.isArray(state.content)) {
+      return { role: 'assistant', content: structuredClone(state.content) };
+    }
+    const content = [];
+    if (typeof message.content === 'string' && message.content) content.push({ type: 'text', text: message.content });
+    else if (Array.isArray(message.content)) for (const part of message.content) {
+      if (part.type === 'text') content.push({ type: 'text', text: part.text });
+      else if (part.type === 'image_url') {
+        // The upload resolver already verified these bytes. Never let SDK download arbitrary URLs.
+        if (!/^data:image\/(png|jpeg|webp);base64,[A-Za-z0-9+/]+=*$/u.test(part.image_url?.url ?? '')) throw new Error('Riferimento immagine non risolto o non consentito.');
+        content.push({ type: 'file', data: part.image_url.url, mediaType: part.image_url.url.slice(5, part.image_url.url.indexOf(';')) });
+      } else throw new Error(`Contenuto non supportato dal provider: ${part.type}`);
+    }
+    for (const call of message.tool_calls ?? []) content.push({ type: 'tool-call', toolCallId: call.id, toolName: call.function.name, input: JSON.parse(call.function.arguments) });
+    return { role: message.role, content };
+  });
+}
+
+/*
+ * ⛔⛔ 12/09 — P-B: QUESTO LETTORE CONOSCEVA UN NOME SOLO.
+ *
+ * `usage.inputTokenDetails?.cacheReadTokens` è il nome che l'AI SDK espone quando l'adattatore
+ * fissato nel lock mappa il campo nativo. Quando NON lo mappa — ed è ❓ non verificato che lo
+ * faccia per `cachedContentTokenCount` di Gemini (§7.8 dell'inventario) — qui usciva `undefined`,
+ * che a valle diventa zero: «non dichiarato» scritto come «nessuno», che è la lezione del 22/8.
+ *
+ * ⇒ Prima si chiede all'SDK, poi si chiede al fornitore con TUTTI i nomi che quel wire può usare
+ *   (`usage-cache.mjs`, alimentato dal record). Un nome in più non fa mai danno; uno in meno fa
+ *   sparire il 93% del costo dal pannello.
+ */
+function canonicalUsage(usage = {}, provider) {
+  // P-J — l'SDK 4.0.49 trasforma campi cache assenti in zero. Per i terzi il dato
+  // grezzo è la prova; il totale SDK include già letture e scritture, senza risommarle.
+  const terzoAnthropic = provider !== 'anthropic' && fornitore(provider)?.wire === 'anthropic-messages';
+  const dallSdk = Number.isFinite(usage.inputTokenDetails?.cacheReadTokens) ? usage.inputTokenDetails.cacheReadTokens : null;
+  const letti = terzoAnthropic ? tokenDaCache(usage.raw, provider) : dallSdk ?? tokenDaCache(usage, provider);
+  const scritti = terzoAnthropic ? tokenScrittiInCache(usage.raw, provider) : Number.isFinite(usage.inputTokenDetails?.cacheWriteTokens)
+    ? usage.inputTokenDetails.cacheWriteTokens
+    : tokenScrittiInCache(usage, provider);
+  return {
+    prompt_tokens: usage.inputTokens,
+    completion_tokens: usage.outputTokens,
+    total_tokens: usage.totalTokens,
+    prompt_tokens_details: {
+      /* ⛔ `undefined` e non `null` quando non si sa: è la forma che questo campo ha sempre avuto,
+         e i lettori a valle distinguono già «assente» da «zero». */
+      cached_tokens: letti ?? undefined,
+      ...(scritti !== null && scritti !== undefined ? { cache_write_tokens: scritti } : {}),
+    },
+    completion_tokens_details: { reasoning_tokens: usage.outputTokenDetails?.reasoningTokens },
+  };
+}
+
+function responseMessage(response, provider, model, finishReason) {
+  if (!['stop', 'tool-calls'].includes(finishReason)) {
+    // P-J — nei nuovi profili lo schermo usa il nome umano, senza codici del protocollo.
+    const record = fornitore(provider);
+    const error = new Error(provider !== 'anthropic' && record?.wire === 'anthropic-messages'
+      ? `Risposta di ${record.etichetta} incompleta. Riprova: la cronologia precedente è conservata.`
+      : `Risposta ${provider} incompleta (${finishReason}). Riprova: la cronologia precedente è conservata.`);
+    error.code = 'NATIVE_RESPONSE_INCOMPLETE';
+    throw error;
+  }
+  const assistant = response.messages.findLast(m => m.role === 'assistant');
+  const content = assistant?.content ?? [];
+  const text = content.filter(p => p.type === 'text').map(p => p.text).join('');
+  const calls = content.filter(p => p.type === 'tool-call').map(p => ({ id: p.toolCallId, type: 'function', function: { name: p.toolName, arguments: JSON.stringify(p.input) } }));
+  const reasoning = content.filter(p => p.type === 'reasoning').map(p => p.text).join('');
+  return {
+    role: 'assistant', content: text || null,
+    ...(calls.length ? { tool_calls: calls } : {}),
+    ...(reasoning ? { reasoning_content: reasoning } : {}),
+    // Incomplete signatures must never become a checkpoint for the next request.
+    ...(['stop', 'tool-calls'].includes(finishReason) ? { talos_provider_state: { version: 1, provider, model, content } } : {}),
+  };
+}
+
+export async function nativeProviderResponse({ provider, model, apiKey, baseURL, body, fetchFn = fetch, signal }) {
+  signal?.throwIfAborted();
+  /* ⛔ 12/09 — P-A: la mappa resta (un pacchetto npm non si deriva da un dato), ma il registro
+     dichiara CHI passa di qui: se le due divergono, si ferma subito invece di costruire un client
+     per un fornitore che il resto del sistema instrada altrove. Il test di parità le confronta. */
+  // P-J — INIZIO scelta del trasporto dal registro; nessun secondo client Messages.
+  const record = fornitore(provider);
+  const wireAnthropic = record?.wire === 'anthropic-messages';
+  const factory = wireAnthropic ? createAnthropic : { gemini: createGoogleGenerativeAI, openai: createOpenAI }[provider];
+  if (!factory || !ID_NATIVI_SDK.includes(provider)) throw new Error('Provider nativo non riconosciuto.');
+  if (wireAnthropic && (typeof apiKey !== 'string' || !apiKey.trim())) {
+    throw Object.assign(new Error(`Manca la chiave per ${record.etichetta}.`), { code: 'PROVIDER_KEY_MISSING' });
+  }
+  const credenziale = wireAnthropic && record.auth.tipo === 'bearer' ? { authToken: apiKey } : { apiKey };
+  const client = factory({ ...credenziale, ...(wireAnthropic ? { baseURL: baseURL || record.baseUrl } : baseURL ? { baseURL } : {}), fetch: fetchFn });
+  // P-J — FINE scelta del trasporto.
+  const languageModel = provider === 'openai' ? client.responses(model) : client.chat(model);
+  const tools = Object.fromEntries((body.tools ?? []).map(t => [t.function.name, { description: t.function.description, inputSchema: jsonSchema(t.function.parameters) }]));
+  const effort = body.reasoning_effort ?? body.reasoning?.effort;
+  const providerOptions = provider === 'openai' ? { openai: { store: false, include: ['reasoning.encrypted_content'] } } : opzioniAnthropicTerzi(provider, model, body);
+  const nativeMessages = toNativeMessages(body.messages, { provider, model });
+  // SDK common reasoning maps support/model differences in the pinned adapters.
+  const common = {
+    model: languageModel, messages: nativeMessages.filter(m => m.role !== 'system'),
+    instructions: nativeMessages.filter(m => m.role === 'system'),
+    ...(Object.keys(tools).length ? { tools } : {}),
+    ...(body.tool_choice ? { toolChoice: typeof body.tool_choice === 'string' ? body.tool_choice : { type: 'tool', toolName: body.tool_choice.function.name } } : {}),
+    ...(body.temperature != null ? { temperature: body.temperature } : {}),
+    ...(body.top_p != null ? { topP: body.top_p } : {}),
+    ...(body.stop ? { stopSequences: Array.isArray(body.stop) ? body.stop : [body.stop] } : {}),
+    ...(effort && !(wireAnthropic && provider !== 'anthropic') ? { reasoning: effort } : {}), // P-J: opzioni esplicite per i terzi.
+    maxOutputTokens: body.max_completion_tokens ?? body.max_tokens ?? 8192,
+    providerOptions, maxRetries: 0, stopWhen: stepCountIs(1), abortSignal: signal,
+    // The caller owns retries, stop, tools and traces. No telemetry or automatic downloads.
+    experimental_download: async urls => { if (urls.length) throw new Error('Download implicito di immagini non consentito.'); return []; },
+  };
+  if (!body.stream) {
+    let usageDelloStep; // P-J — evento nominato, senza dipendere dalla posizione negli array SDK.
+    const result = await generateText({ ...common, onStepFinish: step => { usageDelloStep = step.usage; } });
+    // P-J — l'aggregato perde raw anche con un solo step; lo step mantiene la misura originale.
+    const usage = wireAnthropic && provider !== 'anthropic' ? usageDelloStep : result.usage;
+    return Response.json({ choices: [{ index: 0, message: responseMessage(result.response, provider, model, result.finishReason), finish_reason: result.finishReason === 'tool-calls' ? 'tool_calls' : result.finishReason }], usage: canonicalUsage(usage, provider) });
+  }
+  const abort = new AbortController();
+  const combinedSignal = signal ? AbortSignal.any([signal, abort.signal]) : abort.signal;
+  const result = streamText({ ...common, abortSignal: combinedSignal, onError: () => {} });
+  const encoder = new TextEncoder();
+  const iterator = result.fullStream[Symbol.asyncIterator]();
+  const callIndices = new Map();
+  let completed = false;
+  let usageDelloStep; // P-J — conserva raw senza consumare due volte il flusso SDK.
+  const stream = new ReadableStream({
+    async pull(controller) {
+      const emit = (delta, extra = {}, finishReason) => controller.enqueue(encoder.encode(`data: ${JSON.stringify({ choices: [{ index: 0, delta, ...(finishReason ? { finish_reason: finishReason === 'tool-calls' ? 'tool_calls' : finishReason } : {}) }], ...extra })}\n\n`));
+      try {
+        while (!completed) {
+          const { value: part, done } = await iterator.next();
+          if (done) throw new Error('Flusso del provider interrotto prima della conclusione.');
+          if (part.type === 'error') throw part.error;
+          if (part.type === 'abort') throw new Error('Risposta annullata.');
+          if (part.type === 'text-delta') { emit({ content: part.text }); return; }
+          if (part.type === 'reasoning-delta') { emit({ reasoning_content: part.text }); return; }
+          if (part.type === 'tool-input-start') {
+            callIndices.set(part.id, callIndices.size);
+            emit({ tool_calls: [{ index: callIndices.get(part.id), id: part.id, type: 'function', function: { name: part.toolName, arguments: '' } }] }); return;
+          }
+          if (part.type === 'tool-input-delta') { emit({ tool_calls: [{ index: callIndices.get(part.id), function: { arguments: part.delta } }] }); return; }
+          if (part.type === 'tool-call' && part.invalid) throw part.error ?? new Error('Argomenti dello strumento non validi.');
+          if (part.type === 'finish-step') usageDelloStep = part.usage; // P-J
+          if (part.type === 'finish') {
+            const message = responseMessage(await result.response, provider, model, part.finishReason);
+            // P-J — una sola chiamata/step: gli aggregati scartano raw, finish-step lo conserva.
+            const usage = wireAnthropic && provider !== 'anthropic' ? usageDelloStep : part.totalUsage;
+            emit(message.talos_provider_state ? { talos_provider_state: message.talos_provider_state } : {}, { usage: canonicalUsage(usage, provider) }, part.finishReason);
+            controller.enqueue(encoder.encode('data: [DONE]\n\n')); completed = true; controller.close(); return;
+          }
+        }
+      } catch (error) { completed = true; abort.abort(); controller.error(error); }
+    },
+    async cancel() { completed = true; abort.abort(); await iterator.return?.(); },
+  });
+  return new Response(stream, { headers: { 'content-type': 'text/event-stream' } });
+}
+
+// P-J — opzioni dei nuovi profili nel medesimo SDK; nessuna traduzione HTTP proprietaria.
+function opzioniAnthropicTerzi(provider, model, body) {
+  const record = fornitore(provider);
+  if (provider === 'anthropic' || record?.wire !== 'anthropic-messages') return {};
+  const effort = body.reasoning_effort ?? body.reasoning?.effort;
+  const rifiuta = motivo => { throw Object.assign(new Error(`${record.etichetta}: ${motivo}`), { code: 'PROVIDER_REASONING_UNSUPPORTED' }); };
+  if (provider === 'zai-anthropic') {
+    if (body.reasoning?.enabled === false || (effort && !record.ragionamento.livelli.includes(effort))) rifiuta('scegli un livello di ragionamento alto o massimo.');
+    return effort || body.reasoning?.enabled === true ? { anthropic: { thinking: { type: 'adaptive' }, ...(effort ? { effort } : {}) } } : {};
+  }
+  if (provider === 'minimax-anthropic') {
+    if (body.stop) rifiuta('le sequenze di arresto non sono supportate su questa porta.');
+    if (effort) rifiuta('i livelli di intensità del ragionamento non sono documentati su questa porta.');
+    if (typeof body.reasoning?.enabled === 'boolean') {
+      if (model !== 'MiniMax-M3') rifiuta('questo modello non dichiara il controllo del ragionamento.');
+      return { anthropic: { thinking: { type: body.reasoning.enabled ? 'adaptive' : 'disabled' } } };
+    }
+  }
+  return {};
+}
+// P-J — FINE opzioni dei profili.

package/vendor/harness-ui/src/notes-store.mjs

@@ -0,0 +1,250 @@
+/**
+ * notes-store.mjs — FASE N, quarto sistema (30/8), piano
+ * `elegant-spinning-dongarra.md`. Owner: "TUTTI i 5 sistemi rimasti, uno
+ * dopo l'altro".
+ *
+ * ⛔⛔⛔ GLOBALE, non per-progetto — a differenza di Library/hook/MCP/skill/
+ * plugin (tutti dentro `.harness-ui-<cosa>/` nel workspace di UN progetto).
+ * Letto alla fonte (`mobile/src/lib/tools/notesWriteTools.ts`+`readTools.ts`,
+ * `mobile/src/persistence/chatDatabaseSchema.ts`): su mobile le note sono
+ * per-DISPOSITIVO, non per-conversazione — "prendi nota che il codice del
+ * cancello è 4471" non riguarda NESSUN progetto di codice, è un promemoria
+ * personale. Un desktop che le rendesse per-progetto le renderebbe invisibili
+ * da qualunque altra sessione — un comportamento diverso da quello mobile
+ * che questo porto deve preservare, non inventare. Storage accanto a
+ * `server.mjs`, stesso pattern REALE di `.automations/` (dati locali
+ * generati a runtime, non tracciati) — non `.hooks-trust/`/`.mcp-trust/`
+ * (quelli sono fiducia, non dati).
+ *
+ * ⛔ Stessa CONVENZIONE DI CHIAMATA di `library-store.mjs`
+ * (`funzione({cartella, ...}, deps={})`, non una factory con stato
+ * chiuso come `automation-store.mjs`) — deliberato: questo modulo va
+ * agganciato negli stessi punti di contatto I/O iniettabili di
+ * `agent-service.mjs` (`elencaVociFn`/`rinominaVoceFn`/...), che si
+ * aspettano funzioni STANDALONE, non un oggetto costruito una volta.
+ * `automation-store.mjs` ha una convenzione diversa perché è agganciato
+ * altrove (rotte HTTP dirette), mai dentro il ciclo tool di `talosLavora`.
+ *
+ * ⛔ Un file JSON per nota (non un unico array): una nota corrotta a metà
+ * scrittura non trascina giù le altre, e una cancellazione è un `rm`
+ * diretto invece di riscrivere un array intero — la stessa classe di bug
+ * (riscrittura invece di accodamento) già evitata altrove in questo
+ * progetto (vedi session-store.mjs).
+ */
+import { randomUUID } from 'node:crypto';
+import { promises as fsp } from 'node:fs';
+import { join } from 'node:path';
+import { idArchivioValido } from './id-archivio.mjs';
+
+const TITOLO_MASSIMO = 120;
+const CONTENUTO_MASSIMO = 8_000;
+
+/** ⭐ Stesso pattern REALE di `.automations/`/`.sessions-store/`: il nome che `server.mjs` userà per il percorso di default, esportato per non duplicarlo lì. */
+export const CARTELLA_NOTE = '.notes-store';
+
+export class NoteStoreError extends Error {
+  constructor(message, code = 'NOTE_INVALID') {
+    super(message);
+    this.name = 'NoteStoreError';
+    this.code = code;
+  }
+}
+
+function percorsoDi(cartella, id) {
+  // ⛔ 14/09: l'id arriva da fuori (indirizzo HTTP, attrezzo del modello), non solo da un randomUUID nostro — un id fuori
+  //   grammatica non nomina nessun file e torna `null`, mai un `join` che con `..` uscirebbe dalla cartella. Vedi id-archivio.mjs.
+  if (!idArchivioValido(id)) return null;
+  return join(cartella, `${id}.json`);
+}
+
+function validaTitolo(title) {
+  if (typeof title !== 'string' || title.trim().length === 0 || title.length > TITOLO_MASSIMO) {
+    throw new NoteStoreError(`title deve avere 1-${TITOLO_MASSIMO} caratteri`, 'NOTE_INVALID');
+  }
+  return title.trim();
+}
+
+function validaContenuto(content) {
+  if (typeof content !== 'string' || content.trim().length === 0 || content.length > CONTENUTO_MASSIMO) {
+    throw new NoteStoreError(`content deve avere 1-${CONTENUTO_MASSIMO} caratteri`, 'NOTE_INVALID');
+  }
+  return content.trim();
+}
+
+/*
+ * ⭐⭐⭐⭐ 11/09/2026, owner: «le note, se sono markdown, devono essere renderizzate in markdown».
+ *
+ * ⛔ Chi decide non è il frontend, è questo modulo: una nota nasce qui, e se ogni superficie che
+ *   la mostra ricavasse il formato da sé avremmo tante risposte quante le superfici (la stessa
+ *   classe di difetto di «due lettori dello stesso corpo» già scritta in http-app.mjs).
+ * ⛔ `formato` è DICHIARATO oppure RILEVATO, mai indovinato due volte: se chi scrive lo dichiara
+ *   (la persona, da un interruttore nel pannello) il valore resta sul disco e vince per sempre;
+ *   se non lo dichiara (il modello, che nei suoi attrezzi non ha quel campo) lo rileva questa
+ *   funzione a ogni lettura — così una nota scritta ieri in testo semplice e modificata oggi con
+ *   un titolo `#` si vede subito come markdown, senza una migrazione.
+ *
+ * I marcatori sono quelli della specifica CommonMark 0.31.2 (spec.commonmark.org, letta
+ * l'11/09/2026), non una lista a memoria: titoli ATX (1-6 `#` seguiti da spazio, fino a 3 spazi
+ * di rientro), recinti di codice (3+ backtick o tilde), citazioni (`>`), elenchi puntati
+ * (`-`/`+`/`*` PIÙ uno spazio — senza lo spazio non è un elenco) ed elenchi numerati (1-9 cifre
+ * più `.` o `)`), righe orizzontali, link `[testo](url)` e enfasi `**`/`__`.
+ *
+ * ⛔ Enfasi ed elenchi puntati sono i due marcatori che un testo normale può contenere per caso
+ *   («3 * 4 * 5», un trattino a inizio riga): per questo richiedono la forma STRETTA — `**` o
+ *   `__` attorno a qualcosa, e il trattino solo a inizio riga seguito da spazio. Un asterisco
+ *   solitario non basta a chiamare markdown un promemoria della spesa.
+ */
+const MARCATORI_MARKDOWN = Object.freeze([
+  /^ {0,3}#{1,6}(?:[ \t]|$)/m,          // titolo ATX
+  /^ {0,3}(?:```|~~~)/m,                 // recinto di codice
+  /^ {0,3}>(?:[ \t]|$)/m,                // citazione
+  /^ {0,3}[-+*][ \t]+\S/m,               // elenco puntato (il marcatore VUOLE uno spazio)
+  /^ {0,3}\d{1,9}[.)][ \t]+\S/m,         // elenco numerato
+  /^ {0,3}(?:(?:[-*_][ \t]*){3,})$/m,    // riga orizzontale
+  /\[[^\]\n]+\]\([^)\s]+\)/,             // link in linea
+  /(\*\*|__)(?!\s)[^\n]+?\1/,            // enfasi forte
+  /^ {0,3}\|.*\|[ \t]*$/m,               // riga di tabella (estensione GFM, non CommonMark: dichiarata)
+]);
+
+/** `'markdown'` se il testo porta almeno un marcatore CommonMark, `'testo'` altrimenti. PURA: nessun I/O, si prova con una stringa letterale. */
+export function rilevaFormatoNota(contenuto) {
+  const testo = typeof contenuto === 'string' ? contenuto : '';
+  return MARCATORI_MARKDOWN.some((marcatore) => marcatore.test(testo)) ? 'markdown' : 'testo';
+}
+
+const FORMATI = Object.freeze(['markdown', 'testo']);
+/*
+ * ⛔ 11/09 — CHI ha scritto questa nota. Due soli valori possibili perché due sole porte
+ *   esistono: gli attrezzi `notes_*` del modello (agent-service.mjs) e le rotte HTTP della
+ *   persona (http-app.mjs). Il default è `'modello'` e non `'ignoto'` di proposito: fino a
+ *   oggi la persona NON aveva una porta per scrivere — ogni nota già sul disco viene di lì, e
+ *   un terzo valore inventerebbe un'incertezza che non c'è.
+ */
+const ORIGINI = Object.freeze(['persona', 'modello']);
+
+function validaFormato(formato) {
+  if (!FORMATI.includes(formato)) {
+    throw new NoteStoreError(`formato deve essere uno fra ${FORMATI.join('/')}`, 'NOTE_INVALID');
+  }
+  return formato;
+}
+
+function validaOrigine(origine) {
+  if (!ORIGINI.includes(origine)) {
+    throw new NoteStoreError(`origine deve essere una fra ${ORIGINI.join('/')}`, 'NOTE_INVALID');
+  }
+  return origine;
+}
+
+/**
+ * La forma PUBBLICA di una nota — l'unica che esce da questo prodotto, uguale per la rotta
+ * HTTP della persona e per chiunque altro la mostri. `formato` dichiarato vince, altrimenti
+ * si rileva dal contenuto; `origine` assente su disco vuol dire `'modello'` (vedi ORIGINI).
+ */
+export function formaPubblicaNota(voce) {
+  return {
+    id: voce.id,
+    titolo: voce.titolo,
+    contenuto: voce.contenuto,
+    formato: FORMATI.includes(voce.formato) ? voce.formato : rilevaFormatoNota(voce.contenuto),
+    creataAlle: voce.creataAlle ?? null,
+    aggiornataAlle: voce.aggiornataAlle ?? null,
+    origine: ORIGINI.includes(voce.origine) ? voce.origine : 'modello',
+  };
+}
+
+/** Più recentemente aggiornate per prime — stesso ordine di `notes_list` mobile (`chatDatabaseSchema.ts`: `ON talos_notes(updated_at DESC, id)`). Cartella assente ⇒ `[]`, mai un errore (primo avvio, nessuna nota ancora). */
+export async function elencaNote({ cartella }, deps = {}) {
+  const readdirFn = deps.readdirFn ?? fsp.readdir;
+  const readFileFn = deps.readFileFn ?? fsp.readFile;
+  let nomi;
+  try {
+    nomi = await readdirFn(cartella);
+  } catch {
+    return [];
+  }
+  const voci = [];
+  for (const nome of nomi) {
+    if (!nome.endsWith('.json')) continue;
+    try {
+      voci.push(JSON.parse(await readFileFn(join(cartella, nome), 'utf8')));
+    } catch { /* una voce corrotta non deve nascondere le altre */ }
+  }
+  return voci.sort((a, b) => b.aggiornataAlle.localeCompare(a.aggiornataAlle) || a.id.localeCompare(b.id));
+}
+
+/** Un id assente torna `null`, mai un'eccezione — stesso principio di `library-store.mjs#leggiVoce`. */
+export async function leggiNota({ cartella, id }, deps = {}) {
+  const readFileFn = deps.readFileFn ?? fsp.readFile;
+  const percorso = percorsoDi(cartella, id);
+  if (!percorso) return null; // ⛔ 14/09: id fuori grammatica = «non c'è», mai una lettura fuori dalla cartella
+  try {
+    return JSON.parse(await readFileFn(percorso, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @returns la nota creata: `{id, titolo, contenuto, formato?, origine, creataAlle, aggiornataAlle}`.
+ * @throws {NoteStoreError} NOTE_INVALID su title/content/formato/origine fuori dai tetti — PRIMA di ogni I/O, mai una scrittura parziale.
+ * ⛔ 11/09 — `formato` si scrive sul disco SOLO se dichiarato: assente vuol dire «rilevalo a ogni
+ *   lettura» (vedi formaPubblicaNota), e scriverci dentro il risultato del rilevamento
+ *   congelerebbe per sempre una risposta che deve poter cambiare col contenuto.
+ */
+export async function creaNota({ cartella, title, content, formato, origine = 'modello' }, deps = {}) {
+  const titolo = validaTitolo(title);
+  const contenuto = validaContenuto(content);
+  const formatoDichiarato = formato === undefined ? undefined : validaFormato(formato);
+  const daChi = validaOrigine(origine);
+  const mkdirFn = deps.mkdirFn ?? fsp.mkdir;
+  const writeFileFn = deps.writeFileFn ?? fsp.writeFile;
+  const clockFn = deps.clockFn ?? (() => new Date());
+  const ora = clockFn().toISOString();
+  const voce = {
+    id: randomUUID(),
+    titolo,
+    contenuto,
+    ...(formatoDichiarato ? { formato: formatoDichiarato } : {}),
+    origine: daChi,
+    creataAlle: ora,
+    aggiornataAlle: ora,
+  };
+  await mkdirFn(cartella, { recursive: true });
+  await writeFileFn(percorsoDi(cartella, voce.id), JSON.stringify(voce, null, 2), 'utf8');
+  return voce;
+}
+
+/**
+ * Solo i campi passati cambiano — `undefined` lascia il campo intatto (mai
+ * una cancellazione implicita), stesso contratto ESATTO del tool mobile
+ * ("Send ONLY the fields you are changing").
+ * @throws {NoteStoreError} NOTE_NOT_FOUND se l'id non esiste, NOTE_INVALID su un campo passato ma fuori dai tetti.
+ */
+export async function aggiornaNota({ cartella, id, title, content, formato }, deps = {}) {
+  const readFileFn = deps.readFileFn ?? fsp.readFile;
+  const mkdirFn = deps.mkdirFn ?? fsp.mkdir;
+  const writeFileFn = deps.writeFileFn ?? fsp.writeFile;
+  const clockFn = deps.clockFn ?? (() => new Date());
+  const voce = await leggiNota({ cartella, id }, { readFileFn });
+  if (!voce) throw new NoteStoreError(`nessuna nota con id ${id}`, 'NOTE_NOT_FOUND');
+  if (title !== undefined) voce.titolo = validaTitolo(title);
+  if (content !== undefined) voce.contenuto = validaContenuto(content);
+  /* ⛔ `formato: null` NON è «lascia stare» come `undefined`: è «torna a rilevarlo dal contenuto»,
+     cioè l'unico modo di disfare una dichiarazione sbagliata. Senza questa riga un interruttore
+     acceso una volta non si sarebbe più potuto spegnere. */
+  if (formato === null) delete voce.formato;
+  else if (formato !== undefined) voce.formato = validaFormato(formato);
+  voce.aggiornataAlle = clockFn().toISOString();
+  await mkdirFn(cartella, { recursive: true });
+  await writeFileFn(percorsoDi(cartella, id), JSON.stringify(voce, null, 2), 'utf8');
+  return voce;
+}
+
+/** Idempotente — un id già assente non è un errore, è l'esito voluto ottenuto da qualcun altro (stesso principio del tool mobile: "It may already be gone"). */
+export async function eliminaNota({ cartella, id }, deps = {}) {
+  const rmFn = deps.rmFn ?? fsp.rm;
+  const percorso = percorsoDi(cartella, id);
+  if (!percorso) return; // ⛔ 14/09: un id che non può nominare un file è già «assente» — no-op idempotente, mai un rm fuori dalla cartella
+  await rmFn(percorso, { force: true });
+}