noteconnection 1.7.0 → 1.9.0

package/dist/src/startup.layout.snapshot.contract.test.js

@@ -0,0 +1,57 @@
+"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"));
+describe('startup layout snapshot contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const appPath = path.join(repoRoot, 'src', 'frontend', 'app.js');
+    test('rejects and purges degenerate persisted layout snapshots', () => {
+        const source = fs.readFileSync(appPath, 'utf8');
+        expect(source).toContain('async function deleteStartupLayoutSnapshotRecord(fingerprint)');
+        expect(source).toContain("reason: 'degenerate-layout'");
+        expect(source).toContain("reason: 'degenerate-layout-vs-source'");
+        expect(source).toContain('function isDegenerateLayoutSummary(summary)');
+        expect(source).toContain('function isSnapshotLayoutCollapsedVsSource(summary, sourceSummary)');
+        expect(source).toContain('if (validation.purge === true && record.fingerprint)');
+    });
+    test('restores startup snapshots without re-applying persisted fx/fy pinning and re-seeds collapsed layouts', () => {
+        const source = fs.readFileSync(appPath, 'utf8');
+        expect(source).toContain('n.fx = null;');
+        expect(source).toContain('n.fy = null;');
+        expect(source).toContain("restoreSourceLayoutOrJitterNodes(nodes, width, height, 'worker-init');");
+        expect(source).toContain('function restoreSourceLayoutOrJitterNodes(nodeList, viewportWidth, viewportHeight, reason = \'\')');
+    });
+});

package/dist/src/storage.provider.capacitor.content.contract.test.js

@@ -41,6 +41,9 @@ describe('storage provider capacitor content mapping contract', () => {
     test('maps desktop-style Knowledge_Base paths for capacitor content reads', () => {
         const source = fs.readFileSync(storageProviderPath, 'utf8');
         expect(source).toContain('function extractRelativePathFromKbMarker(rawFilePath)');
+        expect(source).toContain('function extractRelativePathFromWorkspaceUri(rawFilePath)');
+        expect(source).toContain("const prefix = 'note://workspace/v1/'");
+        expect(source).toContain('const relativeFromWorkspaceUri = extractRelativePathFromWorkspaceUri(raw);');
         expect(source).toContain('function resolveCapacitorContentCandidatePath(rawFilePath)');
         expect(source).toContain("if (/^[A-Za-z]:\\//.test(normalized) || normalized.startsWith('/')) {");
         expect(source).toContain('Cannot map absolute desktop path on Capacitor without Knowledge_Base marker.');
@@ -49,6 +52,6 @@ describe('storage provider capacitor content mapping contract', () => {
         const source = fs.readFileSync(storageProviderPath, 'utf8');
         expect(source).toContain('if (isCapacitorNativeRuntime()) {');
         expect(source).toContain('const capacitorPath = resolveCapacitorContentCandidatePath(filePath);');
-        expect(source).toContain('return await capacitorReadText(capacitorPath);');
+        expect(source).toContain('return await capacitorReadText(capacitorPath, {');
     });
 });

package/dist/src/storage.provider.contract.test.js

@@ -35,6 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const browserTestWindow = {};
+globalThis.window = browserTestWindow;
+const storageProvider = require('./frontend/storage_provider.js');
 describe('storage provider abstraction contract', () => {
     const repoRoot = path.resolve(__dirname, '..');
     const storageProviderPath = path.join(repoRoot, 'src', 'frontend', 'storage_provider.js');
@@ -43,6 +46,138 @@ describe('storage provider abstraction contract', () => {
         expect(source).toContain('window.NoteConnectionStorage = {');
         expect(source).toContain('createProvider');
         expect(source).toContain('class RuntimeStorageProvider');
+        expect(source).toContain('getStorageResolution()');
+        expect(source).toContain('async refreshStorageResolution()');
+        expect(source).toContain("sidecarFetchJson('api/knowledge/store-diagnostics')");
+        expect(source).toContain('supportsProjection');
+    });
+    test('forces projection resolution on Android even when a stale SQLite capability is reported', () => {
+        const provider = storageProvider.createProvider({
+            runtimeCaps: {
+                platform: 'android',
+                supports_projection_store: true,
+                supports_sqlite: true,
+                storage_requested_provider: 'sqlite',
+                storage_resolved_provider: 'sqlite',
+            },
+        });
+        expect(provider.getStorageResolution()).toEqual(expect.objectContaining({
+            requestedProvider: 'sqlite',
+            resolvedProvider: 'projection',
+            fallbackReason: 'native_sqlite_runtime_unavailable',
+            supportsSqlite: false,
+            supportsProjection: true,
+        }));
+    });
+    test('forces projection resolution for an iOS/mobile host without Capacitor globals', () => {
+        const provider = storageProvider.createProvider({
+            runtimeCaps: {
+                platform: 'ios',
+                supports_projection_store: true,
+                supports_sqlite: true,
+                storage_requested_provider: 'sqlite',
+                storage_resolved_provider: 'sqlite',
+            },
+        });
+        expect(provider.getStorageResolution()).toEqual(expect.objectContaining({
+            requestedProvider: 'sqlite',
+            resolvedProvider: 'projection',
+            fallbackReason: 'native_sqlite_runtime_unavailable',
+            supportsSqlite: false,
+            supportsProjection: true,
+        }));
+    });
+    test('keeps SQLite as the desktop default and exposes file fallback explicitly', () => {
+        const sqliteProvider = storageProvider.createProvider({
+            runtimeCaps: {
+                platform: 'win32',
+                supports_sidecar: true,
+                supports_sqlite: true,
+                storage_resolved_provider: 'sqlite',
+            },
+        });
+        expect(sqliteProvider.getStorageResolution()).toEqual(expect.objectContaining({
+            requestedProvider: 'sqlite',
+            resolvedProvider: 'sqlite',
+            supportsSqlite: true,
+        }));
+        const fallbackProvider = storageProvider.createProvider({
+            runtimeCaps: {
+                platform: 'linux',
+                supports_sidecar: false,
+                supports_sqlite: false,
+                storage_requested_provider: 'sqlite',
+                storage_resolved_provider: 'file',
+                storage_fallback_reason: 'sqlite_runtime_unavailable',
+            },
+        });
+        expect(fallbackProvider.getStorageResolution()).toEqual(expect.objectContaining({
+            requestedProvider: 'sqlite',
+            resolvedProvider: 'file',
+            fallbackReason: 'sqlite_runtime_unavailable',
+            supportsSqlite: false,
+            supportsProjection: false,
+        }));
+    });
+    test('does not treat desktop capability support as an active SQLite resolution before diagnostics', () => {
+        const provider = storageProvider.createProvider({
+            runtimeCaps: {
+                platform: 'win32',
+                supports_sidecar: true,
+                supports_sqlite: true,
+                storage_requested_provider: 'sqlite',
+                storage_resolved_provider: 'unknown',
+            },
+        });
+        expect(provider.getStorageResolution()).toEqual(expect.objectContaining({
+            requestedProvider: 'sqlite',
+            resolvedProvider: undefined,
+            supportsSqlite: false,
+        }));
+    });
+    test('refreshes desktop resolution from authoritative sidecar diagnostics', async () => {
+        const previousWindow = globalThis.window;
+        const previousFetch = globalThis.fetch;
+        const runtimeWindow = {
+            NoteConnectionRuntime: {
+                buildUrl: (resourcePath) => `http://127.0.0.1:3000/${resourcePath}`,
+                buildFetchOptions: () => ({ cache: 'no-store' }),
+            },
+        };
+        globalThis.window = runtimeWindow;
+        globalThis.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                store: {
+                    requestedProvider: 'sqlite',
+                    resolvedProvider: 'file',
+                    storageEngine: 'file',
+                    fallbackReason: 'sqlite_runtime_unavailable',
+                },
+            }),
+        });
+        try {
+            const provider = storageProvider.createProvider({
+                runtimeCaps: {
+                    platform: 'win32',
+                    supports_sidecar: true,
+                    supports_sqlite: true,
+                    storage_requested_provider: 'sqlite',
+                    storage_resolved_provider: 'sqlite',
+                },
+            });
+            await expect(provider.refreshStorageResolution()).resolves.toEqual(expect.objectContaining({
+                requestedProvider: 'sqlite',
+                resolvedProvider: 'file',
+                fallbackReason: 'sqlite_runtime_unavailable',
+                supportsSqlite: false,
+            }));
+            expect(globalThis.fetch).toHaveBeenCalledWith('http://127.0.0.1:3000/api/knowledge/store-diagnostics', { cache: 'no-store' });
+        }
+        finally {
+            globalThis.window = previousWindow;
+            globalThis.fetch = previousFetch;
+        }
     });
     test('supports sidecar, tauri, and read-only capability branches', () => {
         const source = fs.readFileSync(storageProviderPath, 'utf8');
@@ -53,6 +188,14 @@ describe('storage provider abstraction contract', () => {
         expect(source).toContain('getCapacitorFilesystemPlugin()');
         expect(source).toContain('ensureCapacitorFilesystemPermission');
         expect(source).toContain('normalizeCapacitorPath');
+        expect(source).toContain('createMobileResourceIdentity');
+        expect(source).toContain('canonicalMobileNodeIdFromIdentity');
+        expect(source).toContain('NoteConnectionMobileIdentity');
+        expect(source).toContain('extractMarkdownLinks');
+        expect(source).toContain('sourceUri: file.sourceUri ||');
+        expect(source).toContain('canonicalId: file.canonicalId ||');
+        expect(source).toContain('identityAliases: Array.isArray(file.identityAliases)');
+        expect(source).toContain('Capacitor graph contains duplicate legacy node id');
         expect(source).toContain('extractRelativePathFromKbMarker');
         expect(source).toContain('resolveCapacitorContentCandidatePath');
         expect(source).toContain('async function capacitorReadText(pathValue, options)');
@@ -64,11 +207,19 @@ describe('storage provider abstraction contract', () => {
         expect(source).toContain('CAPACITOR_GRAPH_BUILD_WORKER_TIMEOUT_MS');
         expect(source).toContain("buildMode: 'single-thread-fallback'");
         expect(source).toContain("buildMode: 'worker'");
+        expect(source).toContain('var linkedFile = resolveReference(file, rawLink, referenceIndex);');
+        expect(source).toContain('addEdge(sourceId, linkedFile && linkedFile.id, "wiki-link")');
+        expect(source).toContain('function buildCapacitorReferenceIndex(files)');
+        expect(source).toContain('Capacitor graph contains an ambiguous legacy basename');
+        expect(source).toContain('sourceUri: sourceNode && sourceNode.sourceUri');
         expect(source).toContain("const result = await capacitorBuildGraph(requestPayload || {}, this.runtimeCaps || {});");
         expect(source).toContain('buildModeDetail: resolveCapacitorBuildModeDetail(buildResult.buildMode, runtimeCaps || {})');
         expect(source).toContain('supportsMobileWasmCompute');
         expect(source).toContain('mobileWasmReason');
         expect(source).toContain("unsupportedOperationError('buildGraph')");
+        expect(source).toContain('storage_requested_provider');
+        expect(source).toContain('storage_resolved_provider');
+        expect(source).toContain('storage_fallback_reason');
     });
     test('defines core storage operations used by source manager and reader', () => {
         const source = fs.readFileSync(storageProviderPath, 'utf8');
@@ -80,7 +231,7 @@ describe('storage provider abstraction contract', () => {
         expect(source).toContain('async buildGraph(requestPayload)');
         expect(source).toContain('async readContent(filePath)');
         expect(source).toContain('const capacitorPath = resolveCapacitorContentCandidatePath(filePath);');
-        expect(source).toContain('return await capacitorReadText(capacitorPath);');
+        expect(source).toContain('return await capacitorReadText(capacitorPath, {');
         expect(source).toContain('async setKbPath(kbPath)');
         expect(source).toContain('async readGeneratedAsset(filename)');
     });

package/dist/src/tauri.frontend.build.contract.test.js

@@ -0,0 +1,68 @@
+"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"));
+describe('tauri frontend build contracts', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const packageJsonPath = path.join(repoRoot, 'package.json');
+    const tauriConfigPath = path.join(repoRoot, 'src-tauri', 'tauri.conf.json');
+    const wrapperScriptPath = path.join(repoRoot, 'scripts', 'run-tauri-frontend-build.js');
+    const viteConfigPath = path.join(repoRoot, 'vite.config.ts');
+    function readJson(filePath) {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    test('tauri full build keeps explicit frontend full-mode through tauri beforeBuildCommand', () => {
+        const packageJson = readJson(packageJsonPath);
+        const tauriConfig = readJson(tauriConfigPath);
+        const scripts = packageJson.scripts || {};
+        expect(tauriConfig.build?.beforeBuildCommand).toBe('node scripts/run-tauri-frontend-build.js');
+        expect(scripts['tauri:build:full']).toContain('node scripts/run-tauri-build.js --frontend-build-mode full');
+    });
+    test('tauri frontend build wrapper defaults to runtime-first and supports explicit full mode', () => {
+        const wrapper = require(wrapperScriptPath);
+        expect(wrapper.resolveFrontendBuildCommand()).toBe('npm run build');
+        expect(wrapper.resolveFrontendBuildCommand({ frontendBuildMode: 'runtime-first' })).toBe('npm run build');
+        expect(wrapper.resolveFrontendBuildCommand({ frontendBuildMode: 'full' })).toBe('npm run build:full');
+        expect(() => wrapper.resolveFrontendBuildCommand({ frontendBuildMode: 'legacy-full' })).toThrow(/Unsupported tauri frontend build mode/i);
+    });
+    test('keeps Vite verification output separate from the Tauri runtime frontend directory', () => {
+        const viteConfig = fs.readFileSync(viteConfigPath, 'utf8');
+        expect(viteConfig).toContain("const viteVerificationDir = resolve(__dirname, 'dist', 'vite-verify')");
+        expect(viteConfig).toContain('outDir: viteVerificationDir');
+        expect(viteConfig).toContain('emptyOutDir: true');
+        expect(viteConfig).not.toContain('emptyOutDir: false');
+    });
+});

package/dist/src/tauri.sidecar.cleanup.contract.test.js

@@ -41,6 +41,7 @@ describe('tauri sidecar cleanup integration', () => {
     const cleanupScriptPath = path.join(repoRoot, 'scripts', 'cleanup-tauri-sidecars.js');
     const sidecarEnsureScriptPath = path.join(repoRoot, 'scripts', 'ensure-sidecar-ready.js');
     const tauriBuildRunnerPath = path.join(repoRoot, 'scripts', 'run-tauri-build.js');
+    const tauriDevRunnerPath = path.join(repoRoot, 'scripts', 'run-tauri-dev.js');
     const tauriRunnerPath = path.join(repoRoot, 'scripts', 'run-tauri-tests.js');
     test('desktop tauri scripts run stale sidecar cleanup before cargo build flow', () => {
         const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
@@ -51,6 +52,8 @@ describe('tauri sidecar cleanup integration', () => {
         expect(pkg.scripts['tauri:dev:mini']).toContain('npm run cleanup:tauri:sidecars');
         expect(pkg.scripts['tauri:dev']).toContain('npm run ensure:sidecar:dev');
         expect(pkg.scripts['tauri:dev:mini']).toContain('npm run ensure:sidecar:dev');
+        expect(pkg.scripts['tauri:dev']).toContain('node scripts/run-tauri-dev.js');
+        expect(pkg.scripts['tauri:dev:mini']).toContain('node scripts/run-tauri-dev.js');
         expect(pkg.scripts['tauri:build']).toContain('npm run cleanup:tauri:sidecars');
         expect(pkg.scripts['tauri:build:mini']).toContain('npm run cleanup:tauri:sidecars');
         expect(pkg.scripts['tauri:build']).toContain('node scripts/run-tauri-build.js');
@@ -64,6 +67,15 @@ describe('tauri sidecar cleanup integration', () => {
         expect(tauriBuildRunner).toContain('CARGO_PROFILE_RELEASE_OPT_LEVEL');
         expect(tauriBuildRunner).toContain('CARGO_PROFILE_RELEASE_CODEGEN_UNITS');
         expect(tauriBuildRunner).toContain("['tauri', 'build', '--ci'");
+        const tauriDevRunner = fs.readFileSync(tauriDevRunnerPath, 'utf8');
+        expect(tauriDevRunner).toContain('CARGO_TARGET_DIR');
+        expect(tauriDevRunner).toContain('target-dev-lowmem');
+        expect(tauriDevRunner).toContain('process.pid');
+        expect(tauriDevRunner).toContain('Date.now().toString(36)');
+        expect(tauriDevRunner).toContain('CARGO_BUILD_JOBS');
+        expect(tauriDevRunner).toContain('CARGO_PROFILE_DEV_DEBUG');
+        expect(tauriDevRunner).toContain('CARGO_INCREMENTAL');
+        expect(tauriDevRunner).toContain("['tauri', 'dev'");
         const sidecarEnsureScript = fs.readFileSync(sidecarEnsureScriptPath, 'utf8');
         expect(sidecarEnsureScript).toContain('Sidecar binaries are valid and up-to-date');
         expect(sidecarEnsureScript).toContain("runNodeScript('build-sidecar.js')");
@@ -71,9 +83,18 @@ describe('tauri sidecar cleanup integration', () => {
     });
     test('cleanup script targets copied tauri sidecars in debug and release outputs', () => {
         const script = fs.readFileSync(cleanupScriptPath, 'utf8');
+        expect(script).toContain("const defaultTargetRoots = [");
+        expect(script).toContain("path.join(repoRoot, 'src-tauri', 'target')");
+        expect(script).toContain("path.join(repoRoot, 'src-tauri', 'target-dev-lowmem')");
         expect(script).toContain("const targetModes = ['debug', 'release'];");
         expect(script).toContain("const sidecarNames = ['server', 'godot', 'markdown-worker'];");
+        expect(script).toContain('function resolveTargetRoots()');
+        expect(script).toContain('process.env.CARGO_TARGET_DIR');
         expect(script).toContain("targetRoot, mode, `${name}.exe`");
+        expect(script).toContain('function removeExistingArtifacts(targetPaths)');
+        expect(script).toContain('function runPowerShellNameFallbackCleanup(targetPath)');
+        expect(script).toContain('KILLED_BY_NAME|');
+        expect(script).toContain('[Tauri Sidecar Cleanup] REMOVED|');
         expect(script).toContain('Failed to terminate stale copied sidecars');
     });
 });

package/dist/src/tauri.window.evidence.execution.test.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+jest.mock('child_process', () => ({ ...jest.requireActual('child_process'), spawnSync: jest.fn() }));
+const { runRustWindowEvidenceTests } = require('../scripts/verify-agent-workspace-tauri-window-evidence');
+const { runRustContractTests } = require('../scripts/verify-agent-workspace-tauri-rust');
+const spawn = child_process_1.spawnSync;
+describe('native window test execution evidence', () => {
+    afterEach(() => jest.clearAllMocks());
+    test.each([
+        ['empty filter', 'running 0 tests\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 30 filtered out;\n'],
+        ['ignored test', 'test tests::{name} ... ignored\n\ntest result: ok. 0 passed; 0 failed; 1 ignored;\n'],
+        ['different test', 'test tests::some_other_test ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored;\n'],
+        ['failed test', 'test tests::{name} ... FAILED\n'],
+    ])('does not qualify a zero-exit Cargo run with %s', (_label, stdout) => {
+        spawn.mockImplementation((_command, args) => ({ status: 0, stdout: stdout.replace('{name}', args[3]), stderr: '' }));
+        const results = runRustWindowEvidenceTests();
+        expect(results).toHaveLength(2);
+        expect(results.every((result) => result.passed === false)).toBe(true);
+    });
+    test('requires the named test to pass even when other test executables run zero tests', () => {
+        spawn.mockImplementation((_command, args) => ({ status: 0, stderr: '', stdout: `running 0 tests\ntest result: ok. 0 passed; 0 failed;\n\ntest tests::${args[3]} ... ok\n\ntest result: ok. 1 passed; 0 failed;\n` }));
+        expect(runRustWindowEvidenceTests().every((result) => result.passed)).toBe(true);
+    });
+    test('rejects a passing named test when Cargo later fails', () => {
+        spawn.mockImplementation((_command, args) => ({ status: 101, stderr: 'later test executable failed', stdout: `test tests::${args[3]} ... ok\n` }));
+        expect(runRustWindowEvidenceTests().every((result) => result.passed === false)).toBe(true);
+    });
+    test('selects the native window feature and library target in separate Cargo processes', () => {
+        spawn.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+        runRustWindowEvidenceTests();
+        expect(spawn).toHaveBeenCalledTimes(2);
+        for (const [command, args] of spawn.mock.calls) {
+            expect(command).toBe('cargo');
+            expect(args).toEqual(expect.arrayContaining(['--lib', '--locked', '--features', 'native-window-tests', '--ignored', '--show-output']));
+        }
+    });
+});
+describe('ordinary Rust contract execution evidence', () => {
+    afterEach(() => jest.clearAllMocks());
+    const names = [
+        'pathmode_window_toggle_plan_decouples_godot_signal_from_tauri_hide_restore_flags',
+        'pathmode_window_toggle_plan_restores_tauri_focus_when_restore_policy_is_enabled',
+        'pathmode_window_toggled_event_payload_contains_config_and_execution_plan',
+    ];
+    test.each([
+        ['empty selection', 0, 'running 0 tests\ntest result: ok. 0 passed; 0 failed;', ''],
+        ['unrelated passing test', 0, 'test tests::unrelated ... ok', ''],
+        ['ignored tests', 0, names.map(name => `test tests::${name} ... ignored`).join('\n'), ''],
+        ['failed Cargo invocation mentioning zero tests', 101, '', '0 tests matched after failure'],
+    ])('does not qualify %s', (_label, status, stdout, stderr) => {
+        spawn.mockReturnValue({ status, stdout, stderr });
+        const results = runRustContractTests();
+        expect(results.every((result) => result.passed === false)).toBe(true);
+        expect(results.every((result) => result.exitCode === status)).toBe(true);
+    });
+    test('requires every named case, including both toggle policy tests', () => {
+        spawn.mockReturnValue({ status: 0, stdout: `test tests::${names[0]} ... ok\n`, stderr: '' });
+        expect(runRustContractTests().every((result) => result.passed === false)).toBe(true);
+    });
+    test('qualifies executed names and preserves a later Cargo failure', () => {
+        const stdout = names.map(name => `test tests::${name} ... ok`).join('\n');
+        spawn.mockReturnValue({ status: 0, stdout, stderr: '' });
+        expect(runRustContractTests().every((result) => result.passed)).toBe(true);
+        spawn.mockReturnValue({ status: 101, stdout, stderr: 'process failed' });
+        expect(runRustContractTests().every((result) => result.passed === false)).toBe(true);
+    });
+});

package/dist/src/utils/RuntimePaths.js

@@ -37,6 +37,7 @@ exports.resolveRuntimePaths = resolveRuntimePaths;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const platform_1 = require("./platform");
 function isDirectory(targetPath) {
     try {
         return fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory();
@@ -65,17 +66,6 @@ function pickExisting(candidates) {
     }
     return null;
 }
-function resolveAppDataRoot(cwd) {
-    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    if (localAppData) {
-        return path.join(localAppData, 'NoteConnection');
-    }
-    const home = process.env.HOME || process.env.USERPROFILE;
-    if (home) {
-        return path.join(home, '.noteconnection');
-    }
-    return path.join(cwd, '.noteconnection');
-}
 function ensureWritableDirectory(targetPath) {
     try {
         fs.mkdirSync(targetPath, { recursive: true });
@@ -138,19 +128,25 @@ function resolveRuntimePaths(moduleDir) {
         path.join(moduleDir, 'frontend')
     ].filter((v) => Boolean(v)));
     const frontendDir = pickExisting(frontendCandidates) || path.join(projectRoot, 'dist', 'src', 'frontend');
+    const appDataRoot = (0, platform_1.getAppDataDir)();
     const runtimeDataCandidates = uniqPaths([
         envRuntimeDataDir,
-        path.join(resolveAppDataRoot(cwd), 'runtime_data'),
+        path.join(appDataRoot, 'runtime_data'),
         path.join(projectRoot, 'runtime_data'),
         path.join(cwd, 'runtime_data'),
         path.join(os.tmpdir(), 'noteconnection', 'runtime_data')
     ].filter((v) => Boolean(v)));
     const runtimeDataDirCandidate = runtimeDataCandidates.find((candidate) => ensureWritableDirectory(candidate))
-        || path.join(resolveAppDataRoot(cwd), 'runtime_data');
+        || path.join(appDataRoot, 'runtime_data');
     if (!ensureWritableDirectory(runtimeDataDirCandidate)) {
         throw new Error(`Unable to provision writable runtime data directory: ${runtimeDataDirCandidate}`);
     }
     const runtimeDataDir = path.resolve(runtimeDataDirCandidate);
+    // pkg's projectRoot is a virtual, read-only asset tree. Mutable discovery
+    // credentials belong to the writable runtime directory in packaged builds.
+    const runtimeManifestPath = process.pkg
+        ? path.join(runtimeDataDir, 'active-sidecar-runtime.json')
+        : path.join(projectRoot, 'tmp', 'active-sidecar-runtime.json');
     const kbCandidates = uniqPaths([
         envKbRoot,
         path.join(projectRoot, 'Knowledge_Base'),
@@ -163,6 +159,7 @@ function resolveRuntimePaths(moduleDir) {
         projectRoot,
         frontendDir,
         runtimeDataDir,
+        runtimeManifestPath,
         kbRoot
     };
 }

package/dist/src/utils/RuntimePaths.test.js

@@ -97,6 +97,33 @@ describe('resolveRuntimePaths', () => {
         expect(resolved.runtimeDataDir).toBe(path.resolve(runtimeDataDir));
         expect(resolved.kbRoot).toBe(path.resolve(kbRoot));
     });
+    test('keeps packaged runtime manifests in the writable runtime directory', () => {
+        const previousPkg = Object.getOwnPropertyDescriptor(process, 'pkg');
+        Object.defineProperty(process, 'pkg', { configurable: true, value: { entrypoint: '/snapshot/app/server.js' } });
+        restoreEnv.push(() => {
+            if (previousPkg)
+                Object.defineProperty(process, 'pkg', previousPkg);
+            else
+                Reflect.deleteProperty(process, 'pkg');
+        });
+        const projectRoot = temp.mkdir('packaged_assets');
+        temp.mkdir(path.join('packaged_assets', 'dist', 'src', 'frontend'));
+        const runtimeDataDir = temp.mkdir('user_runtime');
+        restoreEnv.push(setEnv('NOTE_CONNECTION_PROJECT_ROOT', projectRoot));
+        restoreEnv.push(setEnv('NOTE_CONNECTION_RUNTIME_DATA_DIR', runtimeDataDir));
+        const resolved = (0, RuntimePaths_1.resolveRuntimePaths)(temp.child('module'));
+        expect('runtimeManifestPath' in resolved ? resolved.runtimeManifestPath : undefined)
+            .toBe(path.join(runtimeDataDir, 'active-sidecar-runtime.json'));
+    });
+    test('preserves the development manifest location used by diagnostic tools', () => {
+        const projectRoot = temp.mkdir('project');
+        temp.mkdir(path.join('project', 'Knowledge_Base'));
+        restoreEnv.push(setEnv('NOTE_CONNECTION_PROJECT_ROOT', projectRoot));
+        restoreEnv.push(setEnv('NOTE_CONNECTION_RUNTIME_DATA_DIR', temp.mkdir('runtime')));
+        const resolved = (0, RuntimePaths_1.resolveRuntimePaths)(temp.child('module'));
+        expect('runtimeManifestPath' in resolved ? resolved.runtimeManifestPath : undefined)
+            .toBe(path.join(projectRoot, 'tmp', 'active-sidecar-runtime.json'));
+    });
     test('normalizes env kb path that points to a folder inside Knowledge_Base', () => {
         const projectRoot = temp.mkdir('project');
         const kbRoot = temp.mkdir(path.join('project', 'Knowledge_Base'));