gitnexus 1.6.10-rc.85 → 1.6.10-rc.87

package/dist/cli/doctor.js

@@ -4,7 +4,7 @@ import { isHttpMode } from '../core/embeddings/http-client.js';
 import { getLocalEmbeddingRuntimeBlocker, localEmbeddingPrefixUnloadableMessage, localEmbeddingStackMissingMessage, } from '../core/embeddings/runtime-support.js';
 import { isPrefixRuntimeLoadable, resolveEmbeddingRuntime, } from '../core/embeddings/runtime-install.js';
 import { cudaRedirectDoctorStatus } from '../core/embeddings/onnxruntime-node-resolver.js';
-import { checkLbugNative, probeFtsExtensionLoad } from '../core/lbug/native-check.js';
+import { checkLbugNative, probeFtsExtensionLoad, probeVectorExtensionLoad, } from '../core/lbug/native-check.js';
 import { getOsPageSize, isPageSizeAwareLadybug } from '../core/lbug/lbug-config.js';
 import { diagnoseExtensionLoad } from '../core/lbug/extension-load-error.js';
 import { getExtensionInstallPolicy } from '../core/lbug/extension-loader.js';
@@ -162,8 +162,26 @@ export const doctorCommand = async () => {
             console.log(`  ${padDisplayEnd('', 18)}${remedy}`);
         }
     }
-    console.log(`  ${label('doctor.labels.vectorIndex', 18)}${capabilities.vector}`);
-    console.log(`  ${label('doctor.labels.semanticMode', 18)}${capabilities.semanticMode}`);
+    // Live LOAD probe for VECTOR too (#2623). The static capability is just
+    // `platform !== 'win32'`, so it printed "available" on the very machines
+    // where analyze was failing to load the extension — the same contradiction
+    // #2374 fixed for FTS above, and exactly what #2623's reporter saw while
+    // every incremental analyze died on an unloaded VECTOR extension.
+    const vectorProbe = nativeCheck.ok
+        ? await probeVectorExtensionLoad()
+        : { loaded: false, reason: 'LadybugDB native module (lbugjs.node) failed to load' };
+    console.log(`  ${label('doctor.labels.vectorIndex', 18)}${vectorProbe.loaded ? 'available' : 'unavailable'}`);
+    if (!vectorProbe.loaded && vectorProbe.reason) {
+        console.log(`  ${padDisplayEnd('', 18)}${vectorProbe.reason}`);
+        const { kind, remedy } = diagnoseExtensionLoad(vectorProbe.reason, 'VECTOR');
+        if (kind !== 'unknown') {
+            console.log(`  ${padDisplayEnd('', 18)}${remedy}`);
+        }
+    }
+    // Semantic mode follows the probe, not the platform: without a loadable
+    // VECTOR extension the index can be neither built nor queried, so search is
+    // really on exact scan no matter what the platform would allow.
+    console.log(`  ${label('doctor.labels.semanticMode', 18)}${vectorProbe.loaded ? capabilities.semanticMode : 'exact-scan'}`);
     // Surface the optional-extension install policy so offline users can see
     // whether analyze/query will reach the network (extension.ladybugdb.com).
     // Literal label (like the 'native' line) to avoid adding i18n keys.

package/dist/core/lbug/extension-load-error.d.ts

@@ -20,7 +20,7 @@ export declare const FILE_CORRUPTION_SIGNATURES: readonly RegExp[];
  * Windows download (error 193, matched by `/not a valid/i`) routes to
  * FORCE-reinstall rather than to the runtime-install remedy.
  */
-export declare function classifyExtensionLoadError(reason: string | undefined | null): ExtensionLoadDiagnosis;
+export declare function classifyExtensionLoadError(reason: string | undefined | null, label?: string): ExtensionLoadDiagnosis;
 /** Well-formedness of the extension binary for the host platform + arch. */
 export type ExtensionBinaryState = 'absent' | 'corrupt' | 'valid' | 'indeterminate';
 /**
@@ -63,5 +63,5 @@ export declare function inspectExtensionBinary(extensionPath: string | null | un
  * classifier (which still carries the language-independent hedged fallback). This
  * is the entry point every surface should call.
  */
-export declare function diagnoseExtensionLoad(reason: string | undefined | null): ExtensionLoadDiagnosis;
+export declare function diagnoseExtensionLoad(reason: string | undefined | null, label?: string): ExtensionLoadDiagnosis;
 export {};

package/dist/core/lbug/extension-load-error.js

@@ -85,26 +85,30 @@ const POSIX_MISSING_DEPENDENCY_SIGNATURES = [
  * display language — the only localized part is the OS-error tail after it. So
  * it is the language-independent fallback signal once the specific tails miss: a
  * French/German/Japanese Windows 126 has a localized tail we cannot enumerate,
- * but it still carries this wrapper. See HEDGED_LOAD_FAILURE_REMEDY.
+ * but it still carries this wrapper. See hedgedLoadFailureRemedy.
  */
 const LOAD_FAILURE_WRAPPER = /failed to load library/i;
-const MISSING_FILE_REMEDY = 'The FTS extension is not installed. Re-run with network access and ' +
-    'GITNEXUS_LBUG_EXTENSION_INSTALL=auto (or `gitnexus analyze --repair-fts`) to download it.';
-const CORRUPT_FILE_REMEDY = 'The FTS extension file is present but unreadable (corrupt, truncated, or built for another ' +
-    'platform). Re-download it with network access and GITNEXUS_LBUG_EXTENSION_INSTALL=auto ' +
-    '(`gitnexus analyze --repair-fts`).';
+// Remedies are label-parameterized (#2623 follow-up): doctor now live-probes
+// VECTOR through the same classifier, and FTS-specific advice (`--repair-fts`
+// repairs FTS indexes only) must not be dispensed for other extensions.
+const repairFtsHint = (label, lead) => label === 'FTS' ? ` (${lead}\`gitnexus analyze --repair-fts\`)` : '';
+const missingFileRemedy = (label) => `The ${label} extension is not installed. Re-run with network access and ` +
+    `GITNEXUS_LBUG_EXTENSION_INSTALL=auto${repairFtsHint(label, 'or ')} to download it.`;
+const corruptFileRemedy = (label) => `The ${label} extension file is present but unreadable (corrupt, truncated, or built for another ` +
+    `platform). Re-download it with network access and ` +
+    `GITNEXUS_LBUG_EXTENSION_INSTALL=auto${repairFtsHint(label, '')}.`;
 // Single source of truth for the VC++ runtime-install pointer, shared by the
 // Windows-126 and structural missing-dependency remedies so the name/URL cannot
 // drift between them (#2383 F5).
 const VC_REDIST_INSTALL_HINT = 'the Microsoft Visual C++ 2015-2022 Redistributable (x64) from ' +
     'https://aka.ms/vs/17/release/vc_redist.x64.exe';
 // MSVC-first per DuckDB's canonical answer for this exact error; OpenSSL second.
-const WINDOWS_MISSING_DEPENDENCY_REMEDY = 'The FTS extension is present but a required runtime library is missing (Windows error 126). ' +
+const windowsMissingDependencyRemedy = (label) => `The ${label} extension is present but a required runtime library is missing (Windows error 126). ` +
     'Reinstalling the extension will NOT help. Install ' +
     VC_REDIST_INSTALL_HINT +
     '; if the error persists, the extension also needs OpenSSL 3 ' +
     '(libcrypto-3-x64.dll / libssl-3-x64.dll) on the DLL search path.';
-const POSIX_MISSING_DEPENDENCY_REMEDY = 'The FTS extension is present but a shared library it depends on could not be loaded (named in ' +
+const posixMissingDependencyRemedy = (label) => `The ${label} extension is present but a shared library it depends on could not be loaded (named in ` +
     'the error above). Reinstalling the extension will NOT help — install that library or add it to ' +
     'your loader search path.';
 // Language-independent fallback: we know the extension failed to load, but the
@@ -113,13 +117,15 @@ const POSIX_MISSING_DEPENDENCY_REMEDY = 'The FTS extension is present but a shar
 // branches — rather than confidently prescribing the wrong single fix. The clean
 // long-term fix is upstream: have LadybugDB include the numeric GetLastError/errno
 // in the message (as it already does elsewhere), so this becomes a code match.
-const HEDGED_LOAD_FAILURE_REMEDY = 'The FTS extension file was found but could not be loaded — see the "Error:" text above (shown ' +
+const hedgedLoadFailureRemedy = (label) => `The ${label} extension file was found but could not be loaded — see the "Error:" text above (shown ` +
     "in your system's language). Reinstalling usually will not help. If it names a missing module or " +
     'library, install the required runtime (on Windows: the Microsoft Visual C++ 2015-2022 ' +
-    'Redistributable x64 and OpenSSL 3); if it names a corrupt or invalid file, run ' +
-    '`gitnexus analyze --repair-fts` to re-download.';
-const UNKNOWN_REMEDY = 'The FTS extension failed to load for an unrecognized reason. Run `gitnexus doctor` for live ' +
-    'FTS status and verify the extension file and platform.';
+    'Redistributable x64 and OpenSSL 3); if it names a corrupt or invalid file, ' +
+    (label === 'FTS'
+        ? 'run `gitnexus analyze --repair-fts` to re-download.'
+        : 're-run analyze with network access and GITNEXUS_LBUG_EXTENSION_INSTALL=auto to re-download.');
+const unknownRemedy = (label) => `The ${label} extension failed to load for an unrecognized reason. Run \`gitnexus doctor\` for live ` +
+    `${label} status and verify the extension file and platform.`;
 const matchesAny = (reason, signatures) => signatures.some((re) => re.test(reason));
 /**
  * Classify a collapsed LadybugDB LOAD error. Order is most-specific-first and is
@@ -127,19 +133,19 @@ const matchesAny = (reason, signatures) => signatures.some((re) => re.test(reaso
  * Windows download (error 193, matched by `/not a valid/i`) routes to
  * FORCE-reinstall rather than to the runtime-install remedy.
  */
-export function classifyExtensionLoadError(reason) {
+export function classifyExtensionLoadError(reason, label = 'FTS') {
     const text = reason ?? '';
     if (matchesAny(text, MISSING_FILE_SIGNATURES)) {
-        return { kind: 'missing_file', remedy: MISSING_FILE_REMEDY };
+        return { kind: 'missing_file', remedy: missingFileRemedy(label) };
     }
     if (matchesAny(text, FILE_CORRUPTION_SIGNATURES)) {
-        return { kind: 'corrupt_file', remedy: CORRUPT_FILE_REMEDY };
+        return { kind: 'corrupt_file', remedy: corruptFileRemedy(label) };
     }
     if (matchesAny(text, WINDOWS_MISSING_DEPENDENCY_SIGNATURES)) {
-        return { kind: 'missing_dependency', remedy: WINDOWS_MISSING_DEPENDENCY_REMEDY };
+        return { kind: 'missing_dependency', remedy: windowsMissingDependencyRemedy(label) };
     }
     if (matchesAny(text, POSIX_MISSING_DEPENDENCY_SIGNATURES)) {
-        return { kind: 'missing_dependency', remedy: POSIX_MISSING_DEPENDENCY_REMEDY };
+        return { kind: 'missing_dependency', remedy: posixMissingDependencyRemedy(label) };
     }
     // Language-independent fallback: the extension demonstrably failed to load
     // (lbug's English wrapper is present) but the localized OS tail matched no
@@ -147,11 +153,11 @@ export function classifyExtensionLoadError(reason) {
     // remedy — strictly better than the generic `unknown` for non-English hosts,
     // and it never prescribes the wrong fix.
     if (LOAD_FAILURE_WRAPPER.test(text)) {
-        return { kind: 'missing_dependency', remedy: HEDGED_LOAD_FAILURE_REMEDY };
+        return { kind: 'missing_dependency', remedy: hedgedLoadFailureRemedy(label) };
     }
-    return { kind: 'unknown', remedy: UNKNOWN_REMEDY };
+    return { kind: 'unknown', remedy: unknownRemedy(label) };
 }
-const STRUCTURAL_MISSING_DEPENDENCY_REMEDY = 'The FTS extension file is valid, so the failure is a missing or incompatible runtime dependency, ' +
+const structuralMissingDependencyRemedy = (label) => `The ${label} extension file is valid, so the failure is a missing or incompatible runtime dependency, ` +
     'not the extension itself — reinstalling will NOT help. On Windows, install ' +
     VC_REDIST_INSTALL_HINT +
     ' and ensure OpenSSL 3 is available; on Linux/macOS install the shared library named in the error above.';
@@ -284,12 +290,12 @@ export function inspectExtensionBinary(extensionPath) {
  * classifier (which still carries the language-independent hedged fallback). This
  * is the entry point every surface should call.
  */
-export function diagnoseExtensionLoad(reason) {
+export function diagnoseExtensionLoad(reason, label = 'FTS') {
     const text = reason ?? '';
-    const stringResult = classifyExtensionLoadError(text);
+    const stringResult = classifyExtensionLoadError(text, label);
     const fileState = inspectExtensionBinary(extractExtensionPath(text));
     if (fileState === 'corrupt') {
-        return { kind: 'corrupt_file', remedy: CORRUPT_FILE_REMEDY };
+        return { kind: 'corrupt_file', remedy: corruptFileRemedy(label) };
     }
     if (fileState === 'valid') {
         // The structural probe only inspects the first BINARY_HEADER_BYTES, so a file
@@ -307,7 +313,7 @@ export function diagnoseExtensionLoad(reason) {
         // sharper remedy when it recognized the specific case (e.g. English 126).
         const remedy = stringResult.kind === 'missing_dependency'
             ? stringResult.remedy
-            : STRUCTURAL_MISSING_DEPENDENCY_REMEDY;
+            : structuralMissingDependencyRemedy(label);
         return { kind: 'missing_dependency', remedy };
     }
     // 'absent' or 'indeterminate' → no positive structural evidence, so defer to the

package/dist/core/lbug/extension-loader.js

@@ -215,7 +215,7 @@ export class ExtensionManager {
             name,
             loaded: false,
             reason,
-            diagnosis: diagnoseExtensionLoad(reason),
+            diagnosis: diagnoseExtensionLoad(reason, label),
         });
         const key = `${name}:${reason}`;
         if (this.warnedKeys.has(key))

package/dist/core/lbug/lbug-adapter.d.ts

@@ -484,6 +484,40 @@ export declare const createFTSIndex: (tableName: string, indexName: string, prop
  * failure propagates so the caller can log it.
  */
 export declare const createVectorIndex: () => Promise<boolean>;
+/**
+ * Make DML against {@link EMBEDDING_TABLE_NAME} legal on the writable
+ * connection when it can be, and report whether it is.
+ *
+ * LadybugDB refuses EVERY mutation of a table carrying an HNSW index while
+ * the VECTOR extension is not loaded on that connection: `DELETE` fails with
+ * "Trying to delete from an index on table CodeEmbedding but its extension is
+ * not loaded", `CREATE` with the matching "insert into an index" variant,
+ * `DROP TABLE` is refused while the index references it, and `SET` — even on
+ * a NON-indexed property — segfaults the process outright. Probed against
+ * @ladybugdb/core 0.18.2 (the lockfile-pinned version) and 0.18.0 — every
+ * result identical on both (#2623).
+ *
+ * Dropping the index is NOT an available recovery: `CALL DROP_VECTOR_INDEX`
+ * is itself a VECTOR-extension function and resolves to "Catalog exception:
+ * function DROP_VECTOR_INDEX is not defined" in exactly the state it would
+ * need to rescue. Loading the extension is the only in-place repair, which is
+ * why this returns a verdict instead of attempting a fixup.
+ *
+ * `true` = embedding-row DML is safe: either VECTOR is now loaded, or the
+ * table carries no index to trip over. `false` = genuinely blocked (index
+ * present, extension unloadable); the analyze orchestrator answers that by
+ * escalating to the wipe-and-rebuild write plan instead of failing
+ * mid-writeback.
+ *
+ * Cheap by construction: one local `SHOW_INDEXES` read settles the common
+ * "this repo never built an embedding index" case without touching the
+ * extension machinery at all, so a VECTOR-less machine is not charged a
+ * bounded INSTALL attempt on every incremental analyze. `SHOW_INDEXES` is
+ * readable WITHOUT the extension and reports `extension_loaded` per index, so
+ * no error-string sniffing is needed; it runs through the unprepared
+ * `conn.query()` path like every other `CALL` procedure here (#2114).
+ */
+export declare const ensureEmbeddingRowDmlSafe: () => Promise<boolean>;
 /**
  * Lazy-create an FTS index, caching the fact in-process.
  *

package/dist/core/lbug/lbug-adapter.js

@@ -13,10 +13,9 @@ import { NODE_TABLES, REL_TABLE_NAME, SCHEMA_QUERIES, EMBEDDING_TABLE_NAME, CREA
 import { streamAllCSVsToDisk } from './csv-generator.js';
 import { getNodeLabel as deriveNodeLabel } from './rel-pair-routing.js';
 import { EMBEDDABLE_LABELS } from '../embeddings/types.js';
-import { extensionManager } from './extension-loader.js';
+import { extensionManager, resolveAnalyzeInstallPolicy, } from './extension-loader.js';
 import { classifyDeleteAllError, closeLbugConnection, HANDLE_RELEASE_PROBE_ATTEMPTS, HANDLE_RELEASE_PROBE_DELAY_MS, isDbBusyError, isOpenRetryExhausted, isWalCorruptionError, openLbugConnection, sleep, toNativeSafePath, resolveNativeSafeStorageDir, WAL_RECOVERY_SUGGESTION, waitForWindowsHandleRelease, } from './lbug-config.js';
 import { finalizeLbugSidecarsAfterClose, guardWalQuarantine, isMissingShadowSidecarError, isReadOnlyShadowReplayError, lbugLockRemediation, preflightLbugSidecars, quarantineWalForMissingShadow, renameFailureMessage, shadowSidecarRecoveryMessage, } from './sidecar-recovery.js';
-import { isVectorExtensionSupportedByPlatform } from '../platform/capabilities.js';
 import { logger } from '../logger.js';
 /**
  * Split a relationship CSV into per-label-pair files on disk.
@@ -2396,16 +2395,16 @@ export const loadVectorExtension = async (targetConn, opts = {}) => {
     const useModuleState = targetConn === undefined;
     if (useModuleState && vectorExtensionLoaded)
         return true;
-    // INSTALL VECTOR crashes with SIGSEGV on Windows: the KuzuDB native extension
-    // installer has an unhandled error path on Windows that raises a fatal signal
-    // that JS try/catch cannot intercept. Skip loading — vector/embedding search
-    // is unavailable but all graph index queries still work. Do NOT set
-    // vectorExtensionLoaded here: the flag means "successfully loaded", and a
-    // subsequent call would otherwise short-circuit to `return true` at the top.
-    if (process.platform === 'win32')
-        return false;
-    if (!isVectorExtensionSupportedByPlatform())
-        return false;
+    // No platform gate. Windows was hard-refused here for years on the strength
+    // of an early-era report that in-process INSTALL VECTOR could SIGSEGV
+    // (#1365) — but the extension server ships win_amd64 VECTOR artifacts for
+    // every 0.18.x extension version (probed live: v0.18.0 and v0.18.1 both
+    // serve a real PE32+ DLL; the pinned 0.18.2 core resolves its extension
+    // directory to 0.18.1, strace-verified), and INSTALL now runs in a spawned
+    // child process (installDuckDbExtensionOutOfProcess), so even a crashing
+    // installer kills only the child and degrades to `false` here. LOAD of a
+    // present extension file is an ordinary in-process load whose failures
+    // surface as catchable errors, exactly like FTS.
     const c = targetConn ?? conn;
     if (!c) {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
@@ -2499,6 +2498,74 @@ export const createVectorIndex = async () => {
         throw e;
     }
 };
+/**
+ * Make DML against {@link EMBEDDING_TABLE_NAME} legal on the writable
+ * connection when it can be, and report whether it is.
+ *
+ * LadybugDB refuses EVERY mutation of a table carrying an HNSW index while
+ * the VECTOR extension is not loaded on that connection: `DELETE` fails with
+ * "Trying to delete from an index on table CodeEmbedding but its extension is
+ * not loaded", `CREATE` with the matching "insert into an index" variant,
+ * `DROP TABLE` is refused while the index references it, and `SET` — even on
+ * a NON-indexed property — segfaults the process outright. Probed against
+ * @ladybugdb/core 0.18.2 (the lockfile-pinned version) and 0.18.0 — every
+ * result identical on both (#2623).
+ *
+ * Dropping the index is NOT an available recovery: `CALL DROP_VECTOR_INDEX`
+ * is itself a VECTOR-extension function and resolves to "Catalog exception:
+ * function DROP_VECTOR_INDEX is not defined" in exactly the state it would
+ * need to rescue. Loading the extension is the only in-place repair, which is
+ * why this returns a verdict instead of attempting a fixup.
+ *
+ * `true` = embedding-row DML is safe: either VECTOR is now loaded, or the
+ * table carries no index to trip over. `false` = genuinely blocked (index
+ * present, extension unloadable); the analyze orchestrator answers that by
+ * escalating to the wipe-and-rebuild write plan instead of failing
+ * mid-writeback.
+ *
+ * Cheap by construction: one local `SHOW_INDEXES` read settles the common
+ * "this repo never built an embedding index" case without touching the
+ * extension machinery at all, so a VECTOR-less machine is not charged a
+ * bounded INSTALL attempt on every incremental analyze. `SHOW_INDEXES` is
+ * readable WITHOUT the extension and reports `extension_loaded` per index, so
+ * no error-string sniffing is needed; it runs through the unprepared
+ * `conn.query()` path like every other `CALL` procedure here (#2114).
+ */
+export const ensureEmbeddingRowDmlSafe = async () => {
+    const targetConn = conn;
+    if (!targetConn) {
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
+    }
+    // Catalog FIRST. The overwhelmingly common case on a repo that never enabled
+    // embeddings is "no index at all", and that is provable with one local read
+    // — no extension needed. Loading first would make every incremental analyze
+    // on a VECTOR-less machine pay a bounded out-of-process INSTALL attempt (the
+    // `auto` policy) plus an "extension unavailable" warning, for a repo that
+    // can never hit this hazard.
+    let indexRows;
+    try {
+        indexRows = await withConnLock(async () => readQueryRows(await targetConn.query('CALL SHOW_INDEXES() RETURN *')));
+    }
+    catch (err) {
+        // Fall through to the load attempt: unable to prove the index is absent,
+        // so the extension is the only thing that can make DML safe.
+        logger.warn({ err }, `Could not read the index catalog to check for a ${EMBEDDING_TABLE_NAME} vector index; ` +
+            'falling back to loading the VECTOR extension.');
+    }
+    // Any non-HASH index on the embedding table gates DML. Keyed on index TYPE,
+    // not name, so an index built under a different name still counts; the
+    // implicit primary-key HASH index is engine-internal and never gates.
+    const indexGatesDml = indexRows === undefined ||
+        indexRows.some((row) => {
+            const table = row?.table_name ?? row?.[0];
+            if (table !== EMBEDDING_TABLE_NAME)
+                return false;
+            return (row?.index_type ?? row?.[2]) !== 'HASH';
+        });
+    if (!indexGatesDml)
+        return true;
+    return await loadVectorExtension(undefined, { policy: resolveAnalyzeInstallPolicy() });
+};
 /**
  * Lazy-create an FTS index, caching the fact in-process.
  *

package/dist/core/lbug/native-check.d.ts

@@ -9,6 +9,8 @@ export interface FtsProbeResult {
     /** Collapsed LadybugDB error when `loaded` is false. */
     reason?: string;
 }
+/** Same shape for every optional extension; `FtsProbeResult` is the legacy name. */
+export type ExtensionProbeResult = FtsProbeResult;
 /**
  * Live-probe `LOAD EXTENSION fts` on a throwaway in-memory database.
  *
@@ -26,3 +28,19 @@ export interface FtsProbeResult {
  * would need an out-of-process probe.
  */
 export declare function probeFtsExtensionLoad(timeoutMs?: number): Promise<FtsProbeResult>;
+/**
+ * Live-probe `LOAD EXTENSION vector`, the VECTOR counterpart of the FTS probe.
+ *
+ * Needed for the same reason #2374 needed the FTS one, and reported the same
+ * way: #2623's reporter saw `doctor` print `VECTOR index: available` while
+ * every incremental `analyze` was dying because the extension had not loaded.
+ * `doctor` derived that line from a static platform capability, so it read
+ * "available" no matter what the extension file was doing.
+ *
+ * Probes for real on every platform, Windows included: the extension server
+ * ships win_amd64 VECTOR artifacts for every 0.18.x extension version (the
+ * old blanket Windows refusal was stale, #1365-era). LOAD never touches the
+ * network and never invokes the installer, so this probe is exactly as safe
+ * as the FTS one above.
+ */
+export declare function probeVectorExtensionLoad(timeoutMs?: number): Promise<ExtensionProbeResult>;

package/dist/core/lbug/native-check.js

@@ -113,6 +113,30 @@ const closeProbeResults = (result) => {
  * would need an out-of-process probe.
  */
 export async function probeFtsExtensionLoad(timeoutMs = DEFAULT_FTS_PROBE_TIMEOUT_MS) {
+    return await probeExtensionLoad('fts', timeoutMs);
+}
+/**
+ * Live-probe `LOAD EXTENSION vector`, the VECTOR counterpart of the FTS probe.
+ *
+ * Needed for the same reason #2374 needed the FTS one, and reported the same
+ * way: #2623's reporter saw `doctor` print `VECTOR index: available` while
+ * every incremental `analyze` was dying because the extension had not loaded.
+ * `doctor` derived that line from a static platform capability, so it read
+ * "available" no matter what the extension file was doing.
+ *
+ * Probes for real on every platform, Windows included: the extension server
+ * ships win_amd64 VECTOR artifacts for every 0.18.x extension version (the
+ * old blanket Windows refusal was stale, #1365-era). LOAD never touches the
+ * network and never invokes the installer, so this probe is exactly as safe
+ * as the FTS one above.
+ */
+export async function probeVectorExtensionLoad(timeoutMs = DEFAULT_FTS_PROBE_TIMEOUT_MS) {
+    return await probeExtensionLoad('vector', timeoutMs);
+}
+/**
+ * Shared LOAD probe. `extension` is a fixed internal literal, never user input.
+ */
+async function probeExtensionLoad(extension, timeoutMs) {
     let timer;
     const timeout = new Promise((resolve) => {
         timer = setTimeout(() => resolve({
@@ -128,7 +152,7 @@ export async function probeFtsExtensionLoad(timeoutMs = DEFAULT_FTS_PROBE_TIMEOU
             try {
                 const conn = new lbug.Connection(db);
                 try {
-                    const result = await conn.query('LOAD EXTENSION fts');
+                    const result = await conn.query(`LOAD EXTENSION ${extension}`);
                     closeProbeResults(result);
                     return { loaded: true };
                 }

package/dist/core/lbug/pool-adapter.js

@@ -16,7 +16,7 @@
  */
 import fs from 'fs/promises';
 import lbug from '@ladybugdb/core';
-import { isReadOnlyDbError, loadFTSExtension } from './lbug-adapter.js';
+import { isReadOnlyDbError, loadFTSExtension, loadVectorExtension } from './lbug-adapter.js';
 import { closeQueryResults } from './query-result-utils.js';
 import { createLbugDatabase, isWalCorruptionError, toNativeSafePath, WAL_RECOVERY_SUGGESTION, } from './lbug-config.js';
 import { guardWalQuarantine, isMissingFsError, isMissingShadowSidecarError, isReadOnlyShadowReplayError, preflightLbugSidecars, quarantineWalForMissingShadow, renameFailureMessage, statIfExists, } from './sidecar-recovery.js';
@@ -263,6 +263,7 @@ function closeOne(repoId) {
                 // for the same dbPath reuse it instead of hitting a file lock.
                 shared.refCount = 0;
                 shared.ftsLoaded = false;
+                shared.vectorLoaded = false;
             }
             else {
                 shared.db.close().catch(() => { });
@@ -687,6 +688,13 @@ async function doInitLbug(repoId, dbPath) {
     if (!shared.ftsLoaded) {
         shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
     }
+    // VECTOR too — extension load scope is per-Database, so this one load
+    // makes QUERY_VECTOR_INDEX legal on every pooled connection. Same
+    // load-only contract as FTS above; on failure the semantic-query lane
+    // falls back to the exact scan with its own diagnostic (#2623 follow-up).
+    if (!shared.vectorLoaded) {
+        shared.vectorLoaded = await loadVectorExtension(available[0], { policy: 'load-only' });
+    }
     // Register pool entry only after all connections are pre-warmed and FTS is
     // loaded.  Concurrent executeQuery calls see either "not initialized"
     // (and throw cleanly) or a fully ready pool — never a half-built one.
@@ -749,6 +757,11 @@ export async function initLbugWithDb(repoId, existingDb, dbPath) {
     if (!shared.ftsLoaded) {
         shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
     }
+    // VECTOR too — same per-Database scope and load-only contract as the
+    // doInitLbug site above (#2623 follow-up).
+    if (!shared.vectorLoaded) {
+        shared.vectorLoaded = await loadVectorExtension(available[0], { policy: 'load-only' });
+    }
     pool.set(repoId, {
         db: existingDb,
         available,

package/dist/core/platform/capabilities.d.ts

@@ -19,6 +19,5 @@ export interface RuntimeCapabilities {
 export declare const DEFAULT_EXACT_SCAN_LIMIT = 10000;
 export declare const getExactScanLimit: () => number;
 export declare const getRuntimeFingerprint: () => RuntimeFingerprint;
-export declare const isVectorExtensionSupportedByPlatform: (platform?: NodeJS.Platform) => boolean;
 export declare const getRuntimeCapabilities: () => RuntimeCapabilities;
 export declare const defaultEmbeddingThreads: () => number;

package/dist/core/platform/capabilities.js

@@ -59,19 +59,24 @@ export const getRuntimeFingerprint = () => ({
     ladybugdb: packageVersion('@ladybugdb/core'),
     onnxruntime: packageVersion('onnxruntime-node'),
 });
-export const isVectorExtensionSupportedByPlatform = (platform = process.platform) => platform !== 'win32';
 export const getRuntimeCapabilities = () => {
-    const vector = isVectorExtensionSupportedByPlatform() ? 'available' : 'unavailable';
     const exactScanLimit = getExactScanLimit();
+    // Static PLATFORM capability only. LadybugDB ships the VECTOR extension for
+    // every platform gitnexus supports — the extension server hosts win_amd64
+    // artifacts for every 0.18.x extension version (probed: v0.18.0 and v0.18.1
+    // both return a real 14 MB PE32+ DLL; the pinned 0.18.2 core resolves its
+    // extension directory to 0.18.1, strace-verified), so the old
+    // `platform !== 'win32'` gate was stale (#1365-era). Whether the extension
+    // actually LOADS on a given machine is a runtime question — doctor answers
+    // it with probeVectorExtensionLoad, and analyze/query degrade to exact scan
+    // when the load fails.
     return {
         graph: 'available',
         fts: 'available',
-        vector,
-        semanticMode: vector === 'available' ? 'vector-index' : 'exact-scan',
+        vector: 'available',
+        semanticMode: 'vector-index',
         exactScanLimit,
-        reason: vector === 'unavailable'
-            ? 'LadybugDB VECTOR is disabled on this platform; semantic search uses exact scan when embeddings exist.'
-            : undefined,
+        reason: undefined,
     };
 };
 export const defaultEmbeddingThreads = () => {

package/dist/core/run-analyze.js

@@ -13,7 +13,7 @@ import fs from 'fs/promises';
 import { retryRename } from '../storage/fs-atomic.js';
 import { runPipelineFromRepo } from './ingestion/pipeline.js';
 import { resetDegradedParseCounter } from './tree-sitter/safe-parse.js';
-import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, closeLbugBeforeExit, loadCachedEmbeddings, deleteNodesForFiles, deleteAllCommunitiesAndProcesses, deleteAllInterprocTaintPaths, deleteAllCallSummaries, deleteAllInjects, queryImportersBatch, loadFTSExtension, wipeLbugDbFiles, LbugWipeError, DELETE_FILES_CHUNK_SIZE, } from './lbug/lbug-adapter.js';
+import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, closeLbugBeforeExit, loadCachedEmbeddings, deleteNodesForFiles, ensureEmbeddingRowDmlSafe, deleteAllCommunitiesAndProcesses, deleteAllInterprocTaintPaths, deleteAllCallSummaries, deleteAllInjects, queryImportersBatch, loadFTSExtension, wipeLbugDbFiles, LbugWipeError, DELETE_FILES_CHUNK_SIZE, } from './lbug/lbug-adapter.js';
 import { estimateBufferPool, setBufferPoolSizeHint } from './lbug/lbug-config.js';
 import { escapeCypherString } from './lbug/cypher-escape.js';
 import { buildSearchIndexesOrDegrade, createSearchFTSIndexes, dropSearchFTSIndexes, initialiseSearchFTSStemmer, verifySearchFTSIndexes, } from './search/fts-indexes.js';
@@ -1223,15 +1223,57 @@ export async function runFullAnalysis(repoPath, options, callbacks, runnerIdenti
             // DB write plan changes here; fileHashes/meta bookkeeping is identical.
             // Thresholds + the AND-gate live in incremental/escalation-gate.ts.
             const writeFraction = effectiveWriteSet.size / Math.max(1, allFilePaths.length);
-            if (shouldEscalateIncrementalWrite(filesToDelete.length, effectiveWriteSet.size, allFilePaths.length)) {
+            // VECTOR gate (#2623) — load the extension BEFORE a single embedding row
+            // is touched. `deleteNodesForFiles` below opens with the CodeEmbedding
+            // join-delete, and LadybugDB refuses all DML on a table carrying its HNSW
+            // index unless VECTOR is loaded on this connection; nothing else on this
+            // path loads it until Phase 4, so every incremental run over a DB that
+            // already built `code_embedding_idx` died here. Same seam the FTS drop
+            // occupies at the head of this branch (#2589): index lifecycle first,
+            // then rows. UNCONDITIONAL — not gated on `shouldGenerateEmbeddings` —
+            // because a DB carrying the index from an earlier `--embeddings` run hits
+            // the identical wall on a plain incremental run.
+            //
+            // When VECTOR genuinely cannot load, the table is immutable (the index
+            // cannot be dropped without the extension either), so surgery is
+            // impossible: fall through to the escalation valve's wipe-and-COPY plan,
+            // which rebuilds the DB files outright and needs no embedding-row DML.
+            const embeddingRowDmlSafe = await ensureEmbeddingRowDmlSafe();
+            if (!embeddingRowDmlSafe && cachedEmbeddings.length === 0) {
+                // The escalation below WIPES the DB files, and Phase 3.5 restores
+                // embedding rows from `cachedEmbeddings` — which is only populated when
+                // `deriveEmbeddingMode` saw `meta.stats.embeddings > 0`. A DB whose meta
+                // under-reports its embeddings (meta restored from an older run, or a
+                // count that never got stamped) would therefore have every vector
+                // silently destroyed by a rebuild it did not ask for. Read them now,
+                // while the DB is still intact — a plain MATCH, which needs no VECTOR
+                // extension. Rows whose owning node is gone are dropped by Phase 3.5's
+                // live-graph filter, exactly as on any other wiped path.
+                const rescued = await loadCachedEmbeddings();
+                if (rescued.embeddings.length > 0) {
+                    cachedEmbeddings = rescued.embeddings;
+                    cachedEmbeddingNodeIds = rescued.embeddingNodeIds;
+                    log(`Preserving ${rescued.embeddings.length} embedding row(s) across the forced rebuild ` +
+                        `(the index metadata did not account for them).`);
+                }
+            }
+            if (!embeddingRowDmlSafe ||
+                shouldEscalateIncrementalWrite(filesToDelete.length, effectiveWriteSet.size, allFilePaths.length)) {
                 escalatedFullWrite = true;
-                log(`Incremental: effective write set covers ${effectiveWriteSet.size}/${allFilePaths.length} ` +
-                    // Display clamp only (predicate unchanged): BFS-found deleted
-                    // importers can push the numerator past the CURRENT file list, so
-                    // the raw fraction can exceed 1 — see the population-mismatch note
-                    // on shouldEscalateIncrementalWrite (tri-review 4669518496).
-                    `files (${Math.min(100, Math.round(writeFraction * 100))}%) — switching to a full DB write ` +
-                    `(wipe + bulk COPY) for this run; file-level incremental bookkeeping is unaffected.`);
+                log(!embeddingRowDmlSafe
+                    ? `Incremental: the ${EMBEDDING_TABLE_NAME} vector index exists but the VECTOR ` +
+                        `extension could not be loaded, so embedding rows cannot be rewritten in place — ` +
+                        `switching to a full DB write (wipe + bulk COPY) for this run. Semantic search ` +
+                        `falls back to exact scan until VECTOR is available; run \`gitnexus doctor\` for ` +
+                        `live extension status, or set GITNEXUS_LBUG_EXTENSION_INSTALL=auto to allow one ` +
+                        `bounded install attempt.`
+                    : `Incremental: effective write set covers ${effectiveWriteSet.size}/${allFilePaths.length} ` +
+                        // Display clamp only (predicate unchanged): BFS-found deleted
+                        // importers can push the numerator past the CURRENT file list, so
+                        // the raw fraction can exceed 1 — see the population-mismatch note
+                        // on shouldEscalateIncrementalWrite (tri-review 4669518496).
+                        `files (${Math.min(100, Math.round(writeFraction * 100))}%) — switching to a full DB write ` +
+                        `(wipe + bulk COPY) for this run; file-level incremental bookkeeping is unaffected.`);
                 // toWriteCount: 0 is the established full-path dirty-flag sentinel;
                 // the real counters ride along for crash diagnostics.
                 await saveIncrementalDirtyState('escalated-full-write', {
@@ -1565,8 +1607,8 @@ export async function runFullAnalysis(repoPath, options, callbacks, runnerIdenti
         //     the case a naive gate would leave index-less again.
         // buildVectorIndex carries its own extension-policy gate and
         // warn-on-failure; the boolean feeds semanticMode so the finalize stamp
-        // reflects the DB's ACTUAL state even when recreation fails (win32 /
-        // extension unavailable → 'exact-scan').
+        // reflects the DB's ACTUAL state even when recreation fails (extension
+        // unavailable → 'exact-scan').
         const dbWasWiped = !isIncremental || escalatedFullWrite;
         if (restoredEmbeddingCount > 0 && dbWasWiped && embeddingSkipped) {
             // Re-import at the seam rather than thread a mutable capture from

package/dist/mcp/local/local-backend.js

@@ -26,7 +26,7 @@ import { collectBestChunks } from '../../core/embeddings/types.js';
 import { DEFAULT_MCP_VECTOR_MAX_DISTANCE, getVectorMaxDistance, } from '../../core/embeddings/config.js';
 import { rankExactEmbeddingRows, } from '../../core/embeddings/exact-search.js';
 import { EMBEDDING_TABLE_NAME, EMBEDDING_INDEX_NAME } from '../../core/lbug/schema.js';
-import { getExactScanLimit, isVectorExtensionSupportedByPlatform, } from '../../core/platform/capabilities.js';
+import { getExactScanLimit } from '../../core/platform/capabilities.js';
 import { PhaseTimer } from '../../core/search/phase-timer.js';
 import { ftsDegradedWarning } from '../../core/search/fts-indexes.js';
 import { cjkSegmentationModeMismatch, containsSegmentableCjkRun, getSearchFTSCjkSegmentation, isSupportedCjkSegmentationMode, MAX_CJK_SEGMENTATION_QUERY_LENGTH, } from '../../core/search/cjk-segmentation.js';
@@ -1938,10 +1938,16 @@ export class LocalBackend {
             const queryVecStr = `[${queryVec.join(',')}]`;
             const maxDistance = getVectorMaxDistance(DEFAULT_MCP_VECTOR_MAX_DISTANCE);
             let bestChunks = new Map();
-            if (isVectorExtensionSupportedByPlatform()) {
-                try {
-                    bestChunks = await collectBestChunks(limit, async (fetchLimit) => {
-                        const vectorQuery = `
+            // Always TRY the vector lane — no platform gate. LadybugDB ships the
+            // VECTOR extension for every supported platform, Windows included
+            // (#2623 follow-up; the old `platform !== 'win32'` gate was stale), so
+            // whether the index is queryable is a per-machine runtime fact. The
+            // catch below is the fallback: any failure (extension unloadable, index
+            // absent, older DB) degrades to the exact scan with a once-per-backend
+            // diagnostic instead of being silently swallowed.
+            try {
+                bestChunks = await collectBestChunks(limit, async (fetchLimit) => {
+                    const vectorQuery = `
             CALL QUERY_VECTOR_INDEX('${EMBEDDING_TABLE_NAME}', '${EMBEDDING_INDEX_NAME}',
               CAST(${queryVecStr} AS FLOAT[${dims}]), ${fetchLimit})
             YIELD node AS emb, distance
@@ -1951,27 +1957,25 @@ export class LocalBackend {
                    emb.startLine AS startLine, emb.endLine AS endLine, distance
             ORDER BY distance
           `;
-                        const embResults = await executeQuery(repo.lbugPath, vectorQuery);
-                        return embResults.map((row) => ({
-                            nodeId: row.nodeId ?? row[0],
-                            chunkIndex: row.chunkIndex ?? row[1] ?? 0,
-                            startLine: row.startLine ?? row[2] ?? 0,
-                            endLine: row.endLine ?? row[3] ?? 0,
-                            distance: row.distance ?? row[4],
-                        }));
-                    });
-                }
-                catch {
-                    bestChunks = new Map();
-                }
+                    const embResults = await executeQuery(repo.lbugPath, vectorQuery);
+                    return embResults.map((row) => ({
+                        nodeId: row.nodeId ?? row[0],
+                        chunkIndex: row.chunkIndex ?? row[1] ?? 0,
+                        startLine: row.startLine ?? row[2] ?? 0,
+                        endLine: row.endLine ?? row[3] ?? 0,
+                        distance: row.distance ?? row[4],
+                    }));
+                });
             }
-            else if (!this.warnedVectorUnsupported) {
-                // Rare diagnostic: surface why we fell back to the exact scan path so
-                // operators can see at a glance that VECTOR is disabled by platform
-                // policy. Emitted once per `LocalBackend` instance lifetime to avoid
-                // noisy stderr on hot semantic-search paths (DoD §2.8).
-                this.warnedVectorUnsupported = true;
-                logger.warn('GitNexus [query:vector]: VECTOR extension not supported on this platform; using exact scan fallback');
+            catch (err) {
+                bestChunks = new Map();
+                if (!this.warnedVectorUnsupported) {
+                    // Rare diagnostic: surface why semantic search fell back to the
+                    // exact scan. Emitted once per `LocalBackend` instance lifetime to
+                    // avoid noisy stderr on hot semantic-search paths (DoD §2.8).
+                    this.warnedVectorUnsupported = true;
+                    logger.warn({ err }, 'GitNexus [query:vector]: vector index query failed; using exact scan fallback');
+                }
             }
             if (bestChunks.size === 0) {
                 const embeddingCount = Number(tableCheck[0].cnt ?? tableCheck[0][0] ?? 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.85",
+  "version": "1.6.10-rc.87",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",

package/scripts/cross-platform-tests.ts

@@ -117,6 +117,12 @@ const LBUG_NATIVE = [
   // to a live native DB, rm-then-rename over an existing parked copy) before
   // any open — rename semantics are exactly what differs on Windows.
   'test/unit/incremental-dirty-recovery.test.ts',
+  // #2623: the incremental writeback must load VECTOR before the CodeEmbedding
+  // join-delete, and the blocked path must escalate instead of crashing. The
+  // win32 VECTOR gate was removed in the same PR, so this ordering must be
+  // proven on the windows-latest native addon, not just Ubuntu. Budget: ~25s
+  // on Linux → expect ~2min on the slowest Windows shard.
+  'test/unit/incremental-vector-extension-ordering.test.ts',
 ];
 
 // Process spawning and CLI tests — exercise child_process with real

package/scripts/ensure-fts.ts

@@ -1,6 +1,6 @@
 /**
- * Install the LadybugDB FTS extension into the shared home (~/.lbdb) up front, so
- * every test in a sharded CI run finds it regardless of which shard it lands in.
+ * Install the LadybugDB FTS and VECTOR extensions into the shared home (~/.lbdb)
+ * up front, so every test in a sharded CI run finds them regardless of shard.
  *
  * FTS-dependent tests split two ways: the LOAD-path gate (skipUnlessFtsAvailable)
  * self-installs on miss, but the FILE-path gate (requireFtsResourceOrSkip, e.g.
@@ -17,13 +17,24 @@
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { initLbug, loadFTSExtension, closeLbug } from '../src/core/lbug/lbug-adapter.js';
+import {
+  initLbug,
+  loadFTSExtension,
+  loadVectorExtension,
+  closeLbug,
+} from '../src/core/lbug/lbug-adapter.js';
 
 const dir = mkdtempSync(join(tmpdir(), 'gn-ensure-fts-'));
 try {
   await initLbug(join(dir, 'ensure-fts.lbug'));
   const ok = await loadFTSExtension(undefined, { policy: 'auto' });
   console.log(ok ? 'FTS extension ready.' : 'FTS extension unavailable (continuing).');
+  // VECTOR rides the same pre-install (#2623): the win32 gate is gone, so the
+  // vector suites genuinely run on Windows/macOS — installing once here means
+  // every sharded test process LOADs from ~/.lbdb instead of racing its own
+  // out-of-process INSTALL (bounded 15s each when the server is unreachable).
+  const vec = await loadVectorExtension(undefined, { policy: 'auto' });
+  console.log(vec ? 'VECTOR extension ready.' : 'VECTOR extension unavailable (continuing).');
 } catch (err) {
   console.warn(`ensure-fts: skipped (${err instanceof Error ? err.message : String(err)})`);
 } finally {