@alucard_24/pi-codeindex 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+## 1.1.0
+
+### Novità
+
+- Modello di embedding in un servizio locale condiviso tra processi pi e CLI:
+  una sola pipeline per endpoint, avvio automatico, inferenze serializzate e
+  coda limitata. Nessun fallback in-process in caso di errore del servizio.
+- Rilascio del modello dopo inattività (default 5 minuti), configurabile con
+  `serviceIdleMs` / `CODEINDEX_SERVICE_IDLE_MS`.
+- `/codeindex service status` e `/codeindex service stop`, disponibili anche
+  dalla CLI. Autenticazione locale, verifica del profilo dopo riconnessione e
+  rifiuto dei conflitti di configurazione senza creare un secondo modello.
+- Indicizzazione e sincronizzazione anche nelle cartelle senza repository Git.
+  Home e radice del disco richiedono consenso esplicito in ogni sessione.
+- Diagnostica, configurazione e documentazione aggiornate; test di concorrenza,
+  crash, shutdown e prove opt-in con modello reale.
+
+### Aggiornamento
+
+Chiudere e riaprire i vecchi processi pi dopo l'aggiornamento: le copie del
+modello caricate dal vecchio runtime in-process non vengono liberate dal
+nuovo servizio. Per cambiare il profilo di un servizio già attivo usare
+`/codeindex service stop` quando inattivo, oppure attendere il timeout idle.
+I probe espliciti di doctor restano isolati e possono caricare un modello
+aggiuntivo. Endpoint diversi permettono deliberatamente istanze separate.
+
+Il servizio è stato verificato su Linux x64 con CPU, CUDA, WebGPU automatico
+e WebGPU/Vulkan; DirectML/Windows e CoreML/macOS restano da verificare sulle
+rispettive piattaforme. Le misure storiche Fase 5–7 non sono nuovi benchmark
+del servizio condiviso.

package/README.md

@@ -1,9 +1,11 @@
 # pi-codeindex
 
 Indice semantico locale del codice per l'agente pi: embedding con
-**EmbeddingGemma 2** (ONNX, in-process) e ricerca ibrida (coseno + lessico)
-che restituisce `path:righe` + simbolo + anteprima. Nessun server, nessun
-database: due file in `~/.cache/pi-codeindex/<sha1(repo)>/`.
+**EmbeddingGemma 2** (ONNX, servizio locale condiviso) e ricerca ibrida
+(coseno + lessico) che restituisce `path:righe` + simbolo + anteprima.
+Una sola copia del modello fra processi pi/CLI sullo stesso endpoint;
+nessun servizio remoto o database. Indice: due file in
+`~/.cache/pi-codeindex/<sha1(repo)>/`.
 
 ## Requisiti
 
@@ -50,11 +52,12 @@ modificata dal pacchetto.
 
 ## Embedding e backend
 
-Il modello **EmbeddingGemma 2** gira localmente, in-process. I soli pesi testo
-vengono scaricati al primo utilizzo (anche dall'indicizzazione automatica) e
-riutilizzati fra repository. Nessun server o API di embedding; dopo il primo
-download è possibile lavorare offline. Il codice da embeddare non viene
-inviato al server dei pesi. Un processo pi mantiene una propria pipeline.
+Il modello **EmbeddingGemma 2** gira in un servizio locale condiviso avviato
+automaticamente al primo utilizzo, anche dall'indicizzazione automatica.
+I client pi/CLI non caricano una pipeline propria. I soli pesi testo vengono
+scaricati e riutilizzati fra repository; dopo il primo download è possibile
+lavorare offline. Il codice da embeddare viaggia solo sul loopback locale,
+non viene inviato al server dei pesi o a un'API di embedding remota.
 
 | `device` | Default `dtype: auto` | Stato |
 |---|---|---|
@@ -130,6 +133,60 @@ macchina Linux x64 / RTX 5070 Ti: EmbeddingGemma fp16, indice incrementale,
 ricerca su fixture e coesistenza con i provider standard. Queste prove non
 sostituiscono un benchmark di qualità o prestazioni su altri hardware.
 
+## Servizio condiviso e memoria
+
+Il primo client sceglie il profilo secondo la configurazione; gli altri
+riutilizzano la stessa pipeline se quel profilo è consentito. Un profilo
+incompatibile, una cache pesi diversa o valori diversi di `cpuThreads` o
+`serviceIdleMs` danno errore: **nessun secondo modello e nessun fallback
+in-process**. Un device forzato può riutilizzare un servizio CPU solo con
+`fallback: cpu`, con avviso esplicito. Le richieste sono serializzate, con
+massimo 16 richieste attive/in coda; ogni batch contiene al massimo 128 testi
+e 2 MiB di testo. La saturazione della coda produce un errore, non un altro
+worker. Un crash interrompe la richiesta corrente; un uso successivo può
+riavviare il servizio, verificando il profilo già fissato dal client.
+
+Dopo **5 minuti senza operazioni sul modello** il processo termina e l'OS
+libera RAM/VRAM native. `status` non rinnova il timer. Chiudere/disabilitare
+una singola sessione non arresta un modello che può servire altri processi.
+Per liberarlo subito, quando non ci sono inferenze in corso:
+
+```text
+/codeindex service status
+/codeindex service status --json
+/codeindex service stop
+```
+
+Gli stessi comandi funzionano come `node src/cli.js service status|stop`.
+Stop viene rifiutato se ci sono richieste attive/in coda; non interrompe altri
+client. Il servizio si riavvierà al prossimo utilizzo del modello. Nessun
+avvio al login, servizio di sistema o modifica alle impostazioni globali di pi.
+
+Il listener è solo `127.0.0.1`, con porta deterministica per la directory
+utente e autenticazione tramite token in `~/.cache/pi-codeindex/service/`
+(directory 0700, record 0600 su POSIX). Il binding esclusivo della porta
+impedisce due avvii simultanei. Una porta occupata da un altro programma dà
+un errore: `servicePort` consente una scelta esplicita. Usa gli stessi
+`serviceDir`/`servicePort` in tutti i client: cambiarli crea endpoint distinti
+e permette deliberatamente più modelli. Non condividere il token o la directory.
+
+Restano per-processo le cache degli indici, dei vettori e dei grafi: il servizio
+elimina le copie del **modello**, non tutta la memoria di pi. Dopo l'aggiornamento
+**chiudi e riapri i vecchi processi pi**: i modelli già caricati dal vecchio
+codice in-process non possono essere liberati dal nuovo servizio.
+
+Verifica reale opt-in, con pesi già in cache (offline), due processi client,
+indice/ricerca e uscita idle:
+
+```bash
+CODEINDEX_TEST_SERVICE=1 CODEINDEX_DEVICE=cuda node --test test/service-integration.test.js
+# Oppure cpu/q8, oppure WebGPU con CODEINDEX_WEBGPU_BACKEND=vulkan dopo setup-vulkan.
+```
+
+Questi test non sono un nuovo benchmark Fase 5–7. La piattaforma iniziale di
+verifica del servizio è Linux x64; Windows/DirectML e macOS/CoreML richiedono
+verifica sulle rispettive macchine.
+
 ## Configurazione
 
 Dentro pi:
@@ -142,6 +199,8 @@ Dentro pi:
 /codeindex config set webgpuBackend vulkan  solo WebGPU, setup-vulkan richiesto
 /codeindex config set fallback cpu
 /codeindex config unset device           ripristina la scelta automatica
+/codeindex service status                processo condiviso, profilo e memoria
+/codeindex service stop                  rilascia il modello quando inattivo
 /codeindex doctor                        inventario, senza inferenza/download
 /codeindex doctor --probe --device webgpu prova reale isolata (può scaricare i pesi)
 ```
@@ -175,9 +234,15 @@ non default silenziosi. Schema per editor: [config.schema.json](config.schema.js
 | `offline` | booleano; niente download, errore se mancano pesi | `CODEINDEX_OFFLINE=true\|false\|1\|0` |
 | `cacheDir` | cache pesi, default `~/.cache/pi-codeindex/text-model` | `CODEINDEX_MODEL_CACHE` |
 | `cpuThreads` | 0 = default ORT, oppure 1–256; non limita la GPU | `CODEINDEX_CPU_THREADS` |
+| `serviceIdleMs` | default 300000 (5 min), da 1000 a 86400000 ms | `CODEINDEX_SERVICE_IDLE_MS` |
+| `serviceDir` | directory privata condivisa, default `~/.cache/pi-codeindex/service` | `CODEINDEX_SERVICE_DIR` |
+| `servicePort` | 0 = deterministica, oppure 1024–65535; solo loopback | `CODEINDEX_SERVICE_PORT` |
 
 **Riavvia pi con un nuovo processo** dopo una modifica: non si cambia pipeline
-nel mezzo di un run. Il menu non riavvia né reindicizza da solo. Device, dtype
+nel mezzo di un run. Se il servizio ha già un profilo/configurazione diversi,
+usa anche `service stop` quando inattivo, oppure attendi l'uscita idle.
+Prima di aggiornare a un protocollo incompatibile, arresta il vecchio servizio.
+Il menu non riavvia né reindicizza da solo. Device, dtype
 e backend WebGPU effettivi sono salvati nell'indice; se diversi, la ricerca rifiuta di mescolare
 i vettori e chiede un re-index. Gli indici precedenti senza `device` vengono
 ricostruiti alla prossima indicizzazione.
@@ -198,9 +263,11 @@ CODEINDEX_DEVICE=cuda CODEINDEX_DTYPE=fp16 pi -e ./src/extension.js
 in subprocessi isolati con timeout di 120 s per backend; `--all` può scaricare
 più varianti. Ogni provider forzato viene provato senza fallback, per non
 attribuire alla GPU un successo ottenuto in CPU. Usa `offline: true` per provarle solo dalla cache. Un crash nativo
-di una prova non abbatte pi; questo isolamento riguarda `doctor`, non la normale
-pipeline in-process. Smoke del menu e dei comandi via RPC, senza chiamate al
-modello: `CODEINDEX_TEST_RPC=1 node --test test/config-rpc.test.js` (richiede
+di una prova non abbatte pi. I probe restano esplicitamente isolati e **possono
+caricare una copia aggiuntiva del modello** mentre il servizio è attivo: arresta
+prima il servizio se vuoi evitare questo picco. Anche la pipeline ordinaria è
+ora isolata, nel worker condiviso. Smoke del menu e dei comandi via RPC, senza
+chiamate LLM e con cache modello temporanea/offline: `CODEINDEX_TEST_RPC=1 node --test test/config-rpc.test.js` (richiede
 `pi` sul PATH; usa un file config temporaneo, non modifica quello utente).
 
 ## Comandi
@@ -252,13 +319,40 @@ Cosa aggiunge:
 - **indicizzazione automatica** all'avvio della sessione, in background,
   single-flight, interrompibile, con cap 5.000 file / 200 MB.
 - **sincronizzazione**: watcher ricorsivo con debounce 800 ms, invalidazione
-  diretta da `write`/`edit` e sweep `git status` dopo `bash`. Una riconciliazione
-  riusa i vettori dei file intatti (misurato: 1 chunk re-embedded su 3 dopo una
-  modifica, 920 ms fino all'indice aggiornato).
-
-Fuori da un repo git l'estensione si disattiva da sola; se il modello non è
-scaricabile o il reindex fallisce, `search_code` risponde con lo stato reale e
-la sessione continua.
+  diretta da `write`/`edit` e controllo dopo `bash`: sweep `git status` nei
+  repository, riconciliazione incrementale nelle cartelle senza Git. Una
+  riconciliazione riusa i vettori dei file intatti (misurato nei repository:
+  1 chunk re-embedded su 3 dopo una modifica, 920 ms fino all'indice aggiornato).
+
+Se il modello non è scaricabile o il reindex fallisce, `search_code` risponde
+con lo stato reale e la sessione continua.
+
+### Cartelle senza Git
+
+Git è opzionale. Nei repository la radice resta quella restituita da Git,
+anche avviando pi da una sottocartella. Altrimenti viene usata **esattamente
+la directory da cui avvii pi**: non viene creato `.git`, non servono commit
+né un remote. `/codeindex status` mostra radice e modalità.
+
+In modalità cartella la scansione esclude le directory nascoste e le consuete
+directory di dipendenze/output (`node_modules`, `dist`, `build`, `out`,
+`vendor`, `target`, `coverage`, `venv`, `__pycache__`); non segue i symlink.
+Restano i limiti di estensione, dimensione, 5.000 file e 200 MB. Le esclusioni
+sono quelle fisse della scansione locale: **senza Git i file `.gitignore`
+non vengono interpretati**. Nei repository continua a valere `git ls-files`
+con le esclusioni Git.
+
+Il watcher gestisce anche rename/cancellazioni di directory; dopo `bash`
+viene accodata una riconciliazione senza ricalcolare i vettori invariati.
+Se il watcher non è disponibile, la riconciliazione viene accodata anche
+all'inizio di un nuovo prompt. `/codeindex reindex` resta disponibile per
+aggiornare manualmente l'indice; `--force` ricalcola tutti i vettori.
+
+Per evitare scansioni involontarie dell'intera macchina, nella **home** e
+nella **radice del disco**, se non sono repository Git, l'indice parte spento.
+Avvia pi dalla cartella del progetto oppure abilitalo esplicitamente con
+`/codeindex enable`; nelle due cartelle protette il consenso va ripetuto a
+ogni avvio della sessione. Nessuna nuova configurazione globale è necessaria.
 
 ## Cosa indicizza
 
@@ -267,7 +361,10 @@ Markdown. Chunk declaration-aware, con fusione dei chunk piccoli (Markdown fino
 a 80 righe; codice solo micro-chunk ≤6 righe). Esclusi: binari, file >1 MB,
 minified, lockfile, `.pbl`/`.pbt`/`.pbw`.
 
-## Numeri misurati (RTX 5070 Ti, fp16)
+## Numeri misurati (runtime originale in-process, RTX 5070 Ti, fp16)
+
+Queste misure precedono il servizio condiviso e non ne misurano memoria,
+latenza IPC o prestazioni con client concorrenti.
 
 | Repo | File | Chunk | Primo indice | Re-index |
 |---|---|---|---|---|

package/config.schema.json

@@ -11,6 +11,9 @@
     "fallback": { "enum": ["error", "cpu"], "default": "error", "description": "Fallback consentito per un device forzato; auto include sempre CPU." },
     "offline": { "type": "boolean", "default": false },
     "cacheDir": { "type": "string", "minLength": 1, "pattern": "\\S", "description": "Cache dei pesi. Supporta ~/; i percorsi relativi sono risolti dal cwd." },
-    "cpuThreads": { "type": "integer", "minimum": 0, "maximum": 256, "default": 0, "description": "0 usa il default di ONNX Runtime; non limita la GPU." }
+    "cpuThreads": { "type": "integer", "minimum": 0, "maximum": 256, "default": 0, "description": "0 usa il default di ONNX Runtime; non limita la GPU." },
+    "serviceDir": { "type": "string", "minLength": 1, "pattern": "\\S", "description": "Directory privata del servizio condiviso. Default ~/.cache/pi-codeindex/service; non cambiarla fra sessioni se vuoi condividere il modello." },
+    "servicePort": { "type": "integer", "anyOf": [{ "const": 0 }, { "minimum": 1024, "maximum": 65535 }], "default": 0, "description": "0 sceglie una porta loopback deterministica dalla directory del servizio. Cambiarla crea un endpoint distinto." },
+    "serviceIdleMs": { "type": "integer", "minimum": 1000, "maximum": 86400000, "default": 300000, "description": "Inattività prima di terminare il processo e liberare il modello (default 5 minuti). Status non rinnova il timer." }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alucard_24/pi-codeindex",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Indice semantico locale del codice per pi (EmbeddingGemma 2, ONNX)",
   "license": "MIT",
   "author": "Alucard24",
@@ -9,7 +9,7 @@
   "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" },
   "main": "./src/extension.js",
   "bin": { "pi-codeindex": "src/cli.js" },
-  "files": ["src", "scripts/setup-gpu.sh", "scripts/setup-vulkan.mjs", "scripts/vulkan-sources.json", "eval/queries.jsonl", "config.schema.json", "README.md", "LICENSE"],
+  "files": ["src", "scripts/setup-gpu.sh", "scripts/setup-vulkan.mjs", "scripts/vulkan-sources.json", "eval/queries.jsonl", "config.schema.json", "README.md", "CHANGELOG.md", "LICENSE"],
   "engines": { "node": ">=22" },
   "scripts": {
     "test": "node --test 'test/*.test.js'",

package/src/cli.js

@@ -5,7 +5,7 @@
 import fs from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { embed, embedQuery, embedDocs, cosine, MODEL_ID, getEmbeddingProfile, modelDir } from './embed.js';
+import { embed, embedQuery, embedDocs, cosine, MODEL_ID, getEmbeddingProfile, modelDir, getServiceStatus, serviceCommand, embeddingStatus } from './embed.js';
 import { configCommand } from './config.js';
 import { formatProfile } from './backend.js';
 import { doctor, formatDoctor, parseDoctorArgs } from './doctor.js';
@@ -44,7 +44,9 @@ async function embedTest() {
   console.log('cos(same)    :', cosine(sameA, sameB).toFixed(6), '(atteso ~1.0)');
   console.log('cos(diverse) :', cosine(sameA, other).toFixed(6), '(atteso < 0.95)');
   console.log('latency cold :', tCold, 'ms per 3 testi');
-  console.log('rss          :', rssMb(), 'MB');
+  console.log('rss client   :', rssMb(), 'MiB');
+  const service = await getServiceStatus();
+  console.log('servizio     :', service.pid, '· RSS', Math.round(service.rssBytes / 1024 / 1024), 'MiB');
 
   const batch = Array.from({ length: 16 }, (_, i) => `${SAME} // variante ${i}`);
   const t1 = performance.now();
@@ -59,7 +61,7 @@ async function embedTest() {
   ]);
   console.log('query->args  :', cosine(q[0], docs[0]).toFixed(4));
   console.log('query->idle  :', cosine(q[0], docs[1]).toFixed(4));
-  console.log('rss finale   :', rssMb(), 'MB');
+  console.log('rss client finale:', rssMb(), 'MiB');
 
   const dump = arg('dump');
   if (dump && dump !== true) {
@@ -78,6 +80,7 @@ async function cmdIndex() {
   const r = await indexRepo({ root, maxFiles, maxBytes, batchSize, force });
   const out = {
     repo: r.repo,
+    profile: { model: r.index.model, dims: r.index.dims, device: r.index.device, dtype: r.index.dtype, webgpuBackend: r.index.webgpuBackend },
     files: r.index.stats.files,
     chunks: r.total,
     embedded: r.embedded,
@@ -91,6 +94,7 @@ async function cmdIndex() {
     console.log(JSON.stringify(out));
   } else {
     console.log(`repo         : ${r.repo}`);
+    console.log(`runtime      : ${formatProfile(r.index)} · servizio condiviso`);
     console.log(`file         : ${out.files} (${fmtBytes(out.bytes)}) · invariati ${out.unchangedFiles}`);
     console.log(`chunk        : ${out.chunks} · riusati ${out.reused} · embeddati ${out.embedded}`);
     console.log(`esclusi      : estensione ${out.skip.ext}, dimensione ${out.skip.big}, binari ${out.skip.binary}, minified ${out.skip.minified}, cap ${out.skip.cap}`);
@@ -164,6 +168,7 @@ async function cmdEval() {
 const cmd = process.argv[2];
 try {
   if (cmd === 'config') console.log(await configCommand(process.argv.slice(3)));
+  else if (cmd === 'service') console.log(await serviceCommand(process.argv.slice(3)));
   else if (cmd === 'setup-vulkan') {
     const { setupVulkan } = await import('../scripts/setup-vulkan.mjs');
     await setupVulkan(process.argv.slice(3));
@@ -186,9 +191,12 @@ try {
   else if (cmd === 'search') await cmdSearch();
   else if (cmd === 'eval') await cmdEval();
   else {
-    console.error('comandi: embed-test | index | status | search | eval | setup-gpu | setup-vulkan | config [show|path|set CHIAVE VALORE|unset CHIAVE] | doctor [--probe] [--all] [--device DEVICE] [--dtype DTYPE] [--webgpu-backend auto|vulkan] [--json]');
+    console.error('comandi: embed-test | index | status | search | eval | setup-gpu | setup-vulkan | service [status [--json]|stop] | config [show|path|set CHIAVE VALORE|unset CHIAVE] | doctor [--probe] [--all] [--device DEVICE] [--dtype DTYPE] [--webgpu-backend auto|vulkan] [--json]');
     process.exit(1);
   }
+  const runtime = embeddingStatus();
+  const warnings = [...runtime.warnings, ...runtime.attempts.filter((a) => !a.ok).map((a) => `${a.device}: ${a.error}`)];
+  if (runtime.profile && warnings.length) console.error(`codeindex: selezionato ${formatProfile(runtime.profile)}; ${warnings.join('; ')}`);
 } catch (e) {
   console.error(`errore: ${e.message}`);
   if (process.env.CODEINDEX_DEBUG) console.error(e.stack);

package/src/config-ui.js

@@ -14,10 +14,10 @@ export async function configure(ctx, options = {}) {
     if (!selected || selected === 'Annulla') return null;
     if (selected === 'Salva') {
       if (!Object.keys(patch).length) return null;
-      if (!(await ctx.ui.confirm('Salvare la configurazione?', `${loaded.file}\n${JSON.stringify(patch, null, 2)}\nRiavvia pi dopo il salvataggio. Cambiare device/dtype/backend WebGPU richiede un re-index.`))) return null;
+      if (!(await ctx.ui.confirm('Salvare la configurazione?', `${loaded.file}\n${JSON.stringify(patch, null, 2)}\nRiavvia pi dopo il salvataggio. Per cambiare un servizio già attivo usa /codeindex service stop quando inattivo. Cambiare device/dtype/backend WebGPU richiede un re-index.`))) return null;
       const file = await updateConfig(patch, options);
       const overrides = Object.keys(patch).filter((key) => loaded.sources[key] === ENV_KEYS[key]);
-      return `salvato: ${file}\nRiavvia pi (nuovo processo) per applicare.` +
+      return `salvato: ${file}\nRiavvia pi (nuovo processo) per applicare; per cambiare un servizio già attivo usa /codeindex service stop quando inattivo.` +
         (overrides.length ? `\nAttenzione: override d'ambiente attivi per ${overrides.join(', ')}.` : '') +
         `\n${formatConfig(await loadConfig(options))}`;
     }
@@ -25,9 +25,11 @@ export async function configure(ctx, options = {}) {
     if (!key) continue;
     const choices = key === 'device' ? DEVICES : key === 'dtype' ? DTYPES
       : key === 'webgpuBackend' ? WEBGPU_BACKENDS : key === 'fallback' ? ['error', 'cpu'] : key === 'offline' ? ['false', 'true'] : null;
-    const hint = key === 'webgpuBackend' ? ' — solo WebGPU; vulkan richiede setup-vulkan' : '';
+    const hint = key === 'webgpuBackend' ? ' — solo WebGPU; vulkan richiede setup-vulkan'
+      : key === 'serviceIdleMs' ? ' — millisecondi; 300000 = 5 minuti'
+      : key === 'serviceDir' || key === 'servicePort' ? ' — lascia uguale fra sessioni per condividere un solo modello' : '';
     const text = choices ? await ctx.ui.select(`${key}${hint} (attuale: ${draft[key]})`, choices)
-      : await ctx.ui.input(`${key} (attuale: ${draft[key]})`, String(draft[key]));
+      : await ctx.ui.input(`${key}${hint} (attuale: ${draft[key]})`, String(draft[key]));
     if (text === undefined) continue;
     try { draft[key] = patch[key] = parseSetting(key, text); }
     catch (e) { ctx.ui.notify(e.message, 'error'); }

package/src/config.js

@@ -12,6 +12,7 @@ export const ENV_KEYS = {
   device: 'CODEINDEX_DEVICE', dtype: 'CODEINDEX_DTYPE', fallback: 'CODEINDEX_FALLBACK',
   offline: 'CODEINDEX_OFFLINE', cacheDir: 'CODEINDEX_MODEL_CACHE', cpuThreads: 'CODEINDEX_CPU_THREADS',
   webgpuBackend: 'CODEINDEX_WEBGPU_BACKEND',
+  serviceDir: 'CODEINDEX_SERVICE_DIR', servicePort: 'CODEINDEX_SERVICE_PORT', serviceIdleMs: 'CODEINDEX_SERVICE_IDLE_MS',
 };
 
 export function configPath(env = process.env, home = os.homedir()) {
@@ -26,7 +27,8 @@ function expandPath(value, home = os.homedir()) {
 
 export function defaults(home = os.homedir()) {
   return { device: 'auto', dtype: 'auto', webgpuBackend: 'auto', fallback: 'error', offline: false,
-    cacheDir: path.join(home, '.cache', 'pi-codeindex', 'text-model'), cpuThreads: 0 };
+    cacheDir: path.join(home, '.cache', 'pi-codeindex', 'text-model'), cpuThreads: 0,
+    serviceDir: path.join(home, '.cache', 'pi-codeindex', 'service'), servicePort: 0, serviceIdleMs: 300_000 };
 }
 
 export function validateConfig(value, source = 'config') {
@@ -44,8 +46,10 @@ export function validateConfig(value, source = 'config') {
       : key === 'webgpuBackend' ? WEBGPU_BACKENDS : key === 'fallback' ? ['error', 'cpu'] : null;
     if (choices && !choices.includes(v)) throw new Error(`${source}: ${key} deve essere uno di: ${choices.join(', ')}`);
     if (key === 'offline' && typeof v !== 'boolean') throw new Error(`${source}: offline deve essere booleano`);
-    if (key === 'cacheDir' && (typeof v !== 'string' || !v.trim())) throw new Error(`${source}: cacheDir deve essere un percorso non vuoto`);
+    if (['cacheDir', 'serviceDir'].includes(key) && (typeof v !== 'string' || !v.trim())) throw new Error(`${source}: ${key} deve essere un percorso non vuoto`);
     if (key === 'cpuThreads' && (!Number.isInteger(v) || v < 0 || v > 256)) throw new Error(`${source}: cpuThreads deve essere un intero tra 0 e 256`);
+    if (key === 'servicePort' && (!Number.isInteger(v) || (v !== 0 && (v < 1024 || v > 65535)))) throw new Error(`${source}: servicePort deve essere 0 (automatico) oppure un intero tra 1024 e 65535`);
+    if (key === 'serviceIdleMs' && (!Number.isInteger(v) || v < 1000 || v > 86_400_000)) throw new Error(`${source}: serviceIdleMs deve essere un intero tra 1000 e 86400000`);
   }
   return value;
 }
@@ -56,8 +60,8 @@ export function parseSetting(key, text) {
   if (key === 'offline') {
     if (!['true', 'false', '1', '0'].includes(text)) throw new Error('offline: usa true oppure false');
     value = text === 'true' || text === '1';
-  } else if (key === 'cpuThreads') {
-    if (!/^\d+$/.test(text)) throw new Error('cpuThreads: atteso un intero tra 0 e 256');
+  } else if (['cpuThreads', 'servicePort', 'serviceIdleMs'].includes(key)) {
+    if (!/^\d+$/.test(text)) throw new Error(`${key}: atteso un intero`);
     value = Number(text);
   }
   validateConfig({ [key]: value });
@@ -86,6 +90,7 @@ export async function loadConfig({ env = process.env, home = os.homedir() } = {}
   }
   validateConfig(config, file);
   config.cacheDir = expandPath(config.cacheDir, home);
+  config.serviceDir = expandPath(config.serviceDir, home);
   return { config: Object.freeze(config), sources, file };
 }
 
@@ -122,5 +127,5 @@ export async function configCommand(args, options = {}) {
   if (action === 'set' && key && rest.length) file = await updateConfig({ [key]: parseSetting(key, rest.join(' ')) }, options);
   else if (action === 'unset' && key && !rest.length) file = await updateConfig({}, { ...options, unset: [key] });
   else throw new Error('uso: config [show|path|set CHIAVE VALORE|unset CHIAVE]');
-  return `salvato: ${file}\nRiavvia pi (nuovo processo) per applicare. Gli override CODEINDEX_* hanno precedenza.\n${formatConfig(await loadConfig(options))}`;
+  return `salvato: ${file}\nRiavvia pi (nuovo processo) per applicare. Per cambiare un profilo già attivo usa anche /codeindex service stop quando il servizio è inattivo. Gli override CODEINDEX_* hanno precedenza.\n${formatConfig(await loadConfig(options))}`;
 }

package/src/doctor.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'node:url';
 import { loadConfig, parseSetting } from './config.js';
 import { nativeBackends, formatProfile } from './backend.js';
 import { vulkanStatus } from './vulkan.js';
+import { createEmbeddingClient } from './service-client.js';
 
 export function parseDoctorArgs(args) {
   const options = { probe: false, all: false, json: false };
@@ -63,7 +64,9 @@ export async function doctor({ probe = false, all = false, device, dtype, webgpu
   }
   const settings = await loadConfig({ env });
   const native = nativeBackends();
-  const report = { ok: true, platform: process.platform, arch: process.arch, node: process.version,
+  const service = await createEmbeddingClient({ settings: () => settings, env }).status()
+    .catch((e) => ({ running: false, error: e.message }));
+  const report = { ok: !service.error, service, platform: process.platform, arch: process.arch, node: process.version,
     runtime: native.version, settings,
     requested: { device: device ?? settings.config.device, dtype: dtype ?? settings.config.dtype,
       webgpuBackend: webgpuBackend ?? settings.config.webgpuBackend },
@@ -73,7 +76,7 @@ export async function doctor({ probe = false, all = false, device, dtype, webgpu
     for (const selected of devices) {
       report.probes.push(await probeBackend({ device: selected, dtype, webgpuBackend, timeoutMs, env }));
     }
-    report.ok = report.probes.length > 0 && report.probes.every((p) => p.ok);
+    report.ok = !service.error && report.probes.length > 0 && report.probes.every((p) => p.ok);
   }
   return report;
 }
@@ -85,12 +88,14 @@ export function formatDoctor(report) {
     ...report.backends.map((b) => `${b.device.padEnd(8)}: ${b.available ? 'presente' : 'assente'} — ${b.reason}`),
     `backend WebGPU richiesto: ${(report.requested ?? report.settings.config).webgpuBackend} (solo quando il provider selezionato è WebGPU)`,
     `Vulkan forzato: ${report.vulkan?.available ? 'presente' : 'assente'} — ${report.vulkan?.reason ?? 'non verificato'}`];
+  lines.push(`servizio condiviso: ${report.service?.error ?? (report.service?.running ? `PID ${report.service.pid} · ${report.service.pending} richieste · ${Math.round(report.service.rssBytes / 1024 / 1024)} MiB RSS` : report.service?.stopping ? 'in arresto' : 'fermo (nessun avvio da doctor)')}`);
   if (!report.probes.length) lines.push('Nessuna inferenza eseguita. Usa doctor --probe (può scaricare i pesi), oppure --probe --all.');
   for (const p of report.probes) {
     lines.push(p.ok ? `PASS ${p.requested}: ${formatProfile(p.profile)} · ${p.profile.dims}d · ${p.elapsedMs} ms · cos(stesso) ${p.cosSame.toFixed(6)}`
       : `FAIL ${p.requested}: ${p.error}`);
     for (const a of p.attempts ?? []) if (!a.ok) lines.push(`  ${formatProfile(a)}: ${a.error}`);
   }
+  if (report.probes.length) lines.push('Probe isolati: possono caricare una copia aggiuntiva del modello mentre il servizio condiviso è attivo.');
   lines.push('Un provider presente non prova compatibilità/velocità del modello; ORT può eseguire alcuni operatori su CPU.');
   return lines.join('\n');
 }

package/src/embed.js

@@ -1,88 +1,57 @@
-// Embedding locale in-process. Selezione del provider verificata con il
-// modello reale; il profilo resta fisso per tutta la vita del processo.
-import { loadConfig } from './config.js';
-import { createEmbeddingRuntime, nativeBackends, validateEmbeddings, MODEL_ID, DIMS, QUERY_PREFIX, docPrefix } from './backend.js';
-import { ensureTextModel, modelPath } from './model.js';
+// Facciata dei client pi/CLI. L'unica pipeline vive nel servizio condiviso;
+// nessun errore di IPC attiva un fallback in-process.
+import { createEmbeddingClient } from './service-client.js';
+import { modelPath } from './model.js';
+import { MODEL_ID, DIMS, QUERY_PREFIX, docPrefix } from './backend.js';
 
 export { MODEL_ID, DIMS, QUERY_PREFIX, docPrefix };
+const client = createEmbeddingClient();
 
-const runtime = createEmbeddingRuntime({
-  settings: () => loadConfig(),
-  inventory: async () => nativeBackends().backends,
-  log: (s) => process.stderr.write(`${s}\n`),
-  initialize: async (profile, config) => {
-    const sessionOptions = {};
-    if (profile.webgpuBackend === 'vulkan') {
-      // Il setup mancante fallisce PRIMA di scaricare il modello. Backend unico,
-      // esplicito e non registrato come fallback dei provider standard.
-      const { registerVulkanBackend } = await import('./vulkan.js');
-      sessionOptions.executionProviders = [await registerVulkanBackend()];
-    }
-    const dir = await ensureTextModel(profile, config);
-    // Import lazy: config/status/doctor senza --probe non caricano il modello.
-    const { pipeline } = await import('@huggingface/transformers');
-    if (config.cpuThreads) sessionOptions.intraOpNumThreads = config.cpuThreads;
-    if (profile.device === 'dml') {
-      sessionOptions.executionMode = 'sequential';
-      sessionOptions.enableMemPattern = false;
-    }
-    let pipe;
-    try {
-      pipe = await pipeline('feature-extraction', dir, {
-        dtype: profile.dtype, device: profile.device, local_files_only: true,
-        session_options: sessionOptions,
-      });
-      const out = await pipe([QUERY_PREFIX + 'code retrieval smoke test'], { pooling: 'mean', normalize: true });
-      validateEmbeddings(out.tolist(), 1);
-      return pipe;
-    } catch (e) {
-      try { await pipe?.dispose(); } catch { /* conserva l'errore originale */ }
-      throw e;
-    }
-  },
-});
-
-export async function getEmbedder() {
-  return (await runtime.get()).pipe;
-}
-
-export async function getEmbeddingProfile() {
-  return (await runtime.get()).profile;
-}
-
-export function embeddingStatus() {
-  return runtime.info();
-}
+export const getEmbeddingProfile = () => client.getProfile();
+export const embeddingStatus = () => client.info();
+export const getServiceStatus = () => client.status();
+export const stopEmbeddingService = () => client.stop();
 
 /** Testi -> Float32Array[] finiti, normalizzati L2 per default. */
-export async function embed(texts, { normalize = true } = {}) {
+export async function embed(texts, options = {}) {
   if (!Array.isArray(texts) || texts.length === 0) return [];
-  const { pipe } = await runtime.get();
-  // Non fare fallback qui: l'indice è già associato al profilo selezionato.
-  const out = await pipe(texts, { pooling: 'mean', normalize });
-  const rows = validateEmbeddings(out.tolist(), texts.length);
-  return rows.map((row) => Float32Array.from(row));
+  return client.embed(texts, options);
 }
-
-export function embedQuery(q) {
-  return embed([QUERY_PREFIX + q]);
-}
-
+export function embedQuery(q) { return embed([QUERY_PREFIX + q]); }
 export function embedDocs(docs) {
   return embed(docs.map((d) => typeof d === 'string' ? d : docPrefix(d.path, d.title) + d.text));
 }
-
 export function cosine(a, b) {
   let dot = 0, na = 0, nb = 0;
   for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    na += a[i] * a[i];
-    nb += b[i] * b[i];
+    dot += a[i] * b[i]; na += a[i] * a[i]; nb += b[i] * b[i];
   }
   return dot / (Math.sqrt(na) * Math.sqrt(nb) || 1);
 }
-
 export async function modelDir() {
-  const { profile, config } = await runtime.get();
-  return modelPath(config, profile.dtype);
+  const profile = await client.getProfile();
+  return modelPath(client.info().config, profile.dtype);
+}
+
+export function formatServiceStatus(status) {
+  if (status.stopping) return `servizio condiviso: in arresto · PID ${status.pid} (rilascio delle risorse in corso)`;
+  if (!status.running) return `servizio condiviso: fermo (avvio automatico al prossimo embedding) · porta ${status.port}`;
+  const profile = status.profile;
+  return [`servizio condiviso: attivo · PID ${status.pid} · 127.0.0.1:${status.port}`,
+    `modello: ${profile ? `${profile.device}${profile.device === 'webgpu' ? `→${profile.webgpuBackend}` : ''}/${profile.dtype}` : status.initializing ? 'caricamento' : 'non caricato'}`,
+    `richieste attive/in coda: ${status.pending} · RSS servizio: ${Math.round(status.rssBytes / 1024 / 1024)} MiB`,
+    `uscita dopo inattività: ${status.idleMs} ms`].join('\n');
+}
+export async function serviceCommand(args, { service = client } = {}) {
+  const [action = 'status', ...rest] = args;
+  if (rest.some((arg) => arg !== '--json') || rest.length > 1 || (action !== 'status' && rest.length)) throw new Error('uso: service [status [--json]|stop]');
+  if (action === 'status') {
+    const status = await service.status();
+    return rest.includes('--json') ? JSON.stringify(status) : formatServiceStatus(status);
+  }
+  if (action === 'stop') {
+    const result = await service.stop();
+    return result.stopping ? `arresto del servizio condiviso richiesto (PID ${result.pid}); si riavvierà al prossimo embedding` : 'servizio condiviso già fermo';
+  }
+  throw new Error('uso: service [status [--json]|stop]');
 }