gitnexus 1.6.12 → 1.6.13-rc.2

package/dist/core/tree-sitter/vendored-grammars.d.ts

@@ -1,13 +1,5 @@
-/**
- * Absolute path to the vendored grammar tree (`<pkg>/vendor`).
- *
- * This module compiles to `<pkg>/dist/core/tree-sitter/vendored-grammars.js`
- * and runs from `<pkg>/src/core/tree-sitter/...` under tsx in dev — both sit
- * three directories below the package root, and the build (`tsc`) never bundles,
- * so `import.meta.url` resolves the same way in both. `vendor/` ships in the
- * published package via package.json `files`.
- */
-export declare const VENDOR_ROOT: string;
+import { VENDOR_ROOT } from '../vendor-root.js';
+export { VENDOR_ROOT };
 /**
  * The tree-sitter grammars GitNexus vendors inside its own package (NOT npm
  * dependencies). Kept in one place so consumers (runtime loaders, the CLI

package/dist/core/tree-sitter/vendored-grammars.js

@@ -1,17 +1,8 @@
 import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
 import path from 'node:path';
+import { VENDOR_ROOT } from '../vendor-root.js';
 const _require = createRequire(import.meta.url);
-/**
- * Absolute path to the vendored grammar tree (`<pkg>/vendor`).
- *
- * This module compiles to `<pkg>/dist/core/tree-sitter/vendored-grammars.js`
- * and runs from `<pkg>/src/core/tree-sitter/...` under tsx in dev — both sit
- * three directories below the package root, and the build (`tsc`) never bundles,
- * so `import.meta.url` resolves the same way in both. `vendor/` ships in the
- * published package via package.json `files`.
- */
-export const VENDOR_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'vendor');
+export { VENDOR_ROOT };
 /**
  * The tree-sitter grammars GitNexus vendors inside its own package (NOT npm
  * dependencies). Kept in one place so consumers (runtime loaders, the CLI

package/dist/core/vendor-root.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Absolute path to the published `vendor/` tree (`<pkg>/vendor`).
+ *
+ * This module compiles to `<pkg>/dist/core/vendor-root.js` and runs from
+ * `<pkg>/src/core/` under tsx — both sit two directories below the package
+ * root. Shared so grammar loaders and the FTS artifact resolver cannot drift.
+ */
+export declare const VENDOR_ROOT: string;

package/dist/core/vendor-root.js

@@ -0,0 +1,10 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+/**
+ * Absolute path to the published `vendor/` tree (`<pkg>/vendor`).
+ *
+ * This module compiles to `<pkg>/dist/core/vendor-root.js` and runs from
+ * `<pkg>/src/core/` under tsx — both sit two directories below the package
+ * root. Shared so grammar loaders and the FTS artifact resolver cannot drift.
+ */
+export const VENDOR_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'vendor');

package/dist/mcp/server.js

@@ -60,6 +60,14 @@ function getNextStepHint(toolName, args) {
             return '';
     }
 }
+/** Include a string `Error.code` in MCP error text when present. */
+function formatMcpToolError(error) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    const code = typeof error === 'object' && error !== null && 'code' in error
+        ? error.code
+        : undefined;
+    return typeof code === 'string' ? `Error [${code}]: ${message}` : `Error: ${message}`;
+}
 /**
  * Create a configured MCP Server with all handlers registered.
  * Transport-agnostic — caller connects the desired transport.
@@ -129,7 +137,7 @@ export function createMCPServer(backend, options = {}) {
                     {
                         uri,
                         mimeType: 'text/plain',
-                        text: `Error: ${err.message}`,
+                        text: formatMcpToolError(err),
                     },
                 ],
             };
@@ -185,12 +193,11 @@ export function createMCPServer(backend, options = {}) {
             };
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
             return {
                 content: [
                     {
                         type: 'text',
-                        text: applyMcpMaxTokens(`Error: ${message}`, maxTokens),
+                        text: applyMcpMaxTokens(formatMcpToolError(error), maxTokens),
                     },
                 ],
                 isError: true,

package/dist/server/api.js

@@ -14,6 +14,7 @@ import fs from 'fs/promises';
 import { canonicalizePath, cloneDirBelongsToEntry, loadMeta, saveMeta, listRegisteredRepos, registryPathEquals, } from '../storage/repo-manager.js';
 import { requireDeletableStoragePath, requireRegisteredStoragePath, STATUS_STORAGE_REQUIREMENTS, StorageDeletionError, StorageRequirementError, } from '../storage/storage-resolver.js';
 import { executeQuery, executePrepared, executeWithReusedStatement, streamQuery, flushWAL, closeLbug, withLbugDb, isReadOnlyDbError, } from '../core/lbug/lbug-adapter.js';
+import { assertReadOnlyFtsCrashSafe } from '../core/lbug/sidecar-recovery.js';
 import { isValidQueryParams } from '../core/lbug/query-params.js';
 import { NODE_TABLES } from '../_shared/index.js';
 import { searchFTSFromLbug } from '../core/search/bm25-index.js';
@@ -449,6 +450,12 @@ export const streamGraphNdjson = async (res, includeContent = false, signal) =>
         }, signal);
     });
 };
+const httpErrorBody = (err, fallback) => {
+    const body = { error: err.message || fallback };
+    if (typeof err?.code === 'string')
+        body.code = err.code;
+    return body;
+};
 const statusFromError = (err) => {
     // Validation helpers throw BadRequestError / ForbiddenError with a typed
     // .status field — honor it before falling back to message-string matching.
@@ -666,7 +673,7 @@ export const handleQueryRequest = async (req, res, resolveRepo) => {
             res.status(403).json({ error: 'Write queries are not allowed via the HTTP API' });
             return;
         }
-        res.status(500).json({ error: err.message || 'Query failed' });
+        res.status(500).json(httpErrorBody(err, 'Query failed'));
     }
 };
 /**
@@ -1099,10 +1106,10 @@ export const createServer = async (port, host = '127.0.0.1') => {
             if (err instanceof ClientDisconnectedError) {
                 return;
             }
-            const message = err.message || 'Failed to build graph';
+            const body = httpErrorBody(err, 'Failed to build graph');
             if (res.headersSent) {
                 try {
-                    res.write(JSON.stringify({ type: 'error', error: message }) + '\n');
+                    res.write(JSON.stringify({ type: 'error', ...body }) + '\n');
                 }
                 catch {
                     // Best-effort only after streaming has started.
@@ -1110,7 +1117,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
                 res.end();
                 return;
             }
-            res.status(500).json({ error: message });
+            res.status(500).json(body);
         }
     });
     // Execute Cypher query
@@ -1258,7 +1265,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
         catch (err) {
             if (sendStorageRequirementHttp(err, res))
                 return;
-            res.status(500).json({ error: err.message || 'Search failed' });
+            res.status(500).json(httpErrorBody(err, 'Search failed'));
         }
     });
     // Read file — with path traversal guard
@@ -1323,7 +1330,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
         catch (err) {
             if (sendStorageRequirementHttp(err, res))
                 return;
-            res.status(statusFromError(err)).json({ error: err.message || 'Grep failed' });
+            res.status(statusFromError(err)).json(httpErrorBody(err, 'Grep failed'));
         }
     });
     // List all processes
@@ -1333,7 +1340,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
             res.json(result);
         }
         catch (err) {
-            res.status(statusFromError(err)).json({ error: err.message || 'Failed to query processes' });
+            res.status(statusFromError(err)).json(httpErrorBody(err, 'Failed to query processes'));
         }
     });
     // Process detail
@@ -1352,9 +1359,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
             res.json(result);
         }
         catch (err) {
-            res
-                .status(statusFromError(err))
-                .json({ error: err.message || 'Failed to query process detail' });
+            res.status(statusFromError(err)).json(httpErrorBody(err, 'Failed to query process detail'));
         }
     });
     // List all clusters
@@ -1364,7 +1369,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
             res.json(result);
         }
         catch (err) {
-            res.status(statusFromError(err)).json({ error: err.message || 'Failed to query clusters' });
+            res.status(statusFromError(err)).json(httpErrorBody(err, 'Failed to query clusters'));
         }
     });
     // Cluster detail
@@ -1383,9 +1388,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
             res.json(result);
         }
         catch (err) {
-            res
-                .status(statusFromError(err))
-                .json({ error: err.message || 'Failed to query cluster detail' });
+            res.status(statusFromError(err)).json(httpErrorBody(err, 'Failed to query cluster detail'));
         }
     });
     // ── Analyze API ──────────────────────────────────────────────────────
@@ -1640,6 +1643,10 @@ export const createServer = async (port, host = '127.0.0.1') => {
                     const lbugPath = path.join(storagePath, LBUG_DIRECTORY);
                     const ftsSession = await loadFtsSession(storagePath);
                     let embeddingMeta = ftsSession.meta;
+                    // Writable embed still replays a leftover FTS-abort WAL. Refuse
+                    // here — doInitLbug only gates the readOnly path, and analyze
+                    // writers must still be able to park/rebuild.
+                    await assertReadOnlyFtsCrashSafe(lbugPath);
                     await withLbugDb(lbugPath, async () => {
                         const { runEmbeddingPipeline } = await import('../core/embeddings/embedding-pipeline.js');
                         const { resolveEmbeddingIdentity } = await import('../core/embeddings/embedding-identity.js');

package/dist/storage/repo-meta.d.ts

@@ -77,6 +77,11 @@ export interface AnalyzerRunnerIdentity {
         digest: string;
     };
 }
+/**
+ * Hand-mirrored `FtsSkipReason` from core/search/fts-policy.ts so storage
+ * takes no core import. Change both declarations together.
+ */
+export type PersistedFtsSkipReason = 'extension-unavailable' | 'build-failed' | 'disabled-by-flag' | 'disabled-by-env' | 'native-abort' | 'tuple-missing';
 export interface RepoMeta {
     repoPath: string;
     /** Complete index directory selected for this successful analysis. */
@@ -178,13 +183,28 @@ export interface RepoMeta {
              *    `--repair-fts` or a content change addresses it.
              *  - `disabled-by-flag` / `disabled-by-env` — deliberate opt-out.
              *    A later analyze without the opt-out rebuilds FTS at the same commit.
+             *  - `native-abort` — inferred on the next run from an FTS-phase dirty
+             *    flag after the previous process died in the native FTS build.
+             *  - `tuple-missing` — no packaged artifact for this platform tuple.
+             *    The tuple itself is not persisted (closed enum; live messages name it).
              *
              * Collapsing both into `status: 'unavailable'` is exactly what made that
              * loop reachable. ABSENT on indexes written before #2841 and on the
              * `--repair-fts` stamp (which writes `status: 'available'`); `undefined`
              * therefore reads as "cause unknown" and keeps the pre-#2841 behaviour.
+             * No schema version: meta reads are unchecked casts. An older binary
+             * still sees the raw JSON string for an unknown member; it does not
+             * drop the field to `undefined` at parse time.
+             */
+            skipReason?: PersistedFtsSkipReason;
+            /**
+             * Write plan of the analyze that aborted, persisted with
+             * `skipReason: 'native-abort'` so readers can refuse a leftover live
+             * WAL after recovery clears `incrementalInProgress`. Staging persist
+             * also writes `native-abort` and must keep its live WAL. Absent on
+             * older indexes and on non-abort skips.
              */
-            skipReason?: 'extension-unavailable' | 'build-failed' | 'disabled-by-flag' | 'disabled-by-env';
+            writePlan?: 'in-place' | 'staging';
         };
         vectorSearch: {
             provider: string;
@@ -396,8 +416,17 @@ export interface RepoMeta {
         /** Number of files in the writable set, for diagnostic logs.
          *  `0` on the full-rebuild path (no incremental write set exists). */
         toWriteCount: number;
-        /** Last completed writeback phase before the process stopped. */
+        /**
+         * Last completed writeback phase before the process stopped.
+         * `'fts'` is the graph-boundary / FTS-build marker: recovery may act
+         * more narrowly than a bare dirty flag, and `--repair-fts` must not
+         * treat it as a half-written graph.
+         */
         phase?: string;
+        /** Settled write plan at the FTS boundary (in-place vs unpublished staging). */
+        writePlan?: 'in-place' | 'staging';
+        /** Whether the converged graph-boundary CHECKPOINT succeeded. */
+        checkpointSucceeded?: boolean;
         /** Directly changed/added files before importer expansion. */
         directWriteCount?: number;
         /** Extra files pulled into the writable set by importer BFS. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.12",
+  "version": "1.6.13-rc.2",
   "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",
@@ -53,7 +53,7 @@
     "postinstall": "node scripts/build-tree-sitter-grammars.cjs",
     "assert-publish-coverage": "node scripts/assert-publish-grammar-coverage.cjs",
     "prepare": "node scripts/build.js",
-    "prepack": "node scripts/assert-publish-grammar-coverage.cjs && node scripts/build.js --web && node scripts/assert-web-assets.mjs web",
+    "prepack": "node scripts/assert-publish-grammar-coverage.cjs && node scripts/assert-publish-fts-coverage.cjs && node scripts/build.js --web && node scripts/assert-web-assets.mjs web",
     "version": "node scripts/sync-plugin-manifests.mjs"
   },
   "dependencies": {

package/scripts/assert-publish-fts-coverage.cjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+/**
+ * Publish guard: core↔extension pairing plus vendored FTS artifact integrity.
+ *
+ * Does not shell out to `npm pack` (prepack re-entrancy; see the grammar gate).
+ * Checksums and the `files` allow-list are asserted as pure predicates so a
+ * future lean-publish narrowing cannot drop the artifacts silently.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const WIN32_ARM64 = 'win32-arm64';
+const SAFE_FILENAME = /^[\w.-]+\.lbug_extension$/;
+const REQUIRED_SUPPORTED_TUPLES = [
+  'linux-x64',
+  'linux-arm64',
+  'darwin-x64',
+  'darwin-arm64',
+  'win32-x64',
+];
+
+/**
+ * Pure pairing core (exported for tests). Returns human-readable problem
+ * strings; an empty array means the core↔extension pin is consistent.
+ */
+const EXACT_CORE_PIN = /^\d+\.\d+\.\d+$/;
+
+function findPairingProblems({
+  installedCoreVersion,
+  manifestCoreVersion,
+  manifestExtensionVersion,
+}) {
+  const problems = [];
+  const installed = String(installedCoreVersion ?? '');
+  const pinned = String(manifestCoreVersion ?? '');
+  if (!EXACT_CORE_PIN.test(installed) || !EXACT_CORE_PIN.test(pinned)) {
+    problems.push(
+      `core pin must be exact x.y.z: installed '${installedCoreVersion ?? ''}' vs manifest '${manifestCoreVersion ?? ''}'`,
+    );
+    return problems;
+  }
+  if (installed !== pinned) {
+    problems.push(
+      `core pin mismatch: installed ${installed} vs manifest ${pinned}` +
+        (manifestExtensionVersion ? ` (extension ${manifestExtensionVersion})` : ''),
+    );
+  }
+  return problems;
+}
+
+function readInstalledCoreVersion(pkg) {
+  const raw = pkg?.dependencies?.['@ladybugdb/core'];
+  return raw == null ? '' : String(raw);
+}
+
+function normalizeFilesEntry(value) {
+  return String(value ?? '')
+    .replace(/\\/g, '/')
+    .replace(/\/+$/, '')
+    .replace(/\/\*\*?$/, '');
+}
+
+/** True when package.json `files` still ships the FTS prebuild tree. */
+function filesCoverFtsArtifacts(filesField) {
+  return (filesField || []).some((entry) => {
+    const n = normalizeFilesEntry(entry);
+    return (
+      n === 'vendor' ||
+      n === 'vendor/lbug-fts' ||
+      n === 'vendor/lbug-fts/prebuilds' ||
+      n === 'vendor/**/prebuilds'
+    );
+  });
+}
+
+function supportedTuplesFromManifest(manifest) {
+  return (manifest?.tuples ?? []).map((entry) => entry.tuple);
+}
+
+function unsupportedTuplesFromManifest(manifest) {
+  return (manifest?.unsupportedTuples ?? []).map((entry) => entry.tuple);
+}
+
+function parseSha256Sums(text) {
+  const out = {};
+  for (const line of String(text ?? '').split(/\r?\n/)) {
+    const m = /^([a-fA-F0-9]{64})\s+\.\/(\S+)$/.exec(line.trim());
+    if (!m) continue;
+    out[m[2]] = m[1].toLowerCase();
+  }
+  return out;
+}
+
+function sha256File(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+/**
+ * Integrity + coverage predicates. `artifactByTuple` is injected so tests
+ * never invoke pack and never need the real binaries.
+ */
+function findArtifactProblems({
+  tuples,
+  unsupportedTuples,
+  filesField,
+  checksumByRelPath,
+  artifactByTuple,
+  filename,
+}) {
+  const problems = [];
+  const filenameSafe = filename || 'libfts.lbug_extension';
+  if (!SAFE_FILENAME.test(filenameSafe)) {
+    problems.push(`invalid FTS artifact filename: ${filenameSafe}`);
+  }
+  const listed = new Set(tuples || []);
+  for (const required of REQUIRED_SUPPORTED_TUPLES) {
+    if (!listed.has(required)) {
+      problems.push(`manifest.tuples is missing required ${required}`);
+    }
+  }
+  if (!tuples || tuples.length === 0) {
+    problems.push('manifest.tuples is empty — refusing to publish with 0 artifacts');
+  }
+  if (!filesCoverFtsArtifacts(filesField)) {
+    problems.push('package.json files no longer covers vendor/lbug-fts/prebuilds');
+  }
+  if (!(unsupportedTuples || []).includes(WIN32_ARM64)) {
+    problems.push('win32-arm64 must be declared unsupported (no upstream artifact)');
+  }
+  if ((tuples || []).includes(WIN32_ARM64)) {
+    problems.push('win32-arm64 is listed as supported but has no upstream artifact');
+  }
+  for (const tuple of tuples || []) {
+    const rel = `${tuple}/${filenameSafe}`;
+    const artifact = artifactByTuple?.[tuple];
+    if (!artifact?.exists) {
+      problems.push(`missing artifact for ${tuple} (${rel})`);
+      continue;
+    }
+    const expected = checksumByRelPath?.[rel];
+    if (!expected) {
+      problems.push(`missing SHA-256 for ${rel}`);
+      continue;
+    }
+    if (artifact.hash !== expected) {
+      problems.push(
+        `checksum mismatch for ${tuple}: expected ${expected} got ${artifact.hash}` +
+          (artifact.sizeBytes != null ? ` (${artifact.sizeBytes} bytes)` : ''),
+      );
+    }
+  }
+  return problems;
+}
+
+function readDiskArtifacts(prebuildsDir, tuples, filename) {
+  const artifactByTuple = {};
+  for (const tuple of tuples) {
+    const filePath = path.join(prebuildsDir, tuple, filename);
+    if (!fs.existsSync(filePath)) {
+      artifactByTuple[tuple] = { exists: false };
+      continue;
+    }
+    const buf = fs.readFileSync(filePath);
+    artifactByTuple[tuple] = {
+      exists: true,
+      hash: crypto.createHash('sha256').update(buf).digest('hex'),
+      sizeBytes: buf.byteLength,
+    };
+  }
+  return artifactByTuple;
+}
+
+function main() {
+  const gitnexusRoot = path.join(__dirname, '..');
+  const pkg = JSON.parse(fs.readFileSync(path.join(gitnexusRoot, 'package.json'), 'utf8'));
+  const vendorDir = path.join(gitnexusRoot, 'vendor', 'lbug-fts');
+  const manifestPath = path.join(vendorDir, 'manifest.json');
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  } catch (err) {
+    console.error(
+      `[fts-pairing] Refusing to publish — cannot read ${manifestPath}: ${err.message}`,
+    );
+    process.exit(1);
+  }
+
+  const installedCoreVersion = readInstalledCoreVersion(pkg);
+  const pairing = findPairingProblems({
+    installedCoreVersion,
+    manifestCoreVersion: manifest.coreVersion,
+    manifestExtensionVersion: manifest.extensionVersion,
+  });
+
+  const tuples = supportedTuplesFromManifest(manifest);
+  const unsupportedTuples = unsupportedTuplesFromManifest(manifest);
+  const filename = manifest.filename || 'libfts.lbug_extension';
+  const prebuildsDir = path.join(vendorDir, 'prebuilds');
+  let checksumByRelPath = {};
+  try {
+    checksumByRelPath = parseSha256Sums(
+      fs.readFileSync(path.join(prebuildsDir, 'SHA256SUMS'), 'utf8'),
+    );
+  } catch (err) {
+    pairing.push(`cannot read SHA256SUMS: ${err.message}`);
+  }
+
+  const artifacts = findArtifactProblems({
+    tuples,
+    unsupportedTuples,
+    filesField: pkg.files,
+    checksumByRelPath,
+    artifactByTuple: readDiskArtifacts(prebuildsDir, tuples, filename),
+    filename,
+  });
+
+  const problems = [...pairing, ...artifacts];
+  if (problems.length > 0) {
+    console.error('[fts-pairing] Refusing to publish — FTS artifact coverage failed:');
+    for (const p of problems) console.error(`  - ${p}`);
+    console.error(
+      '\nFix: refresh vendor/lbug-fts via .github/scripts/fetch-lbug-fts-artifacts.mjs, ' +
+        'or restore the core pin / files allow-list.',
+    );
+    process.exit(1);
+  }
+
+  console.log(
+    `[fts-pairing] OK — core ${installedCoreVersion} ↔ extension ${manifest.extensionVersion}; ` +
+      `${tuples.length} artifacts.`,
+  );
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  findPairingProblems,
+  findArtifactProblems,
+  filesCoverFtsArtifacts,
+  parseSha256Sums,
+  readInstalledCoreVersion,
+  supportedTuplesFromManifest,
+  unsupportedTuplesFromManifest,
+  sha256File,
+};

package/scripts/cross-platform-shard.ts

@@ -55,8 +55,13 @@ export const WINDOWS_WEIGHTS_SEC: Readonly<Record<string, number>> = {
   // Upstream speedups may reduce these figures; retaining conservative weights
   // keeps the expensive suites distributed without changing the watchdog.
   'test/unit/incremental-index-extension-dml-gate.test.ts': 414,
-  'test/integration/skills-e2e.test.ts': 444,
-  'test/integration/fts-extension-e2e.test.ts': 146,
+  // Re-measured on windows-latest run 34815870795 after vendored-first FTS
+  // rewrote the HOME-layout e2e (373s) and skills-e2e grew to 542s. The old
+  // 146s/444s entries packed both onto shard 2/3 and blew the 20-minute
+  // watchdog with one file still queued.
+  'test/integration/skills-e2e.test.ts': 550,
+  'test/integration/fts-extension-e2e.test.ts': 380,
+  'test/integration/skip-fts.test.ts': 110,
   'test/integration/analyze-wal-checkpoint-failure.test.ts': 86,
   'test/integration/cli-limit-e2e.test.ts': 75,
   'test/unit/hooks.test.ts': 26,

package/scripts/cross-platform-tests.ts

@@ -85,6 +85,20 @@ const PLATFORM_LOGIC = [
   'test/unit/lbug-config-pagesize.test.ts',
   'test/unit/worker-pool-windows-quarantine.test.ts',
   'test/unit/lbug-pool-fts-load.test.ts',
+  // U7 arm B: Windows FTS names a vendor-neutral OpenSSL/VC++ prerequisite
+  // and must never recommend borrowing Git for Windows DLLs. The file's
+  // assertions are unconditional so a skip-only suite cannot stay green.
+  'test/integration/fts-windows-dependency.test.ts',
+  // Remedy-text suites: discoverability only. They pass explicit platform
+  // strings into pure classifiers and drive mocked rejections with hardcoded
+  // literals, so they assert identically on every runner. Registering them
+  // here does not claim Windows-specific behavioral coverage.
+  'test/unit/extension-load-error.test.ts',
+  'test/unit/fts-degraded-warning.test.ts',
+  // Vendored-root symlink containment uses realpathSync + path.relative; a
+  // prefix-only leak follows a Windows junction / POSIX symlink out of
+  // vendor/. Ubuntu-only would leave that guard unverified on the OS matrix.
+  'test/unit/lbug-extension-loader.test.ts',
   // Global registry writes use the platform-specific index-lock backend
   // (Windows named pipe, Linux socket, or macOS file lock). This includes the
   // overlapping-registration regression from #2716 on every OS matrix.
@@ -208,6 +222,7 @@ const SPAWN_CLI = [
   // FTS extension lifecycle — the #2374 bug was Windows-reported, so this must
   // run on the Windows/macOS matrix, not just the Ubuntu full suite.
   'test/integration/fts-extension-e2e.test.ts',
+  'test/integration/fts-vendored-root-seam.test.ts',
   'test/integration/server-http-startup.test.ts',
   'test/integration/mcp/server-startup.test.ts',
   'test/integration/analyze-heap-oom-e2e.test.ts',

package/scripts/ensure-fts.ts

@@ -1,14 +1,11 @@
 /**
- * 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.
+ * Make FTS and VECTOR resolvable for every shard before vitest starts.
  *
- * FTS-dependent tests split two ways: the LOAD-path gate (skipUnlessFtsAvailable)
- * self-installs on miss, but the FILE-path gate (requireFtsResourceOrSkip, e.g.
- * extension-binary-real.test.ts) resolves the extension path at module load and
- * cannot self-install. Sharding (and the balancing sequencer) can drop such a
- * test into a shard with no installer sibling — this step removes that ordering
- * dependency by installing FTS once before vitest starts. `auto` is LOAD-first,
- * so a cache-warmed extension costs no network.
+ * After vendoring, FTS is ready when the packaged artifact exists — LOAD
+ * no longer writes `~/.lbdb`, and the FILE-path gates resolve that artifact
+ * (or a leftover home install). When no artifact is present yet, fall back
+ * to one bounded `auto` INSTALL so shards without an installer sibling still
+ * find a file.
  *
  * Best-effort: exits 0 on failure (offline etc.) — the per-test gates still
  * hard-fail under GITNEXUS_REQUIRE_FTS=1 if FTS is genuinely unavailable, which
@@ -23,12 +20,17 @@ import {
   loadVectorExtension,
   closeLbug,
 } from '../src/core/lbug/lbug-adapter.js';
+import { resolveVendoredFtsPath } from '../src/core/lbug/vendored-extension-path.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).');
+  if (resolveVendoredFtsPath()) {
+    console.log('FTS extension ready (vendored artifact).');
+  } else {
+    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

package/vendor/lbug-fts/LICENSE

@@ -0,0 +1,27 @@
+The files under `prebuilds/` are the LadybugDB FTS extension, redistributed
+unchanged from https://extension.ladybugdb.com/. LadybugDB is MIT-licensed.
+There is no upstream-published digest for these artifacts; GitNexus records
+SHA-256 locally in `prebuilds/SHA256SUMS`.
+
+MIT License
+
+Copyright (c) 2022-2025 Kùzu Inc.
+Copyright (c) 2025-2026 Ladybug Memory Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.