@sanqianx/project-knowledge 5.0.23 → 5.0.25

package/_site/_test/shared-scope-root-binding-test.js

@@ -1,67 +1,74 @@
-'use strict';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const { createEngineServer } = require('../../_modules/knowledge-engine/src/server');
-const { SettingsStore } = require('../lib/settings-store');
-const { ModuleBridge } = require('../lib/module-bridge');
-
-(async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-shared-bindings-'));
-  const oldRoot = path.join(root, '原知识根目录'), newRoot = path.join(root, '新知识根目录');
-  const settings = new SettingsStore({ dataDir: path.join(root, 'shell') });
-  await settings.initialize({ knowledge: { rootPath: oldRoot } });
-  await settings.addDomain({ id: 'domain-tools', name: '开发工具' });
-  let engine;
-  async function start() {
-    engine = createEngineServer({ dataDir: path.join(root, 'engine'), consume: false, runtimeToken: 'scope-binding-test' });
-    await engine.ready;
-    await new Promise(resolve => engine.server.listen(0, '127.0.0.1', resolve));
-    return `http://127.0.0.1:${engine.server.address().port}`;
-  }
-  const logs = [];
-  const bridge = new ModuleBridge({ settingsStore: settings, runtimeToken: 'scope-binding-test', logger: { warn: (...args) => logs.push(args) } });
-  const upstream = bridge._fetch.bind(bridge);
-  bridge._fetch = (url, init) => url.startsWith(bridge.engineUrl) ? upstream(url, init) : Promise.resolve({ ok: false });
-  try {
-    bridge.engineUrl = await start();
-    assert.equal((await bridge.syncEngineConfiguration()).scopes, true);
-    const scopes = structuredClone(engine.store.state.sharedScopes);
-    const brain = scopes.find(scope => scope.kind === 'brain');
-    const domain = scopes.find(scope => scope.kind === 'domain');
-    engine.store.addProject({ projectId: 'project-test', repoPath: path.join(root, 'code'), knowledgePath: path.join(root, 'project-knowledge'), domainId: domain.id });
-    engine.store.state.memories.push({ id: 'memory-test', brainId: brain.id, status: 'candidate', text: '保持目录绑定稳定', evidence: { projectId: 'project-test', commitSha: 'a'.repeat(40), entryId: 'README.md' } });
-    engine.store.save();
-    await engine.coordinator.memories.update('memory-test', { status: 'confirmed' });
-    fs.writeFileSync(path.join(domain.knowledgePath, 'README.md'), '# 领域经验\n\n领域知识不能随根目录设置隐式移动。\n');
-    const memoryFile = engine.coordinator.memories.file(brain);
-    const before = fs.readFileSync(memoryFile);
-    await settings.updatePatch({ knowledge: { rootPath: newRoot } });
-    assert.equal((await bridge.syncEngineConfiguration()).scopes, true, 'changing index root must not invalidate shared memory wiring');
-    assert.deepEqual(engine.store.state.sharedScopes.map(scope => scope.knowledgePath), scopes.map(scope => scope.knowledgePath));
-    assert.deepEqual(fs.readFileSync(memoryFile), before);
-    assert.equal(settings.read().brain.knowledgePath, brain.knowledgePath);
-    assert.equal(settings.read().brain.domains[0].knowledgePath, domain.knowledgePath);
-    await assert.rejects(settings.updatePatch({ brain: { knowledgePath: newRoot } }), { code: 'INVALID_ARGUMENT' });
-    await assert.rejects(settings.bindSharedKnowledgePaths([{ ...brain, knowledgePath: newRoot }]), { code: 'IMMUTABLE_FIELD' });
-    await settings.addDomain({ id: 'domain-new', name: '新领域' });
-    assert.equal((await bridge.syncEngineConfiguration()).scopes, true);
-    assert.equal(engine.store.state.sharedScopes.find(scope => scope.id === 'domain-new').knowledgePath, path.join(newRoot, '_shared', 'domain-new'));
-    await engine.close();
-    bridge.engineUrl = await start();
-    assert.equal((await bridge.syncEngineConfiguration()).scopes, true);
-    assert.deepEqual(fs.readFileSync(memoryFile), before);
-    const memory = await engine.coordinator.retrieval.get({ projectId: 'project-test', spaceId: 'brain:brain-default', entryId: 'memories/confirmed.md' });
-    assert.ok(memory.chunks.some(chunk => chunk.chunk_text.includes('保持目录绑定稳定')));
-    const shared = await engine.coordinator.retrieval.get({ projectId: 'project-test', spaceId: 'domain:domain-tools', entryId: 'README.md' });
-    assert.ok(shared.chunks.some(chunk => chunk.chunk_text.includes('不能随根目录设置隐式移动')));
-    await engine.close(); engine = null;
-    const pending = await bridge.syncEngineConfiguration();
-    assert.equal(pending.scopes, false);
-    assert.equal(pending.scopeStatus.status, 'pending');
-    assert.ok(logs.some(entry => entry[0] === 'modules.scopes.pending'));
-    assert.equal(settings.read().brain.knowledgePath, brain.knowledgePath);
-    console.log('shared-scope-root-binding-test PASS');
-  } finally { if (engine) await engine.close(); }
-})().catch(error => { console.error(error); process.exitCode = 1; });
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { applyDriverIsolation } = require('./helpers/parallel-qa-engine-endpoint-isolate');
+const { guardedCreateEngineServer, createEngineVectorStandin, createEngineBridgeDouble } = require('./helpers/parallel-qa-engine-endpoint-guard');
+
+(async () => {
+  const applied = applyDriverIsolation({ prefix: 'pk-qa-shared-scope' });
+  // Product modules load only after the driver environment is isolated.
+  const { SettingsStore } = require('../lib/settings-store');
+  const { ModuleBridge } = require('../lib/module-bridge');
+  const root = fs.mkdtempSync(path.join(applied.layout.temp, 'kb-shared-bindings-'));
+  const oldRoot = path.join(root, '原知识根目录'), newRoot = path.join(root, '新知识根目录');
+  const settings = new SettingsStore({ dataDir: path.join(root, 'shell') });
+  await settings.initialize({ knowledge: { rootPath: oldRoot } });
+  await settings.addDomain({ id: 'domain-tools', name: '开发工具' });
+  // OWN vector stand-in and bridge double exist BEFORE any engine construction:
+  // the coordinator ignores env and falls back to LIVE 8787/8790 otherwise.
+  const vectorStandin = createEngineVectorStandin();
+  await vectorStandin.ready;
+  const bridgeDouble = createEngineBridgeDouble();
+  let engine;
+  async function start() {
+    engine = guardedCreateEngineServer({ dataDir: path.join(root, 'engine'), consume: false, runtimeToken: 'scope-binding-test', vectorUrl: vectorStandin.url, bridge: bridgeDouble });
+    await engine.ready;
+    await new Promise(resolve => engine.server.listen(0, '127.0.0.1', resolve));
+    return `http://127.0.0.1:${engine.server.address().port}`;
+  }
+  const logs = [];
+  const bridge = new ModuleBridge({ settingsStore: settings, runtimeToken: 'scope-binding-test', logger: { warn: (...args) => logs.push(args) } });
+  const upstream = bridge._fetch.bind(bridge);
+  bridge._fetch = (url, init) => url.startsWith(bridge.engineUrl) ? upstream(url, init) : Promise.resolve({ ok: false });
+  try {
+    bridge.engineUrl = await start();
+    assert.equal((await bridge.syncEngineConfiguration()).scopes, true);
+    const scopes = structuredClone(engine.store.state.sharedScopes);
+    const brain = scopes.find(scope => scope.kind === 'brain');
+    const domain = scopes.find(scope => scope.kind === 'domain');
+    engine.store.addProject({ projectId: 'project-test', repoPath: path.join(root, 'code'), knowledgePath: path.join(root, 'project-knowledge'), domainId: domain.id });
+    engine.store.state.memories.push({ id: 'memory-test', brainId: brain.id, status: 'candidate', text: '保持目录绑定稳定', evidence: { projectId: 'project-test', commitSha: 'a'.repeat(40), entryId: 'README.md' } });
+    engine.store.save();
+    await engine.coordinator.memories.update('memory-test', { status: 'confirmed' });
+    fs.writeFileSync(path.join(domain.knowledgePath, 'README.md'), '# 领域经验\n\n领域知识不能随根目录设置隐式移动。\n');
+    const memoryFile = engine.coordinator.memories.file(brain);
+    const before = fs.readFileSync(memoryFile);
+    await settings.updatePatch({ knowledge: { rootPath: newRoot } });
+    assert.equal((await bridge.syncEngineConfiguration()).scopes, true, 'changing index root must not invalidate shared memory wiring');
+    assert.deepEqual(engine.store.state.sharedScopes.map(scope => scope.knowledgePath), scopes.map(scope => scope.knowledgePath));
+    assert.deepEqual(fs.readFileSync(memoryFile), before);
+    assert.equal(settings.read().brain.knowledgePath, brain.knowledgePath);
+    assert.equal(settings.read().brain.domains[0].knowledgePath, domain.knowledgePath);
+    await assert.rejects(settings.updatePatch({ brain: { knowledgePath: newRoot } }), { code: 'INVALID_ARGUMENT' });
+    await assert.rejects(settings.bindSharedKnowledgePaths([{ ...brain, knowledgePath: newRoot }]), { code: 'IMMUTABLE_FIELD' });
+    await settings.addDomain({ id: 'domain-new', name: '新领域' });
+    assert.equal((await bridge.syncEngineConfiguration()).scopes, true);
+    assert.equal(engine.store.state.sharedScopes.find(scope => scope.id === 'domain-new').knowledgePath, path.join(newRoot, '_shared', 'domain-new'));
+    await engine.close();
+    bridge.engineUrl = await start();
+    assert.equal((await bridge.syncEngineConfiguration()).scopes, true);
+    assert.deepEqual(fs.readFileSync(memoryFile), before);
+    const memory = await engine.coordinator.retrieval.get({ projectId: 'project-test', spaceId: 'brain:brain-default', entryId: 'memories/confirmed.md' });
+    assert.ok(memory.chunks.some(chunk => chunk.chunk_text.includes('保持目录绑定稳定')));
+    const shared = await engine.coordinator.retrieval.get({ projectId: 'project-test', spaceId: 'domain:domain-tools', entryId: 'README.md' });
+    assert.ok(shared.chunks.some(chunk => chunk.chunk_text.includes('不能随根目录设置隐式移动')));
+    await engine.close(); engine = null;
+    const pending = await bridge.syncEngineConfiguration();
+    assert.equal(pending.scopes, false);
+    assert.equal(pending.scopeStatus.status, 'pending');
+    assert.ok(logs.some(entry => entry[0] === 'modules.scopes.pending'));
+    assert.equal(settings.read().brain.knowledgePath, brain.knowledgePath);
+    console.log('shared-scope-root-binding-test PASS');
+  } finally { if (engine) await engine.close(); await vectorStandin.close().catch(() => {}); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/simple-import-test.js

@@ -1,98 +1,98 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const { spawnServer } = require('./helpers/spawn-server');
-const freePort = require('./helpers/free-port');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-let PORT, BASE;
-const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-import-v2-'));
-const repoPath = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-import-repo-'));
-const knowledgeRoot = path.join(dataDir, 'knowledge');
-
-function git(args) {
-  const result = spawnSync('git', args, { cwd: repoPath, encoding: 'utf8' });
-  assert.strictEqual(result.status, 0, result.stderr);
-  return String(result.stdout || '').trim();
-}
-
-async function request(method, pathname, body) {
-  const response = await fetch(`${BASE}${pathname}`, {
-    method,
-    headers: body === undefined ? undefined : { 'content-type': 'application/json' },
-    body: body === undefined ? undefined : JSON.stringify(body),
-  });
-  return { status: response.status, data: await response.json() };
-}
-
-async function waitForServer() {
-  for (let attempt = 0; attempt < 100; attempt += 1) {
-    try { if ((await fetch(`${BASE}/api/health`)).ok) return; } catch {}
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-  throw new Error('server did not start');
-}
-
-(async () => {
-  PORT = await freePort(); BASE = `http://127.0.0.1:${PORT}`;
-  git(['init', '--initial-branch=main']);
-  git(['config', 'user.email', 'import@example.test']);
-  git(['config', 'user.name', 'Import Test']);
-  fs.writeFileSync(path.join(repoPath, 'README.md'), '# source\n', 'utf8');
-  git(['add', 'README.md']);
-  git(['commit', '-m', 'baseline']);
-  const baseline = git(['rev-parse', 'HEAD']);
-
-  const spawned = spawnServer({ root: ROOT, port: PORT, dataDir, tag: 'simple-import-v2', extraEnv: { KB_SKIP_MIGRATION: '1' } });
-  let output = '';
-  spawned.child.stdout.on('data', chunk => { output += chunk; });
-  spawned.child.stderr.on('data', chunk => { output += chunk; });
-  try {
-    await waitForServer();
-    let result = await request('PATCH', '/api/settings', { knowledge: { rootPath: knowledgeRoot } });
-    assert.strictEqual(result.status, 200, JSON.stringify(result.data));
-
-    result = await request('POST', '/api/projects/import', { localPath: repoPath, displayName: 'Imported v2' });
-    assert.strictEqual(result.status, 201, JSON.stringify(result.data));
-    assert.match(result.data.projectId, /^project-/);
-    assert.strictEqual(result.data.project.config.projectId, result.data.projectId);
-    assert.strictEqual(result.data.project.state.trackingStartCommit, baseline);
-    assert.strictEqual(result.data.project.state.lastAnalyzedCommit, null);
-    assert.strictEqual(result.data.project.state.analysis.status, 'idle');
-    assert.strictEqual(result.data.hook.ok, true);
-    assert.strictEqual(result.data.project.state.hook.managedVersion, 2);
-    assert.deepStrictEqual(fs.readdirSync(result.data.project.config.knowledgePath), [], 'import must not create speculative knowledge');
-    assert(!fs.existsSync(path.join(dataDir, 'projects', result.data.projectId, 'requirements.jsonl')));
-
-    const projectId = result.data.projectId;
-    result = await request('PATCH', `/api/projects/${projectId}`, { displayName: 'Renamed safely', knowledgeLanguage: 'en-US' });
-    assert.strictEqual(result.status, 200, JSON.stringify(result.data));
-    assert.strictEqual(result.data.config.displayName, 'Renamed safely');
-    result = await request('PATCH', `/api/projects/${projectId}`, { repoPath: path.join(repoPath, 'unverified') });
-    assert.strictEqual(result.status, 400, 'generic PATCH must not bypass Hook-verified repo relocation');
-    assert.strictEqual(result.data.error.code, 'INVALID_ARGUMENT');
-    result = await request('PATCH', `/api/projects/${projectId}`, { teamBinding: { provider: 'github' } });
-    assert.strictEqual(result.status, 400, 'generic PATCH must not change a fixed team binding');
-
-    const hookPath = path.join(repoPath, '.git', 'hooks', 'post-commit');
-    assert(fs.existsSync(hookPath), 'managed Hook was not installed');
-    const hook = fs.readFileSync(hookPath, 'utf8');
-    assert(hook.includes('PROJECT-KNOWLEDGE-HOOK'));
-    assert(hook.includes(projectId));
-
-    result = await request('GET', '/api/projects');
-    assert.strictEqual(result.status, 200);
-    assert.strictEqual(result.data.projects.length, 1);
-    assert.strictEqual(result.data.projects[0].projectId, result.data.projects[0].config.projectId);
-    assert(!fs.existsSync(path.join(dataDir, 'runtime', 'staging')), 'import must not dispatch analysis');
-    console.log('simple-import-test PASS');
-  } catch (error) {
-    console.error(output);
-    throw error;
-  } finally {
-    await spawned.cleanup();
-    fs.rmSync(repoPath, { recursive: true, force: true });
-  }
-})().catch(error => { console.error(error); process.exitCode = 1; });
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { spawnServer } = require('./helpers/spawn-server');
+const freePort = require('./helpers/free-port');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+let PORT, BASE;
+const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-import-v2-'));
+const repoPath = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-import-repo-'));
+const knowledgeRoot = path.join(dataDir, 'knowledge');
+
+function git(args) {
+  const result = spawnSync('git', args, { cwd: repoPath, encoding: 'utf8' });
+  assert.strictEqual(result.status, 0, result.stderr);
+  return String(result.stdout || '').trim();
+}
+
+async function request(method, pathname, body) {
+  const response = await fetch(`${BASE}${pathname}`, {
+    method,
+    headers: body === undefined ? undefined : { 'content-type': 'application/json' },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  return { status: response.status, data: await response.json() };
+}
+
+async function waitForServer() {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    try { if ((await fetch(`${BASE}/api/health`)).ok) return; } catch {}
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error('server did not start');
+}
+
+(async () => {
+  PORT = await freePort(); BASE = `http://127.0.0.1:${PORT}`;
+  git(['init', '--initial-branch=main']);
+  git(['config', 'user.email', 'import@example.test']);
+  git(['config', 'user.name', 'Import Test']);
+  fs.writeFileSync(path.join(repoPath, 'README.md'), '# source\n', 'utf8');
+  git(['add', 'README.md']);
+  git(['commit', '-m', 'baseline']);
+  const baseline = git(['rev-parse', 'HEAD']);
+
+  const spawned = spawnServer({ root: ROOT, port: PORT, dataDir, tag: 'simple-import-v2', extraEnv: { KB_SKIP_MIGRATION: '1' } });
+  let output = '';
+  spawned.child.stdout.on('data', chunk => { output += chunk; });
+  spawned.child.stderr.on('data', chunk => { output += chunk; });
+  try {
+    await waitForServer();
+    let result = await request('PATCH', '/api/settings', { knowledge: { rootPath: knowledgeRoot } });
+    assert.strictEqual(result.status, 200, JSON.stringify(result.data));
+
+    result = await request('POST', '/api/projects/import', { localPath: repoPath, displayName: 'Imported v2' });
+    assert.strictEqual(result.status, 201, JSON.stringify(result.data));
+    assert.match(result.data.projectId, /^project-/);
+    assert.strictEqual(result.data.project.config.projectId, result.data.projectId);
+    assert.strictEqual(result.data.project.state.trackingStartCommit, baseline);
+    assert.strictEqual(result.data.project.state.lastAnalyzedCommit, null);
+    assert.strictEqual(result.data.project.state.analysis.status, 'idle');
+    assert.strictEqual(result.data.hook.ok, true);
+    assert.strictEqual(result.data.project.state.hook.managedVersion, 2);
+    assert.deepStrictEqual(fs.readdirSync(result.data.project.config.knowledgePath), [], 'import must not create speculative knowledge');
+    assert(!fs.existsSync(path.join(dataDir, 'projects', result.data.projectId, 'requirements.jsonl')));
+
+    const projectId = result.data.projectId;
+    result = await request('PATCH', `/api/projects/${projectId}`, { displayName: 'Renamed safely', knowledgeLanguage: 'en-US' });
+    assert.strictEqual(result.status, 200, JSON.stringify(result.data));
+    assert.strictEqual(result.data.config.displayName, 'Renamed safely');
+    result = await request('PATCH', `/api/projects/${projectId}`, { repoPath: path.join(repoPath, 'unverified') });
+    assert.strictEqual(result.status, 400, 'generic PATCH must not bypass Hook-verified repo relocation');
+    assert.strictEqual(result.data.error.code, 'INVALID_ARGUMENT');
+    result = await request('PATCH', `/api/projects/${projectId}`, { teamBinding: { provider: 'github' } });
+    assert.strictEqual(result.status, 400, 'generic PATCH must not change a fixed team binding');
+
+    const hookPath = path.join(repoPath, '.git', 'hooks', 'post-commit');
+    assert(fs.existsSync(hookPath), 'managed Hook was not installed');
+    const hook = fs.readFileSync(hookPath, 'utf8');
+    assert(hook.includes('PROJECT-KNOWLEDGE-HOOK'));
+    assert(hook.includes(projectId));
+
+    result = await request('GET', '/api/projects');
+    assert.strictEqual(result.status, 200);
+    assert.strictEqual(result.data.projects.length, 1);
+    assert.strictEqual(result.data.projects[0].projectId, result.data.projects[0].config.projectId);
+    assert(!fs.existsSync(path.join(dataDir, 'runtime', 'staging')), 'import must not dispatch analysis');
+    console.log('simple-import-test PASS');
+  } catch (error) {
+    console.error(output);
+    throw error;
+  } finally {
+    await spawned.cleanup();
+    fs.rmSync(repoPath, { recursive: true, force: true });
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/startup-analysis-disabled-test.js

@@ -1,16 +1,16 @@
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-
-const root = path.resolve(__dirname, '..', '..');
-const server = fs.readFileSync(path.join(root, '_site', 'lib', 'server-app.js'), 'utf8');
-const contracts = require('../lib/contracts');
-const automation = require('../lib/post-commit-automation');
-
-assert.deepEqual(contracts.TRIGGERS, ['git-hook']);
-assert.equal(/reconcileProjectCommits\(projectId, 'startup'/.test(server), false);
-assert.equal(server.includes('reconcile.startup_failed'), false);
-assert.equal(Object.hasOwn(automation, 'dispatchPendingAutomations'), false);
-assert.equal(typeof automation.recoverOrphanedClaims, 'function');
-assert.equal(/recoverOrphanedClaims\(runtime\)/.test(server), true);
-console.log('startup-analysis-disabled-test PASS');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+const root = path.resolve(__dirname, '..', '..');
+const server = fs.readFileSync(path.join(root, '_site', 'lib', 'server-app.js'), 'utf8');
+const contracts = require('../lib/contracts');
+const automation = require('../lib/post-commit-automation');
+
+assert.deepEqual(contracts.TRIGGERS, ['git-hook']);
+assert.equal(/reconcileProjectCommits\(projectId, 'startup'/.test(server), false);
+assert.equal(server.includes('reconcile.startup_failed'), false);
+assert.equal(Object.hasOwn(automation, 'dispatchPendingAutomations'), false);
+assert.equal(typeof automation.recoverOrphanedClaims, 'function');
+assert.equal(/recoverOrphanedClaims\(runtime\)/.test(server), true);
+console.log('startup-analysis-disabled-test PASS');

package/_site/_test/storage-foundation-test.js

@@ -1,78 +1,78 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { StorageLayout } = require('../lib/storage-layout');
-const AtomicFile = require('../lib/atomic-file');
-const { SettingsStore } = require('../lib/settings-store');
-
-(async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-storage-foundation-'));
-  const dataDir = path.join(root, 'data');
-  const knowledgeRoot = path.join(root, 'knowledge');
-  const layout = new StorageLayout({ dataDir, platform: 'win32' });
-
-  assert.strictEqual(layout.pathsEqual('C:\\Work\\Repo', 'c:\\work\\repo\\'), true);
-  const posixLayout = new StorageLayout({ dataDir, platform: 'linux' });
-  assert.strictEqual(posixLayout.pathsEqual('/tmp/Repo', '/tmp/repo'), false);
-  assert.strictEqual(layout.getIndexPath(), path.join(dataDir, 'index', 'knowledge.lancedb'));
-  assert(!layout.getIndexPath().startsWith(knowledgeRoot));
-
-  const rootResult = layout.validateKnowledgeRoot(knowledgeRoot);
-  assert.strictEqual(rootResult.ok, true);
-  assert.strictEqual(fs.readdirSync(knowledgeRoot).length, 0, 'write probe must not leave files');
-  const projectKnowledge = layout.resolveNewProjectKnowledgePath('repo-a1b2c3', { knowledge: { rootPath: knowledgeRoot } });
-  assert.strictEqual(projectKnowledge, path.join(knowledgeRoot, 'repo-a1b2c3'));
-  assert.strictEqual(layout.getProjectKnowledgePath({ knowledgePath: projectKnowledge }), projectKnowledge);
-
-  const atomicPath = path.join(dataDir, 'atomic.json');
-  AtomicFile.writeJsonAtomic(atomicPath, { revision: 1 });
-  assert.throws(() => AtomicFile.writeJsonAtomic(atomicPath, { revision: 2 }, {
-    beforeRename() { throw new Error('injected-before-rename'); },
-  }), /injected-before-rename/);
-  assert.deepStrictEqual(JSON.parse(fs.readFileSync(atomicPath, 'utf8')), { revision: 1 });
-
-  const jsonlPath = path.join(dataDir, 'append', 'requirements.jsonl');
-  await Promise.all(Array.from({ length: 20 }, (_, index) => AtomicFile.appendJsonlLocked(jsonlPath, { index })));
-  const lines = fs.readFileSync(jsonlPath, 'utf8').trim().split(/\r?\n/).map(JSON.parse);
-  assert.strictEqual(lines.length, 20);
-  assert.deepStrictEqual(lines.map(line => line.index).sort((a, b) => a - b), Array.from({ length: 20 }, (_, index) => index));
-
-  fs.mkdirSync(dataDir, { recursive: true });
-  const staleTemp = path.join(dataDir, '.atomic.json.1.1.abcdef.tmp');
-  const unrelated = path.join(dataDir, 'user.tmp');
-  fs.writeFileSync(staleTemp, 'stale');
-  fs.writeFileSync(unrelated, 'keep');
-  const old = new Date(Date.now() - 48 * 60 * 60 * 1000);
-  fs.utimesSync(staleTemp, old, old);
-  const removed = AtomicFile.cleanupStaleTemps(dataDir);
-  assert.deepStrictEqual(removed, [staleTemp]);
-  assert(fs.existsSync(unrelated));
-
-  const store = new SettingsStore({ layout });
-  await store.initialize({
-    knowledge: { rootPath: knowledgeRoot },
-    ai: { schema: 'ai-profiles/v1', profiles: [{ id: 'primary', apiKey: 'secret-key-7890' }] },
-  });
-  const privateSettings = store.read();
-  assert.strictEqual(privateSettings.ai.profiles[0].apiKey, 'secret-key-7890');
-  const publicSettings = store.readPublicView();
-  assert.strictEqual(publicSettings.ai.profiles[0].hasApiKey, true);
-  assert.strictEqual(publicSettings.ai.profiles[0].apiKeyMasked, '****7890');
-  assert.strictEqual(Object.prototype.hasOwnProperty.call(publicSettings.ai.profiles[0], 'apiKey'), false);
-
-  await assert.rejects(
-    () => store.updatePatch({ logging: { retentionDays: 0, maxTotalSizeMB: 512 } }),
-    error => error.code === 'INVALID_ARGUMENT',
-    'runtime retention/capacity settings must not be writable',
-  );
-  const updated = store.readPublicView();
-  assert.deepStrictEqual(updated.logging.levels, ['trace', 'debug', 'info', 'warn', 'error', 'fatal']);
-  assert.strictEqual(fs.existsSync(layout.getRecoveryPath()), false, 'optional recovery directory must stay lazy');
-  assert.strictEqual(fs.existsSync(layout.getCachePath()), false, 'optional cache directory must stay lazy');
-
-  console.log('storage-foundation-test PASS');
-})().catch(error => {
-  console.error(error.stack || error.message);
-  process.exitCode = 1;
-});
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { StorageLayout } = require('../lib/storage-layout');
+const AtomicFile = require('../lib/atomic-file');
+const { SettingsStore } = require('../lib/settings-store');
+
+(async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-storage-foundation-'));
+  const dataDir = path.join(root, 'data');
+  const knowledgeRoot = path.join(root, 'knowledge');
+  const layout = new StorageLayout({ dataDir, platform: 'win32' });
+
+  assert.strictEqual(layout.pathsEqual('C:\\Work\\Repo', 'c:\\work\\repo\\'), true);
+  const posixLayout = new StorageLayout({ dataDir, platform: 'linux' });
+  assert.strictEqual(posixLayout.pathsEqual('/tmp/Repo', '/tmp/repo'), false);
+  assert.strictEqual(layout.getIndexPath(), path.join(dataDir, 'index', 'knowledge.lancedb'));
+  assert(!layout.getIndexPath().startsWith(knowledgeRoot));
+
+  const rootResult = layout.validateKnowledgeRoot(knowledgeRoot);
+  assert.strictEqual(rootResult.ok, true);
+  assert.strictEqual(fs.readdirSync(knowledgeRoot).length, 0, 'write probe must not leave files');
+  const projectKnowledge = layout.resolveNewProjectKnowledgePath('repo-a1b2c3', { knowledge: { rootPath: knowledgeRoot } });
+  assert.strictEqual(projectKnowledge, path.join(knowledgeRoot, 'repo-a1b2c3'));
+  assert.strictEqual(layout.getProjectKnowledgePath({ knowledgePath: projectKnowledge }), projectKnowledge);
+
+  const atomicPath = path.join(dataDir, 'atomic.json');
+  AtomicFile.writeJsonAtomic(atomicPath, { revision: 1 });
+  assert.throws(() => AtomicFile.writeJsonAtomic(atomicPath, { revision: 2 }, {
+    beforeRename() { throw new Error('injected-before-rename'); },
+  }), /injected-before-rename/);
+  assert.deepStrictEqual(JSON.parse(fs.readFileSync(atomicPath, 'utf8')), { revision: 1 });
+
+  const jsonlPath = path.join(dataDir, 'append', 'requirements.jsonl');
+  await Promise.all(Array.from({ length: 20 }, (_, index) => AtomicFile.appendJsonlLocked(jsonlPath, { index })));
+  const lines = fs.readFileSync(jsonlPath, 'utf8').trim().split(/\r?\n/).map(JSON.parse);
+  assert.strictEqual(lines.length, 20);
+  assert.deepStrictEqual(lines.map(line => line.index).sort((a, b) => a - b), Array.from({ length: 20 }, (_, index) => index));
+
+  fs.mkdirSync(dataDir, { recursive: true });
+  const staleTemp = path.join(dataDir, '.atomic.json.1.1.abcdef.tmp');
+  const unrelated = path.join(dataDir, 'user.tmp');
+  fs.writeFileSync(staleTemp, 'stale');
+  fs.writeFileSync(unrelated, 'keep');
+  const old = new Date(Date.now() - 48 * 60 * 60 * 1000);
+  fs.utimesSync(staleTemp, old, old);
+  const removed = AtomicFile.cleanupStaleTemps(dataDir);
+  assert.deepStrictEqual(removed, [staleTemp]);
+  assert(fs.existsSync(unrelated));
+
+  const store = new SettingsStore({ layout });
+  await store.initialize({
+    knowledge: { rootPath: knowledgeRoot },
+    ai: { schema: 'ai-profiles/v1', profiles: [{ id: 'primary', apiKey: 'secret-key-7890' }] },
+  });
+  const privateSettings = store.read();
+  assert.strictEqual(privateSettings.ai.profiles[0].apiKey, 'secret-key-7890');
+  const publicSettings = store.readPublicView();
+  assert.strictEqual(publicSettings.ai.profiles[0].hasApiKey, true);
+  assert.strictEqual(publicSettings.ai.profiles[0].apiKeyMasked, '****7890');
+  assert.strictEqual(Object.prototype.hasOwnProperty.call(publicSettings.ai.profiles[0], 'apiKey'), false);
+
+  await assert.rejects(
+    () => store.updatePatch({ logging: { retentionDays: 0, maxTotalSizeMB: 512 } }),
+    error => error.code === 'INVALID_ARGUMENT',
+    'runtime retention/capacity settings must not be writable',
+  );
+  const updated = store.readPublicView();
+  assert.deepStrictEqual(updated.logging.levels, ['trace', 'debug', 'info', 'warn', 'error', 'fatal']);
+  assert.strictEqual(fs.existsSync(layout.getRecoveryPath()), false, 'optional recovery directory must stay lazy');
+  assert.strictEqual(fs.existsSync(layout.getCachePath()), false, 'optional cache directory must stay lazy');
+
+  console.log('storage-foundation-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});