@alucard_24/pi-codeindex 1.0.0 → 1.1.1

package/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+## 1.1.1
+
+- Porta loopback predefinita `43127`, sempre configurabile; l'override esplicito
+  `0` conserva la scelta deterministica precedente. Nessuna garanzia che una
+  porta fissa sia libera o non esclusa su ogni macchina.
+- Attivazione dell'integrazione pi persistente **per progetto**, spenta in
+  assenza di consenso. `/codeindex enable|disable` salva la scelta fuori dai
+  sorgenti; progetti e sessioni non si abilitano globalmente a vicenda.
+- Il servizio embedding resta condiviso. Disabilitare un progetto annulla
+  watcher/indicizzazione e libera le cache del client, senza arrestare il
+  modello eventualmente usato da altri progetti.
+- Gli errori `listen EACCES` suggeriscono una porta alternativa configurabile,
+  senza fallback in-process. Nessuna correzione dichiarata per il timeout
+  intermittente segnalato su Windows: la causa resta da diagnosticare.
+- Nessun caricamento automatico dell'indice o reindex a progetto spento.
+  I vecchi flag di sessione non vengono migrati in consenso per un progetto.
+- Prima di cambiare porta, arrestare il servizio con la configurazione
+  precedente e riavviare i client. Anche il nuovo default richiede questa
+  precauzione se è ancora presente un servizio della versione precedente.
+
+## 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,15 @@
 # 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)>/`.
+
+**Default dalla versione 1.1.1:** porta locale `43127`; integrazione pi
+spenta nei progetti mai abilitati. `/codeindex enable` salva il consenso
+**per progetto**, mentre il modello resta condiviso fra i progetti attivi.
 
 ## Requisiti
 
@@ -18,7 +24,7 @@ database: due file in `~/.cache/pi-codeindex/<sha1(repo)>/`.
 ### Da npm, solo su richiesta
 
 ```bash
-pi -e npm:@alucard_24/pi-codeindex@1.0.0
+pi -e npm:@alucard_24/pi-codeindex@1.1.1
 ```
 
 Carica il pacchetto per questa invocazione, senza aggiungerlo alle impostazioni
@@ -50,11 +56,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 +137,72 @@ 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`, sulla porta predefinita **`43127`**, con
+autenticazione tramite token in `~/.cache/pi-codeindex/service/`
+(directory 0700, record 0600 su POSIX). Il binding esclusivo della porta
+impedisce due avvii simultanei sullo stesso endpoint. Nessuna porta è garantita
+su tutte le macchine: se occupata o esclusa dal sistema, scegli una porta
+libera con `/codeindex config set servicePort NUMERO` e riavvia pi.
+Su Windows `netsh interface ipv4 show excludedportrange protocol=tcp` mostra
+gli intervalli esclusi; non cancellare le prenotazioni del sistema.
+
+Usa gli stessi `serviceDir`/`servicePort` in tutti i client per condividere il
+modello. **Arresta il vecchio servizio inattivo prima di cambiare porta**
+(`/codeindex service stop` con la configurazione precedente), poi chiudi e
+riapri i client. Questo vale anche per il passaggio dalla porta automatica
+della 1.1.0 al nuovo default: un vecchio record può riferirsi alla porta
+precedente. Gli override già salvati non vengono sovrascritti; `servicePort: 0`
+mantiene esplicitamente la scelta deterministica precedente.
+Directory diverse e porte diverse permettono deliberatamente più modelli;
+una stessa directory non va usata contemporaneamente con porte diverse.
+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 +215,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 +250,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` | default **43127**; 1024–65535, oppure 0 per la scelta deterministica precedente; 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 +279,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
@@ -220,11 +303,43 @@ node src/cli.js embed-test
   mai dal repo.
 - `eval` misura recall@3/@8 e latenza sulle query della fixture.
 
+## Attivazione per progetto
+
+Il caricamento dell'estensione non abilita automaticamente un progetto.
+Prima del consenso non vengono avviati modello, download, indicizzazione,
+watcher o caricamento automatico dell'indice. Configurazione, stato e
+`doctor` restano disponibili; `doctor --probe` richiede esplicitamente il modello.
+
+```text
+/codeindex enable    # abilita solo il progetto corrente, anche per le sessioni future
+/codeindex disable   # disabilita solo quel progetto, senza fermare il modello condiviso
+/codeindex status    # mostra radice, stato e percorso del file di attivazione
+```
+
+La scelta è salvata fuori dai sorgenti, in
+`projects/<sha256(radice canonica)>.json` accanto al file restituito da
+`/codeindex config path` (normalmente `~/.config/pi-codeindex/projects/`,
+oppure `%APPDATA%\\pi-codeindex\\projects\\` su Windows).
+Non viene aggiunto un flag globale di attivazione alla configurazione di pi
+o al profilo embedding. Symlink e differenze di maiuscole su Windows non
+creano consensi separati per lo stesso percorso canonico.
+
+Nei repository Git la scelta vale per l'intera radice Git, anche dalle
+sottocartelle. Senza Git vale per la cartella di avvio. Gli altri client dello
+stesso progetto rileggono la scelta al prompt, alle richieste di stato/reindex
+e prima di indicizzare; i progetti diversi mantengono il proprio stato.
+
+I vecchi flag nel branch della sessione non abilitano implicitamente un
+progetto: dopo l'aggiornamento usa `/codeindex enable` una volta per progetto.
+Stato corrotto o illeggibile significa spento con avviso, non consenso implicito.
+`/codeindex reindex` a progetto spento invita prima ad abilitarlo; i comandi CLI
+espliciti di indice/ricerca non cambiano il consenso dell'integrazione pi.
+
 ## Uso dentro pi
 
 ```bash
 # pacchetto npm: solo questa invocazione, nessuna configurazione globale
-pi -e npm:@alucard_24/pi-codeindex@1.0.0
+pi -e npm:@alucard_24/pi-codeindex@1.1.1
 
 # in sviluppo, dalla directory del progetto
 pi -e ./src/extension.js
@@ -247,18 +362,46 @@ Cosa aggiunge:
   durante l'indicizzazione).
 - **`/codeindex status|reindex [--force]|enable|disable|config|configure|doctor`**. `disable` spegne
   tutto: tool, outline, riga di stato, riga nel system prompt, watcher e
-  indicizzazione in corso. Lo stato è persistito nel branch della sessione;
-  una sessione nuova riparte attiva.
-- **indicizzazione automatica** all'avvio della sessione, in background,
+  indicizzazione in corso. Lo stato è persistito **per progetto**, non nel
+  branch della sessione e non globalmente. Disabilitare libera anche le cache
+  dell'indice e del grafo di quel client, senza fermare il servizio condiviso.
+- **indicizzazione automatica solo nei progetti già abilitati**, 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 +410,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": 43127, "description": "Porta TCP loopback predefinita 43127, da cambiare se occupata o esclusa dal sistema. 0 mantiene la scelta deterministica precedente. Arrestare il vecchio servizio prima di cambiare porta nella stessa directory." },
+    "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.1",
   "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: 43127, 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');
 }