noteconnection 1.7.0 → 1.9.0

package/dist/src/frontend.locale.contract.test.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function getNestedStringValue(record, dottedKey) {
+    const value = dottedKey.split('.').reduce((current, segment) => {
+        if (!current || typeof current !== 'object' || !(segment in current)) {
+            return null;
+        }
+        return current[segment];
+    }, record);
+    return typeof value === 'string' && value.trim().length > 0 ? value : null;
+}
+describe('frontend locale contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const enLocale = JSON.parse(fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'locales', 'en.json'), 'utf8'));
+    const zhLocale = JSON.parse(fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'locales', 'zh.json'), 'utf8'));
+    const requiredKeys = [
+        'analysis_title',
+        'node_details',
+        'reader_loading',
+        'reader_outline_title',
+        'reader_outline_empty',
+    ];
+    test('required reader and analysis keys resolve in both locales', () => {
+        const missing = requiredKeys.filter((key) => (!getNestedStringValue(enLocale, key) || !getNestedStringValue(zhLocale, key)));
+        expect(missing).toEqual([]);
+    });
+});

package/dist/src/frontend.runtime.assets.contract.test.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+describe('frontend runtime asset verifier', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const verifierPath = path.join(repoRoot, 'scripts', 'verify-frontend-runtime-assets.js');
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'noteconnection-frontend-assets-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    test('rejects an index that references a missing legacy runtime script', () => {
+        fs.writeFileSync(path.join(tempDir, 'index.html'), '<script src="markdown_runtime.js"></script><script src="workspace_panes.js"></script>', 'utf8');
+        fs.writeFileSync(path.join(tempDir, 'markdown_runtime.js'), 'window.runtime = true;', 'utf8');
+        const { verifyFrontendRuntimeAssets } = require(verifierPath);
+        expect(() => verifyFrontendRuntimeAssets(tempDir)).toThrow(/workspace_panes\.js/);
+    });
+    test('accepts an index when every local runtime script is present', () => {
+        fs.writeFileSync(path.join(tempDir, 'index.html'), '<script src="markdown_runtime.js"></script><script src="workspace_panes.js"></script><script src="https://example.invalid/remote.js"></script>', 'utf8');
+        fs.writeFileSync(path.join(tempDir, 'markdown_runtime.js'), 'window.runtime = true;', 'utf8');
+        fs.writeFileSync(path.join(tempDir, 'workspace_panes.js'), 'window.panes = true;', 'utf8');
+        const { verifyFrontendRuntimeAssets } = require(verifierPath);
+        expect(() => verifyFrontendRuntimeAssets(tempDir)).not.toThrow();
+    });
+    test('rejects an index that references a missing local stylesheet or module preload', () => {
+        fs.writeFileSync(path.join(tempDir, 'index.html'), '<link rel="stylesheet" href="styles.css"><link rel="modulepreload" href="assets/main.js"><script src="workspace_panes.js"></script>', 'utf8');
+        fs.writeFileSync(path.join(tempDir, 'workspace_panes.js'), 'window.panes = true;', 'utf8');
+        const { verifyFrontendRuntimeAssets } = require(verifierPath);
+        expect(() => verifyFrontendRuntimeAssets(tempDir)).toThrow(/styles\.css.*assets\/main\.js|assets\/main\.js.*styles\.css/);
+    });
+    test('cleans only stale Vite-owned bundle directories from the runtime destination', () => {
+        const copierPath = path.join(repoRoot, 'scripts', 'copy-assets.js');
+        fs.mkdirSync(path.join(tempDir, 'assets'), { recursive: true });
+        fs.mkdirSync(path.join(tempDir, 'vite-assets'), { recursive: true });
+        fs.writeFileSync(path.join(tempDir, 'assets', 'stale.js'), 'stale', 'utf8');
+        fs.writeFileSync(path.join(tempDir, 'vite-assets', 'stale.js'), 'stale', 'utf8');
+        fs.writeFileSync(path.join(tempDir, 'workspace_panes.js'), 'runtime', 'utf8');
+        const { cleanGeneratedFrontendBundleDirectories } = require(copierPath);
+        cleanGeneratedFrontendBundleDirectories(tempDir);
+        expect(fs.existsSync(path.join(tempDir, 'assets'))).toBe(false);
+        expect(fs.existsSync(path.join(tempDir, 'vite-assets'))).toBe(false);
+        expect(fs.readFileSync(path.join(tempDir, 'workspace_panes.js'), 'utf8')).toBe('runtime');
+    });
+});

package/dist/src/godot.sidecar.bootstrap.contract.test.js

@@ -0,0 +1,244 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const url_1 = require("url");
+class TempDir {
+    constructor(prefix) {
+        this.path = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), `${prefix}-`));
+    }
+    child(relative) {
+        return path.join(this.path, relative);
+    }
+    mkdir(relative) {
+        const target = this.child(relative);
+        fs.mkdirSync(target, { recursive: true });
+        return target;
+    }
+    cleanup() {
+        fs.rmSync(this.path, { recursive: true, force: true });
+    }
+}
+function sha256File(filePath) {
+    return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+describe('godot sidecar bootstrap contracts', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const sidecarUtilsPath = path.join(repoRoot, 'scripts', 'tauri-sidecar-utils.js');
+    let sidecarUtils;
+    let temp;
+    beforeAll(() => {
+        sidecarUtils = require(sidecarUtilsPath);
+    });
+    beforeEach(() => {
+        temp = new TempDir('noteconnection-godot-bootstrap');
+    });
+    afterEach(() => {
+        if (temp) {
+            temp.cleanup();
+        }
+    });
+    test('downloads and caches a host godot binary when a pinned file URL is configured', async () => {
+        const fakeRepoRoot = temp.mkdir('repo');
+        const downloadRoot = temp.mkdir('downloads');
+        const cacheRoot = temp.mkdir('cache');
+        const sourceBinaryPath = path.join(downloadRoot, 'godot-linux-x64');
+        const sourceBinary = Buffer.alloc(sidecarUtils.MIN_GODOT_BINARY_BYTES + 64, 7);
+        fs.writeFileSync(sourceBinaryPath, sourceBinary);
+        const result = await sidecarUtils.prepareGodotSidecar({
+            repoRoot: fakeRepoRoot,
+            platform: 'linux',
+            arch: 'x64',
+            env: {
+                NOTE_CONNECTION_GODOT_DOWNLOAD_URL: (0, url_1.pathToFileURL)(sourceBinaryPath).href,
+                NOTE_CONNECTION_GODOT_DOWNLOAD_SHA256: sha256File(sourceBinaryPath),
+                NOTE_CONNECTION_GODOT_CACHE_DIR: cacheRoot,
+            },
+            logger: console,
+        });
+        expect(result.outcome).toBe('prepared');
+        expect(result.sourceKind).toBe('download');
+        expect(fs.existsSync(result.targetPath)).toBe(true);
+        expect(fs.existsSync(result.cachePath)).toBe(true);
+        expect(fs.readFileSync(result.targetPath)).toEqual(sourceBinary);
+        expect(fs.readFileSync(result.cachePath)).toEqual(sourceBinary);
+    });
+    test('accepts GitHub Releases URLs as pinned bootstrap sources without provider-specific branching', () => {
+        const fakeRepoRoot = temp.mkdir('repo');
+        const cacheRoot = temp.mkdir('cache');
+        const githubReleaseUrl = 'https://github.com/Jacobinwwey/NoteConnection/releases/download/v1.7.0/godot-x86_64-unknown-linux-gnu';
+        const context = sidecarUtils.resolveGodotBootstrapContext({
+            repoRoot: fakeRepoRoot,
+            platform: 'linux',
+            arch: 'x64',
+            env: {
+                NOTE_CONNECTION_GODOT_DOWNLOAD_URL: githubReleaseUrl,
+                NOTE_CONNECTION_GODOT_DOWNLOAD_SHA256: 'abc123',
+                NOTE_CONNECTION_GODOT_CACHE_DIR: cacheRoot,
+            },
+        });
+        expect(context).not.toBeNull();
+        expect(context?.downloadUrl).toBe(githubReleaseUrl);
+        expect(context?.expectedSha256).toBe('abc123');
+        expect(context?.cachePath).toBe(path.join(cacheRoot, 'godot-x86_64-unknown-linux-gnu'));
+        expect(context?.targetPath).toBe(path.join(fakeRepoRoot, 'src-tauri', 'bin', 'godot-x86_64-unknown-linux-gnu'));
+    });
+    test('accepts generic object-storage mirror URLs through the same bootstrap contract', () => {
+        const fakeRepoRoot = temp.mkdir('repo');
+        const cacheRoot = temp.mkdir('cache');
+        const objectStorageUrl = 'https://mirror.example.invalid/noteconnection/godot/godot-x86_64-unknown-linux-gnu';
+        const context = sidecarUtils.resolveGodotBootstrapContext({
+            repoRoot: fakeRepoRoot,
+            platform: 'linux',
+            arch: 'x64',
+            env: {
+                NOTE_CONNECTION_GODOT_DOWNLOAD_URL: objectStorageUrl,
+                NOTE_CONNECTION_GODOT_DOWNLOAD_SHA256: 'def456',
+                NOTE_CONNECTION_GODOT_CACHE_DIR: cacheRoot,
+            },
+        });
+        expect(context).not.toBeNull();
+        expect(context?.downloadUrl).toBe(objectStorageUrl);
+        expect(context?.expectedSha256).toBe('def456');
+        expect(context?.cachePath).toBe(path.join(cacheRoot, 'godot-x86_64-unknown-linux-gnu'));
+    });
+    test('reuses cached godot binary when the original download source is gone', async () => {
+        const fakeRepoRoot = temp.mkdir('repo');
+        const downloadRoot = temp.mkdir('downloads');
+        const cacheRoot = temp.mkdir('cache');
+        const sourceBinaryPath = path.join(downloadRoot, 'godot-linux-x64');
+        fs.writeFileSync(sourceBinaryPath, Buffer.alloc(sidecarUtils.MIN_GODOT_BINARY_BYTES + 32, 3));
+        const env = {
+            NOTE_CONNECTION_GODOT_DOWNLOAD_URL: (0, url_1.pathToFileURL)(sourceBinaryPath).href,
+            NOTE_CONNECTION_GODOT_DOWNLOAD_SHA256: sha256File(sourceBinaryPath),
+            NOTE_CONNECTION_GODOT_CACHE_DIR: cacheRoot,
+        };
+        const first = await sidecarUtils.prepareGodotSidecar({
+            repoRoot: fakeRepoRoot,
+            platform: 'linux',
+            arch: 'x64',
+            env,
+            logger: console,
+        });
+        expect(first.sourceKind).toBe('download');
+        fs.rmSync(sourceBinaryPath, { force: true });
+        fs.rmSync(first.targetPath, { force: true });
+        const second = await sidecarUtils.prepareGodotSidecar({
+            repoRoot: fakeRepoRoot,
+            platform: 'linux',
+            arch: 'x64',
+            env,
+            logger: console,
+        });
+        expect(second.outcome).toBe('prepared');
+        expect(second.sourceKind).toBe('cache');
+        expect(fs.existsSync(second.targetPath)).toBe(true);
+    });
+    test('rejects downloaded godot binaries when sha256 does not match the pinned value', async () => {
+        const fakeRepoRoot = temp.mkdir('repo');
+        const downloadRoot = temp.mkdir('downloads');
+        const cacheRoot = temp.mkdir('cache');
+        const sourceBinaryPath = path.join(downloadRoot, 'godot-linux-x64');
+        fs.writeFileSync(sourceBinaryPath, Buffer.alloc(sidecarUtils.MIN_GODOT_BINARY_BYTES + 16, 9));
+        await expect(sidecarUtils.prepareGodotSidecar({
+            repoRoot: fakeRepoRoot,
+            platform: 'linux',
+            arch: 'x64',
+            env: {
+                NOTE_CONNECTION_GODOT_DOWNLOAD_URL: (0, url_1.pathToFileURL)(sourceBinaryPath).href,
+                NOTE_CONNECTION_GODOT_DOWNLOAD_SHA256: 'deadbeef',
+                NOTE_CONNECTION_GODOT_CACHE_DIR: cacheRoot,
+            },
+            logger: console,
+        })).rejects.toThrow(/sha256/i);
+    });
+    test('does not require a linux host godot binary by default when validating sidecars', () => {
+        const fakeRepoRoot = temp.mkdir('repo');
+        const binDir = temp.mkdir(path.join('repo', 'src-tauri', 'bin'));
+        fs.writeFileSync(path.join(binDir, 'server-x86_64-unknown-linux-gnu'), 'server');
+        fs.writeFileSync(path.join(binDir, 'markdown-worker-x86_64-unknown-linux-gnu'), 'worker');
+        const result = sidecarUtils.validateTauriSidecars({
+            repoRoot: fakeRepoRoot,
+            platform: 'linux',
+            arch: 'x64',
+        });
+        expect(sidecarUtils.resolveHostGodotBinaryName({ platform: 'linux', arch: 'x64' })).toBe('godot-x86_64-unknown-linux-gnu');
+        expect(result.invalid).toEqual([]);
+    });
+    test('requires the windows host godot binary together with server and markdown worker sidecars', () => {
+        const fakeRepoRoot = temp.mkdir('repo');
+        const binDir = temp.mkdir(path.join('repo', 'src-tauri', 'bin'));
+        fs.writeFileSync(path.join(binDir, 'server-x86_64-pc-windows-msvc.exe'), 'server');
+        fs.writeFileSync(path.join(binDir, 'markdown-worker-x86_64-pc-windows-msvc.exe'), 'worker');
+        const missingGodot = sidecarUtils.validateTauriSidecars({
+            repoRoot: fakeRepoRoot,
+            platform: 'win32',
+            arch: 'x64',
+        });
+        expect(missingGodot.invalid).toEqual([
+            expect.stringContaining('godot-x86_64-pc-windows-msvc.exe'),
+        ]);
+        fs.writeFileSync(path.join(binDir, 'godot-x86_64-pc-windows-msvc.exe'), Buffer.alloc(sidecarUtils.MIN_GODOT_BINARY_BYTES + 8, 5));
+        const ready = sidecarUtils.validateTauriSidecars({
+            repoRoot: fakeRepoRoot,
+            platform: 'win32',
+            arch: 'x64',
+        });
+        expect(ready.invalid).toEqual([]);
+    });
+    test('treats git-lfs pointer placeholders as invalid server and markdown-worker sidecars', () => {
+        const fakeRepoRoot = temp.mkdir('repo');
+        const binDir = temp.mkdir(path.join('repo', 'src-tauri', 'bin'));
+        const lfsPointer = [
+            'version https://git-lfs.github.com/spec/v1',
+            'oid sha256:deadbeef',
+            'size 12345678',
+        ].join('\n');
+        fs.writeFileSync(path.join(binDir, 'server-x86_64-unknown-linux-gnu'), lfsPointer);
+        fs.writeFileSync(path.join(binDir, 'markdown-worker-x86_64-unknown-linux-gnu'), lfsPointer);
+        const result = sidecarUtils.validateTauriSidecars({
+            repoRoot: fakeRepoRoot,
+            platform: 'linux',
+            arch: 'x64',
+        });
+        expect(result.invalid).toEqual([
+            expect.stringContaining('server-x86_64-unknown-linux-gnu'),
+            expect.stringContaining('markdown-worker-x86_64-unknown-linux-gnu'),
+        ]);
+    });
+});

package/dist/src/graph.answer.operator.contract.test.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function extractFunctionBody(source, functionName) {
+    const functionStart = source.indexOf(`function ${functionName}(`);
+    if (functionStart < 0)
+        throw new Error(`Function not found: ${functionName}`);
+    const openBrace = source.indexOf('{', functionStart);
+    let depth = 0;
+    for (let index = openBrace; index < source.length; index += 1) {
+        if (source[index] === '{')
+            depth += 1;
+        if (source[index] === '}')
+            depth -= 1;
+        if (depth === 0)
+            return source.slice(openBrace, index + 1);
+    }
+    throw new Error(`Function body is incomplete: ${functionName}`);
+}
+describe('graph answer operator inspector contract', () => {
+    const frontendRoot = path.join(__dirname, 'frontend');
+    const workspaceSource = fs.readFileSync(path.join(frontendRoot, 'agent_workspace.js'), 'utf8');
+    const panesSource = fs.readFileSync(path.join(frontendRoot, 'workspace_panes.js'), 'utf8');
+    test('projects plan, coverage, and bounded expansion only through grounding diagnostics', () => {
+        expect(workspaceSource).toContain('graphAnswerPlan');
+        expect(workspaceSource).toContain('graphAnswerCoverage');
+        expect(workspaceSource).toContain('graphExpansion');
+        expect(panesSource).toContain('buildEvidenceGraphAnswerPlanHtml');
+        expect(panesSource).toContain("agentWorkspace.evidence.graphAnswerPlanLabel");
+        expect(panesSource).toContain('missingRequiredClaimIds');
+        expect(panesSource).toContain('executedSteps');
+    });
+    test('does not render plan scaffolding in the public assistant answer block', () => {
+        const answerRenderer = extractFunctionBody(workspaceSource, 'appendAssistantConversationResult');
+        expect(answerRenderer).not.toContain('graphAnswerPlan');
+        expect(answerRenderer).not.toContain('graphAnswerCoverage');
+    });
+});

package/dist/src/index.js

@@ -42,7 +42,7 @@ async function buildGraph(options, maxWorkers, enableGPU, enableGPULayout, memor
     const runtimePaths = (0, RuntimePaths_1.resolveRuntimePaths)(__dirname);
     const projectRoot = runtimePaths.projectRoot;
     const runtimeDataDir = runtimePaths.runtimeDataDir;
-    let buildOptions = { projectRoot };
+    let buildOptions = { projectRoot, knowledgeBaseRoot: runtimePaths.kbRoot };
     if (typeof options === 'string') {
         // Legacy signature support
         buildOptions.targetPath = options;
@@ -54,7 +54,11 @@ async function buildGraph(options, maxWorkers, enableGPU, enableGPULayout, memor
     }
     else {
         // New object signature
-        buildOptions = { ...options, projectRoot };
+        buildOptions = {
+            ...options,
+            projectRoot,
+            knowledgeBaseRoot: options.knowledgeBaseRoot ?? runtimePaths.kbRoot,
+        };
         // Map frontend 'target' to backend 'targetPath'
         // Frontend uses 'target', BuildOptions interface expects 'targetPath'
         if (options.target && !buildOptions.targetPath) {

package/dist/src/index.knowledge-root.test.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const index_1 = require("./index");
+const config_1 = require("./backend/config");
+const NoteConnection_1 = require("./core/NoteConnection");
+describe('Graph builds in the selected knowledge workspace', () => {
+    const environmentKeys = [
+        'NOTE_CONNECTION_PROJECT_ROOT',
+        'NOTE_CONNECTION_KB_ROOT',
+        'NOTE_CONNECTION_FRONTEND_DIR',
+        'NOTE_CONNECTION_RUNTIME_DATA_DIR',
+    ];
+    const originalConfig = { ...config_1.config, exclusionList: [...config_1.config.exclusionList] };
+    let previousEnvironment;
+    let fixtureRoot;
+    let projectRoot;
+    let selectedRoot;
+    beforeEach(() => {
+        previousEnvironment = environmentKeys.map(key => process.env[key]);
+        fixtureRoot = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-selected-kb-')));
+        projectRoot = path.join(fixtureRoot, 'application');
+        selectedRoot = path.join(fixtureRoot, 'selected-vault');
+        const frontendRoot = path.join(projectRoot, 'dist', 'src', 'frontend');
+        const runtimeRoot = path.join(fixtureRoot, 'runtime-data');
+        for (const directory of [path.join(projectRoot, 'Knowledge_Base'), path.join(selectedRoot, 'notes'), frontendRoot, runtimeRoot]) {
+            fs.mkdirSync(directory, { recursive: true });
+        }
+        fs.writeFileSync(path.join(projectRoot, 'Knowledge_Base', 'Default.md'), '# Default\nThis is a different workspace.');
+        fs.writeFileSync(path.join(selectedRoot, 'notes', 'Alpha.md'), '# Alpha\nAlpha requires [[Beta]].');
+        fs.writeFileSync(path.join(selectedRoot, 'notes', 'Beta.md'), '# Beta\nBeta is the prerequisite foundation.');
+        [projectRoot, selectedRoot, frontendRoot, runtimeRoot].forEach((directory, index) => {
+            process.env[environmentKeys[index]] = directory;
+        });
+        Object.assign(config_1.config, {
+            enableTags: false,
+            enableStatisticalInference: false,
+            enableVectorSimilarity: false,
+            enableHybridInference: false,
+            enableGPU: false,
+            enableGPULayout: false,
+            clusteringStrategy: 'folder',
+            maxWorkers: 1,
+            exclusionList: [],
+        });
+    });
+    afterEach(() => {
+        environmentKeys.forEach((key, index) => {
+            const previous = previousEnvironment[index];
+            if (previous === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = previous;
+        });
+        Object.assign(config_1.config, originalConfig);
+        fs.rmSync(fixtureRoot, { recursive: true, force: true });
+    });
+    test('builds an absolute native target with identities relative to the selected workspace', async () => {
+        const graph = await (0, index_1.buildGraph)({ targetPath: path.join(selectedRoot, 'notes') });
+        expect(graph.nodes.map((node) => node.id).sort()).toEqual(['Alpha', 'Beta']);
+        expect(graph.nodes.find((node) => node.id === 'Alpha')).toEqual(expect.objectContaining({
+            canonicalId: 'notes/alpha',
+            sourceUri: 'note://workspace/v1/notes/alpha.md',
+        }));
+    });
+    test('resolves a relative CLI target against the selected workspace', async () => {
+        const graph = await (0, index_1.buildGraph)('notes');
+        expect(graph.nodes.map((node) => node.canonicalId).sort()).toEqual(['notes/alpha', 'notes/beta']);
+    });
+    test('builds the entire selected workspace without reading the application default', async () => {
+        const graph = await (0, index_1.buildGraph)({});
+        expect(graph.nodes.map((node) => node.id).sort()).toEqual(['Alpha', 'Beta']);
+    });
+    test('preserves the direct library default independently of runtime environment overrides', async () => {
+        const result = await NoteConnection_1.NoteConnection.build({ projectRoot });
+        expect(result.data.nodes.map((node) => node.id)).toEqual(['Default']);
+    });
+    test('accepts an explicit library knowledge root without moving the application root', async () => {
+        const result = await NoteConnection_1.NoteConnection.build({ projectRoot, knowledgeBaseRoot: selectedRoot, targetPath: 'notes' });
+        expect(result.stats.fileCount).toBe(2);
+        expect(result.data.nodes.map((node) => node.canonicalId).sort()).toEqual(['notes/alpha', 'notes/beta']);
+    });
+});