@alucard_24/pi-codeindex 1.0.0 → 1.1.1

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]');
 }

package/src/extension.js

@@ -10,41 +10,70 @@ import { Type } from '@earendil-works/pi-ai';
 import fs from 'node:fs';
 import path from 'node:path';
 import { indexRepo } from './indexer.js';
-import { embeddingStatus } from './embed.js';
+import { embeddingStatus, serviceCommand, getServiceStatus, formatServiceStatus } from './embed.js';
 import { formatProfile } from './backend.js';
 import { configCommand } from './config.js';
+import { readProjectState, writeProjectState } from './project-state.js';
 import { configure } from './config-ui.js';
 import { doctor, formatDoctor, parseDoctorArgs } from './doctor.js';
 import { loadIndex } from './store.js';
 import { invalidateSearcher, loadSearcher, search } from './search.js';
 import { buildBundle, buildGraph } from './graph.js';
 import { createDebouncedQueue, filterDirty, parsePorcelainStatus } from './sync.js';
-import { fmtBytes, git, headCommit, repoRoot } from './util.js';
+import { fmtBytes, git, headCommit } from './util.js';
+import { resolveWorkspace } from './workspace.js';
 import { formatBundle, formatHits, outlineText, promptLine, shouldAnnotateRead, statusLine, toRepoRel } from './present.js';
 
 const STATUS_KEY = 'codeindex';
 const DEFAULT_K = 8;
 const MAX_K = 30;
 const MAX_CAPS = { maxFiles: 5000, maxBytes: 200 * 1024 * 1024 };
-const CONFIG_ENTRY = 'codeindex-config';
 const DEBOUNCE_MS = 800;
 const MAX_SWEEP_PATHS = 200;
 
-let state = null; // { repo, enabled, indexing, progress, index, error, abort, queue, watcher, rerun }
+let state = null; // { repo, mode, enabled, indexing, progress, index, error, abort, queue, watcher, rerun }
 const running = new Map(); // repo -> promise (single-flight per repo)
 
-function readEnabled(ctx) {
-  try {
-    for (const entry of ctx.sessionManager.getBranch()) {
-      if (entry.type === 'custom' && entry.customType === CONFIG_ENTRY) {
-        const data = entry.data ?? {};
-        if (typeof data.enabled === 'boolean') return data.enabled;
-      }
+function applyEnabled(ctx, enabled, { start = true } = {}) {
+  const st = state;
+  st.enabled = enabled;
+  if (enabled) {
+    if (st.abort.signal.aborted) st.abort = new AbortController();
+    st.error = null;
+    if (start) {
+      if (!st.watcher) startWatcher(ctx);
+      void runIndex(ctx);
     }
-  } catch {
-    /* nessuno stato salvato: default attivo */
+  } else {
+    stopBackground();
+    st.index = null;
+    st.graph = null;
+    invalidateSearcher(st.repo);
+  }
+  showStatus(ctx);
+}
+
+async function syncProjectState(ctx, options = {}) {
+  const st = state;
+  if (!st) return false;
+  try {
+    const saved = await readProjectState(st.repo);
+    if (state !== st) return false;
+    if (st.error === st.activationError) st.error = null;
+    st.activationError = null;
+    st.activationFile = saved.file;
+    const enabled = saved.enabled && (st.autoIndex || st.manualConsent);
+    if (enabled !== st.enabled) applyEnabled(ctx, enabled, options);
+    return enabled;
+  } catch (e) {
+    if (state !== st) return false;
+    const changed = st.activationError !== e.message;
+    applyEnabled(ctx, false, options);
+    st.activationError = e.message;
+    st.error = e.message;
+    if (changed) ctx.ui.notify(`codeindex: ${e.message}`, 'warning');
+    return false;
   }
-  return true;
 }
 
 function showStatus(ctx) {
@@ -65,11 +94,13 @@ function showStatus(ctx) {
 
 /** Legge solo i metadati (per l'outline e la riga di stato): niente vettori. */
 async function refreshMeta() {
+  const st = state;
+  if (!st) return;
   try {
-    const { index } = await loadIndex(state.repo);
-    state.index = index;
+    const { index } = await loadIndex(st.repo);
+    if (state === st) st.index = index;
   } catch {
-    state.index = null;
+    if (state === st) st.index = null;
   }
 }
 
@@ -90,18 +121,20 @@ function runIndex(ctx, { force = false } = {}) {
     return inflight;
   }
 
+  const signal = st.abort.signal;
   const p = (async () => {
-    st.indexing = true;
-    st.rerun = false;
-    st.progress = null;
-    st.error = null;
-    showStatus(ctx);
     try {
+      if (!await syncProjectState(ctx, { start: false }) || state !== st || signal.aborted) return null;
+      st.indexing = true;
+      st.rerun = false;
+      st.progress = null;
+      st.error = null;
+      showStatus(ctx);
       const r = await indexRepo({
         root: repo,
         ...MAX_CAPS,
         force,
-        signal: st.abort.signal,
+        signal,
         log: () => {}, // niente rumore su stderr dentro la TUI
         onProgress: (p) => {
           if (state !== st) return; // sessione sostituita: non toccarne lo stato
@@ -109,17 +142,19 @@ function runIndex(ctx, { force = false } = {}) {
           showStatus(ctx);
         },
       });
+      if (state !== st || !st.enabled || signal.aborted) return null;
       st.index = r.index;
       const runtime = embeddingStatus();
-      if (state === st && st.enabled && !st.backendWarning && runtime.attempts.some((a) => !a.ok)) {
+      const warnings = [...runtime.warnings, ...runtime.attempts.filter((a) => !a.ok).map((a) => `${a.device}: ${a.error}`)];
+      if (state === st && st.enabled && !st.backendWarning && warnings.length) {
         st.backendWarning = true;
-        ctx.ui.notify(`codeindex: selezionato ${formatProfile(runtime.profile)}; tentativi falliti: ${runtime.attempts.filter((a) => !a.ok).map((a) => `${a.device}: ${a.error}`).join('; ')}`, 'warning');
+        ctx.ui.notify(`codeindex: selezionato ${formatProfile(runtime.profile)}; ${warnings.join('; ')}`, 'warning');
       }
       st.graph = null; // il grafo è derivato dall'indice: va ricostruito
       invalidateSearcher(repo);
       return r;
     } catch (e) {
-      if (st.abort.signal.aborted) return null;
+      if (signal.aborted) return null;
       st.error = e.message ?? String(e);
       if (state === st && st.enabled && !/abort/i.test(st.error)) {
         // Degradazione silenziosa: il tool resta disponibile e risponde con lo stato.
@@ -167,16 +202,22 @@ function stopBackground() {
 }
 
 /** Path toccati da watcher/hook: passa dal debounce e poi riconcilia. */
-function markDirty(paths) {
+function markDirty(paths, options) {
   if (!state?.queue) return;
-  const rel = filterDirty(paths, state.repo);
+  const rel = filterDirty(paths, state.repo, options);
   if (rel.size === 0) return;
   state.queue.add(rel);
 }
 
-/** `git status --porcelain -z` dopo un bash: cattura le modifiche indirette. */
-function sweepGitStatus() {
+/** Dopo bash: status Git, oppure riconciliazione incrementale senza Git. */
+function sweepChanges() {
   if (!state?.enabled || !state.repo) return;
+  if (state.mode === 'folder') {
+    // Non possiamo dedurre i path dal comando. La coda coalesca le richieste
+    // e indexRepo riusa i vettori invariati, anche senza watcher disponibile.
+    state.queue?.add(['.']);
+    return;
+  }
   // Costa ~50–100 ms su un repo grande: il watcher è il segnale primario, questo
   // è la rete di sicurezza. Un giro ogni 1,5 s basta.
   const now = Date.now();
@@ -190,9 +231,20 @@ function sweepGitStatus() {
 
 /** Watcher ricorsivo; se il sistema non lo consente si degrada senza watcher. */
 function startWatcher(ctx) {
+  const st = state;
+  if (!st?.enabled) return;
   try {
-    const watcher = fs.watch(state.repo, { recursive: true }, (_event, filename) => {
-      if (filename) markDirty([String(filename)]);
+    const watcher = fs.watch(st.repo, { recursive: true }, (event, filename) => {
+      if (state !== st || !st.enabled) return;
+      if (!filename) {
+        if (st.mode === 'folder') st.queue?.add(['.']);
+        return;
+      }
+      // Un rename può essere una directory intera: senza Git non esiste uno
+      // status successivo che recuperi i file aggiunti, spostati o cancellati.
+      markDirty([String(filename)], {
+        includeDirectories: st.mode === 'folder' && event === 'rename',
+      });
     });
     watcher.on('error', () => {
       try {
@@ -200,12 +252,12 @@ function startWatcher(ctx) {
       } catch {
         /* già chiuso */
       }
-      if (state) state.watcher = null;
+      if (st.watcher === watcher) st.watcher = null;
     });
-    state.watcher = watcher;
+    st.watcher = watcher;
   } catch (e) {
-    state.watcher = null;
-    ctx.ui.notify(`codeindex: watcher non disponibile (${e.message})`, 'warning');
+    st.watcher = null;
+    if (state === st) ctx.ui.notify(`codeindex: watcher non disponibile (${e.message})`, 'warning');
   }
 }
 
@@ -248,7 +300,7 @@ const searchCode = defineTool({
     })),
   }),
   async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-    if (!state?.repo) return unavailable('la directory corrente non è un repository git');
+    if (!state?.repo) return unavailable('nessuna cartella di progetto attiva');
     if (!state.enabled) return unavailable('indice disattivato (/codeindex enable per riattivarlo)');
 
     const k = Math.min(MAX_K, Math.max(1, Math.round(params.k ?? DEFAULT_K)));
@@ -312,23 +364,26 @@ async function annotateRead(event, ctx) {
 }
 
 function statusReport() {
-  if (!state) return 'codeindex: nessun repository git nella directory corrente';
+  if (!state) return 'codeindex: nessuna cartella di progetto attiva';
   const i = state.index;
   const lines = [
     `repo        : ${state.repo}`,
+    `modalità    : ${state.mode === 'git' ? 'repository Git' : 'cartella (senza Git)'}`,
     `stato       : ${state.enabled ? 'attivo' : 'disattivato'}${state.indexing ? ' · indicizzazione in corso' : ''}`,
   ];
   if (state.progress) lines.push(`progresso   : ${state.progress.done}/${state.progress.total} chunk`);
   if (i) {
     lines.push(`file        : ${i.stats?.files ?? '?'} (${fmtBytes(i.stats?.bytes ?? 0)})`);
     lines.push(`chunk       : ${i.chunks.length} · ${i.dims}d · ${i.model} (${i.dtype})`);
-    lines.push(`head        : ${i.head ?? '?'}`);
+    if (state.mode === 'git') lines.push(`head        : ${i.head ?? '?'}`);
     lines.push(`aggiornato  : ${i.updatedAt}`);
   } else {
-    lines.push('indice      : assente (usa /codeindex reindex)');
+    lines.push(state.enabled ? 'indice      : assente (usa /codeindex reindex)'
+      : 'indice      : non caricato (usa /codeindex enable)');
   }
+  if (state.activationFile) lines.push(`attivazione progetto: ${state.activationFile}`);
   const runtime = embeddingStatus();
-  lines.push(`runtime     : ${runtime.profile ? formatProfile(runtime.profile) : 'non caricato'}`);
+  lines.push(`profilo client: ${runtime.profile ? formatProfile(runtime.profile) : 'non ancora associato al servizio'}`);
   if (i?.device) lines.push(`profilo indice: ${formatProfile(i)}`);
   if (state.error) lines.push(`ultimo errore: ${state.error}`);
   return lines.join('\n');
@@ -338,7 +393,7 @@ export default function codeindexExtension(pi) {
   pi.registerTool(searchCode);
 
   pi.registerCommand('codeindex', {
-    description: 'Indice e embedding locali (status|reindex|enable|disable|config|configure|doctor)',
+    description: 'Indice e embedding locali (status|reindex|enable|disable|config|configure|doctor|service)',
     handler: async (args, ctx) => {
       const [sub = 'status', ...rest] = (args ?? '').trim().split(/\s+/).filter(Boolean);
       // Configurazione/diagnostica funzionano anche fuori da git o con indice spento.
@@ -352,9 +407,13 @@ export default function codeindexExtension(pi) {
           if (result) ctx.ui.notify(result, 'info');
           return;
         }
+        if (sub === 'service') {
+          ctx.ui.notify(await serviceCommand(rest), 'info');
+          return;
+        }
         if (sub === 'doctor') {
           const options = parseDoctorArgs(rest);
-          if (options.probe) ctx.ui.notify('codeindex: prova isolata del modello (può scaricare i pesi, timeout 120 s per backend)…', 'info');
+          if (options.probe) ctx.ui.notify('codeindex: prova isolata del modello (può caricare una copia aggiuntiva, scaricare pesi; timeout 120 s per backend)…', 'info');
           const report = await doctor(options);
           ctx.ui.notify(options.json ? JSON.stringify(report) : formatDoctor(report), report.ok ? 'info' : 'warning');
           return;
@@ -364,18 +423,27 @@ export default function codeindexExtension(pi) {
         return;
       }
       if (!state) {
-        ctx.ui.notify('codeindex: nessun repository git nella directory corrente', 'warning');
+        ctx.ui.notify('codeindex: nessuna cartella di progetto attiva', 'warning');
         return;
       }
       if (sub === 'status') {
         // La sessione può chiedere lo stato prima che il refresh in background
         // abbia finito: meglio aspettare che mentire ("indice assente").
-        if (!state.index) await refreshMeta();
+        await syncProjectState(ctx);
+        if (state.enabled && !state.index) await refreshMeta();
         showStatus(ctx);
-        ctx.ui.notify(statusReport(), 'info');
+        let service;
+        try { service = formatServiceStatus(await getServiceStatus()); }
+        catch (e) { service = `servizio condiviso: ${e.message}`; }
+        ctx.ui.notify(`${statusReport()}\n${service}`, 'info');
         return;
       }
       if (sub === 'reindex') {
+        await syncProjectState(ctx);
+        if (!state.enabled) {
+          ctx.ui.notify('codeindex: progetto disattivato; usa prima /codeindex enable', 'warning');
+          return;
+        }
         if (state.indexing) {
           ctx.ui.notify('codeindex: indicizzazione già in corso', 'warning');
           return;
@@ -385,41 +453,41 @@ export default function codeindexExtension(pi) {
         return;
       }
       if (sub === 'enable' || sub === 'disable') {
-        state.enabled = sub === 'enable';
-        if (state.enabled) {
-          // Un abort precedente resta sul vecchio controller: senza rinnovarlo
-          // ogni run futuro uscirebbe subito.
-          state.abort = new AbortController();
-          state.error = null;
-          if (!state.watcher) startWatcher(ctx);
-        } else {
-          stopBackground(); // watcher, coda, run in corso e rerun pendente
-        }
-        showStatus(ctx);
+        const st = state;
+        const enabled = sub === 'enable';
         try {
-          pi.appendEntry(CONFIG_ENTRY, { enabled: state.enabled });
-        } catch {
-          /* stato non persistito: vale per questa sessione */
+          const saved = await writeProjectState(st.repo, enabled);
+          if (state !== st) return;
+          st.activationFile = saved.file;
+          st.activationError = null;
+          st.error = null;
+          st.manualConsent = enabled;
+          applyEnabled(ctx, enabled);
+          ctx.ui.notify(`codeindex: ${enabled ? 'attivo' : 'disattivato'} per questo progetto (${st.repo})`, 'info');
+        } catch (e) {
+          ctx.ui.notify(`codeindex: attivazione progetto non salvata (${e.message})`, 'error');
         }
-        if (state.enabled) void runIndex(ctx);
-        ctx.ui.notify(`codeindex: ${state.enabled ? 'attivo' : 'disattivato'}`, 'info');
         return;
       }
-      ctx.ui.notify('uso: /codeindex status|reindex [--force]|enable|disable|config [show|set CHIAVE VALORE|unset CHIAVE]|configure|doctor [--probe] [--all] [--device DEVICE] [--webgpu-backend auto|vulkan]', 'warning');
+      ctx.ui.notify('uso: /codeindex status|reindex [--force]|enable|disable|config [show|set CHIAVE VALORE|unset CHIAVE]|configure|service [status [--json]|stop]|doctor [--probe] [--all] [--device DEVICE] [--webgpu-backend auto|vulkan]', 'warning');
     },
   });
 
   // Risorse di sessione: watcher e timer non vanno creati nel factory.
   pi.on('session_start', async (_event, ctx) => {
-    const repo = repoRoot(ctx.cwd);
-    if (!repo) {
-      state = null;
-      ctx.ui.setStatus(STATUS_KEY, undefined);
-      return;
-    }
+    stopBackground();
+    invalidateSearcher();
+    const workspace = resolveWorkspace(ctx.cwd);
     const st = {
-      repo,
-      enabled: readEnabled(ctx),
+      repo: workspace.root,
+      mode: workspace.mode,
+      // Le cartelle protette richiedono consenso a ogni nuova sessione,
+      // anche se un enable era stato salvato nel branch in un altro progetto.
+      enabled: false,
+      autoIndex: workspace.autoIndex,
+      manualConsent: false,
+      activationFile: null,
+      activationError: null,
       indexing: false,
       progress: null,
       index: null,
@@ -434,8 +502,14 @@ export default function codeindexExtension(pi) {
       if (state === st && st.enabled) void runIndex(ctx);
     }, { delayMs: DEBOUNCE_MS });
     state = st;
+    await syncProjectState(ctx, { start: false });
+    if (state !== st) return;
     showStatus(ctx);
-    // Non bloccare l'avvio: metadati, watcher e indice corrono in background.
+    if (!workspace.autoIndex && !st.enabled) {
+      ctx.ui.notify('codeindex: indicizzazione automatica disattivata nella home o nella radice del disco; usa una cartella di progetto o /codeindex enable', 'info');
+    }
+    if (!st.enabled) return;
+    // Solo i progetti abilitati caricano metadati, watcher e indice.
     void (async () => {
       await refreshMeta();
       if (state !== st) return;
@@ -455,12 +529,16 @@ export default function codeindexExtension(pi) {
   // Una riga stabile nel system prompt rende il tool scopribile; i conteggi
   // esatti restano nel footer per non invalidare la prompt cache a ogni run.
   pi.on('before_agent_start', async (event, ctx) => {
+    await syncProjectState(ctx);
     showStatus(ctx);
     if (!state?.enabled) return undefined; // spento: nessuna riga nel prompt
     // Un checkout può cambiare HEAD senza eventi utili del watcher.
-    if (!state.indexing && state.index?.head && headCommit(state.repo) !== state.index.head) {
+    if (state.mode === 'git' && !state.indexing && state.index?.head && headCommit(state.repo) !== state.index.head) {
       void runIndex(ctx);
     }
+    // Senza watcher e senza Git, un nuovo prompt recupera anche le modifiche
+    // esterne a pi. Nessun polling o processo aggiuntivo.
+    if (state.mode === 'folder' && !state.watcher) state.queue?.add(['.']);
     const line = promptLine(state?.index?.chunks?.length ?? 0);
     if (!line) return undefined;
     return { systemPrompt: `${event.systemPrompt}\n\n${line}` };
@@ -468,15 +546,20 @@ export default function codeindexExtension(pi) {
 
   // Invalidazione diretta: `write`/`edit` sanno esattamente che path hanno toccato.
   pi.on('tool_result', async (event, ctx) => {
-    if (event.isError || !state?.enabled) return undefined;
+    await syncProjectState(ctx);
+    if (!state?.enabled) return undefined;
     try {
+      // Anche un comando terminato con errore può aver modificato dei file.
+      if (event.toolName === 'bash') {
+        sweepChanges();
+        return undefined;
+      }
+      if (event.isError) return undefined;
       if (event.toolName === 'read') return await annotateRead(event, ctx);
       if (event.toolName === 'write' || event.toolName === 'edit') {
         markDirty([String(event.input?.path ?? '')]);
         return undefined;
       }
-      // Dopo un bash il filesystem può essere cambiato in modo invisibile agli hook.
-      if (event.toolName === 'bash') sweepGitStatus();
     } catch {
       return undefined; // un hook non deve mai rompere un tool
     }

package/src/local-embed.js

@@ -0,0 +1,51 @@
+// Solo nel servizio e nei probe esplicitamente isolati. I client pi non
+// importano Transformers/ORT e non possiedono una pipeline nativa.
+import { createEmbeddingRuntime, nativeBackends, validateEmbeddings, QUERY_PREFIX } from './backend.js';
+import { ensureTextModel } from './model.js';
+
+export function createLocalEmbedder(config) {
+  const runtime = createEmbeddingRuntime({
+    settings: () => ({ config }),
+    inventory: async () => nativeBackends().backends,
+    log: (s) => process.stderr.write(`${s}\n`),
+    initialize: async (profile, settings) => {
+      const sessionOptions = {};
+      if (profile.webgpuBackend === 'vulkan') {
+        const { registerVulkanBackend } = await import('./vulkan.js');
+        sessionOptions.executionProviders = [await registerVulkanBackend()];
+      }
+      const dir = await ensureTextModel(profile, settings);
+      const { pipeline } = await import('@huggingface/transformers');
+      if (settings.cpuThreads) sessionOptions.intraOpNumThreads = settings.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;
+      }
+    },
+  });
+  return {
+    getProfile: async () => (await runtime.get()).profile,
+    info: () => runtime.info(),
+    embed: async (texts, { normalize = true } = {}) => {
+      const { pipe } = await runtime.get();
+      // Non cambiare provider dopo la prima inferenza riuscita.
+      const out = await pipe(texts, { pooling: 'mean', normalize });
+      return validateEmbeddings(out.tolist(), texts.length);
+    },
+    dispose: async () => {
+      if (runtime.info().profile) await (await runtime.get()).pipe.dispose();
+    },
+  };
+}

package/src/probe.js

@@ -1,20 +1,23 @@
 // Entry point interno, eseguito solo da doctor --probe in un processo isolato.
-import { embed, cosine, getEmbeddingProfile, embeddingStatus, getEmbedder } from './embed.js';
+import { cosine } from './embed.js';
+import { loadConfig } from './config.js';
+import { createLocalEmbedder } from './local-embed.js';
 
-let result;
+let result, runtime;
 try {
   const t0 = performance.now();
+  runtime = createLocalEmbedder((await loadConfig()).config);
   const same = 'title: args.ts | text: export function parseArgs(argv) { return argv.slice(2); }';
   const other = 'title: math.py | text: def factorial(n): return 1 if n < 2 else n * factorial(n - 1)';
-  const [a, b, c] = await embed([same, same, other]);
+  const [a, b, c] = await runtime.embed([same, same, other]);
   const cosSame = cosine(a, b);
   const cosOther = cosine(a, c);
   if (cosSame < 0.999 || cosOther > 0.9999) throw new Error(`smoke test discriminazione fallito: stesso=${cosSame}, diverso=${cosOther}`);
-  result = { ok: true, profile: await getEmbeddingProfile(), elapsedMs: Math.round(performance.now() - t0),
-    cosSame, cosOther, attempts: embeddingStatus().attempts };
-  await (await getEmbedder()).dispose();
+  result = { ok: true, profile: await runtime.getProfile(), elapsedMs: Math.round(performance.now() - t0),
+    cosSame, cosOther, attempts: runtime.info().attempts };
+  await runtime.dispose();
 } catch (e) {
-  result = { ok: false, error: String(e.message ?? e), attempts: embeddingStatus().attempts };
+  result = { ok: false, error: String(e.message ?? e), attempts: runtime?.info().attempts ?? [] };
 }
 if (process.send) process.send(result, () => process.exit(result.ok ? 0 : 1));
 else { console.log(JSON.stringify(result)); process.exitCode = result.ok ? 0 : 1; }