noteconnection 1.8.0 → 1.9.0

package/dist/src/frontend/styles.css

@@ -1566,17 +1566,9 @@ body.agent-workspace-open .agent-workspace-drawer {
 }
 
 .agent-chat-pane {
-  display: grid;
-  grid-template-rows:
-    auto
-    auto
-    auto
-    minmax(128px, 0.92fr)
-    minmax(128px, 0.62fr)
-    auto
-    auto
-    auto;
-  max-height: calc(100vh - 142px);
+  display: flex;
+  flex-direction: column;
+  height: calc(100vh - 142px);
   padding: 16px;
   gap: 12px;
   overflow-x: hidden;
@@ -1585,6 +1577,10 @@ body.agent-workspace-open .agent-workspace-drawer {
   scrollbar-gutter: stable;
 }
 
+.agent-chat-pane > * {
+  flex-shrink: 0;
+}
+
 .agent-pane-header,
 .agent-workspace-pane-header {
   display: flex;
@@ -1683,6 +1679,101 @@ body.agent-workspace-open .agent-workspace-drawer {
   grid-column: 2;
 }
 
+.agent-answer-language-control {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 8px 0 12px;
+  color: var(--text-secondary, #9aa4b2);
+  font-size: 0.78rem;
+}
+
+.agent-answer-language-control select {
+  min-width: 108px;
+  padding: 4px 8px;
+  border: 1px solid var(--border-subtle, #3d4652);
+  border-radius: 4px;
+  background: var(--surface-input, #1c232d);
+  color: var(--text-primary, #e8edf3);
+}
+
+.agent-answer-language-summary {
+  color: var(--text-muted, #758195);
+}
+
+.agent-response-mode-control {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 8px 0 12px;
+  color: var(--text-secondary, #9aa4b2);
+  font-size: 0.78rem;
+}
+
+.agent-response-mode-control select {
+  min-width: 112px;
+  padding: 4px 8px;
+  border: 1px solid var(--border-subtle, #3d4652);
+  border-radius: 4px;
+  background: var(--surface-input, #1c232d);
+  color: var(--text-primary, #e8edf3);
+}
+
+.agent-response-mode-summary {
+  color: var(--text-muted, #758195);
+  overflow-wrap: anywhere;
+}
+
+.agent-response-budget-control {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 8px 0 12px;
+  color: var(--text-secondary, #9aa4b2);
+  font-size: 0.78rem;
+}
+
+.agent-response-budget-control select {
+  min-width: 132px;
+  padding: 4px 8px;
+  border: 1px solid var(--border-subtle, #3d4652);
+  border-radius: 4px;
+  background: var(--surface-input, #1c232d);
+  color: var(--text-primary, #e8edf3);
+}
+
+.agent-response-budget-summary {
+  color: var(--text-muted, #758195);
+  overflow-wrap: anywhere;
+}
+
+.agent-chat-structured-answer-next-actions-toggle {
+  width: 26px;
+  height: 26px;
+  min-width: 26px;
+  margin: 8px 0 0 auto;
+  padding: 0;
+  border: 1px solid var(--border-subtle, #3d4652);
+  border-radius: 50%;
+  background: var(--surface-raised, #252e3a);
+  color: var(--text-primary, #e8edf3);
+  cursor: pointer;
+  line-height: 24px;
+  text-align: center;
+}
+
+.agent-chat-structured-answer-next-actions-toggle:hover,
+.agent-chat-structured-answer-next-actions-toggle:focus-visible {
+  border-color: var(--accent, #6ea8fe);
+  outline: none;
+}
+
+.agent-chat-structured-answer-next-actions {
+  margin-top: 8px;
+  padding-top: 8px;
+  border-top: 1px solid var(--border-subtle, #3d4652);
+}
+
 .agent-pane-field label {
   color: #cbd5e1;
   font-size: 0.84rem;
@@ -1808,7 +1899,9 @@ body.agent-workspace-open .agent-workspace-drawer {
 }
 
 .agent-chat-messages {
-  min-height: 0;
+  /* The transcript owns spare height even when optional controls are inserted. */
+  flex: 1 0 240px;
+  min-height: 128px;
   display: flex;
   flex-direction: column;
   gap: 10px;
@@ -2124,6 +2217,7 @@ body.agent-workspace-open .agent-workspace-drawer {
 
 .agent-knowledge-points {
   min-height: 0;
+  max-height: min(200px, 24vh);
   display: flex;
   flex-direction: column;
   gap: 10px;
@@ -3603,7 +3697,7 @@ body[data-agent-workspace-promotion="learning-path"] #agent-learning-path-pane {
   }
 
   .agent-chat-pane {
-    max-height: none;
+    height: auto;
   }
 
   .agent-side-work-area {

package/dist/src/frontend/workspace_panes.js

@@ -5673,6 +5673,50 @@
         `;
     }
 
+    function buildEvidenceGraphAnswerPlanHtml(payload) {
+        const plan = payload && payload.graphAnswerPlan && typeof payload.graphAnswerPlan === 'object'
+            ? payload.graphAnswerPlan
+            : null;
+        const coverage = payload && payload.graphAnswerCoverage && typeof payload.graphAnswerCoverage === 'object'
+            ? payload.graphAnswerCoverage
+            : null;
+        const expansion = payload && payload.graphExpansion && typeof payload.graphExpansion === 'object'
+            ? payload.graphExpansion
+            : null;
+        if (!plan && !coverage && !expansion) return '';
+        const requiredClaimIds = Array.isArray(coverage && coverage.requiredClaimIds) ? coverage.requiredClaimIds : [];
+        const coveredClaimIds = Array.isArray(coverage && coverage.coveredClaimIds) ? coverage.coveredClaimIds : [];
+        const missingRequiredClaimIds = Array.isArray(coverage && coverage.missingRequiredClaimIds)
+            ? coverage.missingRequiredClaimIds
+            : [];
+        const omissions = Array.isArray(plan && plan.omittedCandidates) ? plan.omittedCandidates : [];
+        const metrics = [
+            {
+                title: translate('agentWorkspace.evidence.graphAnswerIntentLabel', 'Intent / depth'),
+                value: [String(plan && plan.intent || '').trim(), String(plan && plan.depth || '').trim()].filter(Boolean).join(' / ') || 'none',
+            },
+            {
+                title: translate('agentWorkspace.evidence.graphAnswerCoverageLabel', 'Required claim coverage'),
+                value: `${coveredClaimIds.length}/${requiredClaimIds.length} (${Number((Number(coverage && coverage.coverageScore || 0) * 100).toFixed(2))}%)`,
+            },
+            {
+                title: translate('agentWorkspace.evidence.graphAnswerMissingLabel', 'Missing required claims'),
+                value: missingRequiredClaimIds.join(', ') || 'none',
+            },
+            {
+                title: translate('agentWorkspace.evidence.graphAnswerOmissionsLabel', 'Omitted graph candidates'),
+                value: String(omissions.length),
+            },
+            {
+                title: translate('agentWorkspace.evidence.graphExpansionLabel', 'Bounded expansion'),
+                value: expansion
+                    ? `${String(expansion.executedSteps || 0)}/${String(expansion.maxSteps || 0)} steps; ${String(expansion.selectedNeighborCount || 0)}/${String(expansion.maxNeighbors || 0)} neighbors`
+                    : 'none',
+            },
+        ];
+        return `<div class="agent-pane-section-title">${escapeHtml(translate('agentWorkspace.evidence.graphAnswerPlanLabel', 'Graph answer plan'))}</div><ul class="agent-pane-list">${buildEvidenceMetricListHtml(metrics)}</ul>`;
+    }
+
     function renderEvidenceGroundingBody(body, payload) {
         const title = String(
             payload.title
@@ -5703,6 +5747,7 @@
         const metricsHtml = buildEvidenceMetricListHtml(metrics);
         const ragContextHtml = buildEvidenceRagContextHtml(payload);
         const graphContextHtml = buildEvidenceGraphContextHtml(payload);
+        const graphAnswerPlanHtml = buildEvidenceGraphAnswerPlanHtml(payload);
         body.innerHTML = `
             <div class="agent-pane-block">
                 <div class="agent-pane-title">${escapeHtml(title)}</div>
@@ -5711,6 +5756,7 @@
                 ${missMessage ? `<div class="agent-pane-section-title">${escapeHtml(translate('agentWorkspace.evidence.missLabel', 'Scope recovery'))}</div><div class="agent-pane-summary">${escapeHtml(missMessage)}</div>` : ''}
                 ${ragContextHtml}
                 ${graphContextHtml}
+                ${graphAnswerPlanHtml}
             </div>
         `;
     }
@@ -9182,13 +9228,71 @@
         ).trim();
         wrapper.appendChild(title);
 
-        const directAnswer = String(block && block.directAnswer || '').trim();
-        if (directAnswer) {
-            const summary = document.createElement('div');
-            summary.className = 'agent-chat-inline-card-summary agent-chat-structured-answer-direct';
-            summary.textContent = directAnswer;
-            summary.setAttribute('data-structured-answer-section', 'directAnswer');
-            wrapper.appendChild(summary);
+        const appendMarkdownSection = async function (sectionName, rawMarkdown, className) {
+            const markdown = String(rawMarkdown || '').trim();
+            if (!markdown) {
+                return;
+            }
+            const section = document.createElement('div');
+            section.className = className;
+            section.setAttribute('data-structured-answer-section', sectionName);
+            if (markdownRuntime && typeof markdownRuntime.renderMarkdownInto === 'function') {
+                await markdownRuntime.renderMarkdownInto(section, markdown);
+            } else {
+                section.style.whiteSpace = 'pre-wrap';
+                section.textContent = markdown;
+            }
+            wrapper.appendChild(section);
+        };
+
+        await appendMarkdownSection(
+            'directAnswer',
+            block && block.directAnswer,
+            'agent-chat-inline-card-summary agent-chat-structured-answer-direct agent-chat-structured-answer-markdown'
+        );
+        const nextActionsMarkdown = String(block && block.nextActionsMarkdown || '').trim();
+        if (nextActionsMarkdown) {
+            const nextActionsToggle = document.createElement('button');
+            nextActionsToggle.type = 'button';
+            nextActionsToggle.className = 'agent-chat-structured-answer-next-actions-toggle';
+            nextActionsToggle.setAttribute('data-structured-answer-next-actions-toggle', 'true');
+            const setNextActionsExpanded = function (expanded) {
+                const label = expanded
+                    ? translate('agentWorkspace.reply.hideNextActions', 'Hide next actions')
+                    : translate('agentWorkspace.reply.showNextActions', 'Show next actions');
+                nextActionsToggle.setAttribute('aria-expanded', expanded ? 'true' : 'false');
+                nextActionsToggle.setAttribute('aria-label', label);
+                nextActionsToggle.title = label;
+                nextActionsToggle.textContent = expanded ? '-' : '+';
+            };
+            setNextActionsExpanded(false);
+            nextActionsToggle.addEventListener('click', function () {
+                const expanded = nextActionsToggle.getAttribute('aria-expanded') === 'true';
+                if (expanded) {
+                    const existingPanel = wrapper.querySelector('[data-structured-answer-next-actions-panel]');
+                    existingPanel?.remove();
+                    setNextActionsExpanded(false);
+                    return;
+                }
+                const panel = document.createElement('div');
+                panel.className = 'agent-chat-structured-answer-section agent-chat-structured-answer-next-actions';
+                panel.setAttribute('data-structured-answer-next-actions-panel', 'true');
+                panel.setAttribute('data-structured-answer-section', 'nextActionsMarkdown');
+                wrapper.insertBefore(panel, nextActionsToggle);
+                setNextActionsExpanded(true);
+                if (markdownRuntime && typeof markdownRuntime.renderMarkdownInto === 'function') {
+                    Promise.resolve(markdownRuntime.renderMarkdownInto(panel, nextActionsMarkdown)).catch(function () {
+                        if (panel.parentNode === wrapper) {
+                            panel.remove();
+                            setNextActionsExpanded(false);
+                        }
+                    });
+                } else {
+                    panel.style.whiteSpace = 'pre-wrap';
+                    panel.textContent = nextActionsMarkdown;
+                }
+            });
+            wrapper.appendChild(nextActionsToggle);
         }
 
         return wrapper;

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

package/dist/src/indexing/IndexLifecycle.js

@@ -109,6 +109,28 @@ class IndexLifecycle {
         });
         this.unitIdsByDocumentId.delete(String(documentId || '').trim());
     }
+    /**
+     * Moves the indexed path in place. Rebuilding units would allocate new
+     * segments and make a path-only identity transition look like content
+     * churn, so the existing index identity is deliberately preserved.
+     */
+    updateDocumentSourcePath(documentId, sourcePath, updatedAt) {
+        const unitIds = this.unitIdsByDocumentId.get(String(documentId || '').trim()) || [];
+        let updatedCount = 0;
+        unitIds.forEach((unitId) => {
+            const unit = this.units.get(unitId);
+            if (!unit) {
+                return;
+            }
+            this.units.set(unitId, {
+                ...unit,
+                sourcePath,
+                updatedAt,
+            });
+            updatedCount += 1;
+        });
+        return updatedCount;
+    }
     listSegmentsForAtom(atomId) {
         const segmentIds = this.segmentIdsByAtomId.get(String(atomId || '').trim()) || [];
         return segmentIds

package/dist/src/indexing/IndexLifecycle.test.js

@@ -46,4 +46,28 @@ describe('IndexLifecycle', () => {
         expect(lifecycle.hasIndexedSegmentsForAtom('atom_1')).toBe(false);
         expect(lifecycle.buildSummary().totalUnits).toBe(0);
     });
+    test('updates indexed source paths in place during a document move', () => {
+        let idCounter = 0;
+        const lifecycle = new IndexLifecycle_1.IndexLifecycle((prefix = 'index') => `${prefix}_${++idCounter}`, (value) => `hash_${value.length}`);
+        const indexed = lifecycle.syncDocumentIndex({
+            resourceId: 'resource_move',
+            projectionId: 'projection_move',
+            documentId: 'doc_move',
+            sourcePath: 'Knowledge_Base/old.md',
+            language: 'en',
+            workspaceId: 'workspace',
+            corpusId: 'corpus',
+            title: 'old',
+            content: '# Move\nContent',
+            atoms: [],
+            indexedAt: '2026-05-26T06:00:00.000Z',
+        });
+        expect(lifecycle.updateDocumentSourcePath('doc_move', 'Knowledge_Base/new.md', '2026-05-26T07:00:00.000Z')).toBe(indexed.units.length);
+        expect(lifecycle.listUnitsByProjectionIds(['projection_move'])).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                sourcePath: 'Knowledge_Base/new.md',
+                updatedAt: '2026-05-26T07:00:00.000Z',
+            }),
+        ]));
+    });
 });