@sanqianx/project-knowledge 4.7.0 → 5.0.0

package/_site/_test/offline-boundary-isolation-test.js

@@ -1,32 +1,32 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { StorageLayout } = require('../lib/storage-layout');
-const { ProjectStore } = require('../lib/project-store');
-const { ConversationStore } = require('../lib/conversation-store');
-const { CommitConversationBinder } = require('../lib/commit-conversation-binder');
-
-(async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-offline-boundaries-'));
-  try {
-    const layout = new StorageLayout({ dataDir: path.join(root, 'data') });
-    const projects = new ProjectStore({ layout });
-    const projectId = 'project-offline-boundary';
-    const identity = { commonDir: path.join(root, 'repo', '.git') };
-    await projects.create(projectId, { storageName: 'offline-boundary', displayName: 'Offline Boundary', repoPath: path.join(root, 'repo'), knowledgePath: path.join(root, 'knowledge'), repoIdentity: identity }, { conversationBaselineCursor: 0 });
-    const store = new ConversationStore({ layout, projectStore: projects });
-    const binder = new CommitConversationBinder({ layout, projectStore: projects, conversationStore: store });
-    const add = (sequence, eventId, content) => store.appendEvent(projectId, { eventId, sequence, source: 'codex', eventType: 'user_prompt', role: 'user', content, turnId: eventId, repoIdentity: identity, capturedAt: '2026-08-24T00:00:00.000Z', identityConfidence: 'exact', captureStatus: 'captured' });
-    const boundary = (sha, cursor) => store.writeBoundary(projectId, { commitSha: sha, repoIdentity: identity, parentShas: [], branch: 'main', committedAt: '2026-08-24T00:00:00.000Z', bridgeCursorAtCommit: cursor, journalSequence: cursor, openTurnIdsAtCommit: [], operationId: `op-${cursor}` });
-    const b = 'b'.repeat(40); const c = 'c'.repeat(40); const d = 'd'.repeat(40);
-    await add(1, 'prompt-b', 'offline B'); boundary(b, 2);
-    await add(3, 'prompt-c', 'offline C'); boundary(c, 4);
-    await add(5, 'prompt-d', 'online D'); boundary(d, 6);
-    const snapshot = await binder.bind({ projectId, commitSha: d });
-    assert.deepEqual(snapshot.turns.map(turn => turn.turnId), ['prompt-d']);
-    assert.equal(JSON.stringify(snapshot).includes('offline B'), false);
-    assert.equal(JSON.stringify(snapshot).includes('offline C'), false);
-  } finally { fs.rmSync(root, { recursive: true, force: true }); }
-  console.log('offline-boundary-isolation-test PASS');
-})().catch(error => { console.error(error.stack || error.message); process.exit(1); });
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { StorageLayout } = require('../lib/storage-layout');
+const { ProjectStore } = require('../lib/project-store');
+const { ConversationStore } = require('../lib/conversation-store');
+const { CommitConversationBinder } = require('../lib/commit-conversation-binder');
+
+(async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-offline-boundaries-'));
+  try {
+    const layout = new StorageLayout({ dataDir: path.join(root, 'data') });
+    const projects = new ProjectStore({ layout });
+    const projectId = 'project-offline-boundary';
+    const identity = { commonDir: path.join(root, 'repo', '.git') };
+    await projects.create(projectId, { storageName: 'offline-boundary', displayName: 'Offline Boundary', repoPath: path.join(root, 'repo'), knowledgePath: path.join(root, 'knowledge'), repoIdentity: identity }, { conversationBaselineCursor: 0 });
+    const store = new ConversationStore({ layout, projectStore: projects });
+    const binder = new CommitConversationBinder({ layout, projectStore: projects, conversationStore: store });
+    const add = (sequence, eventId, content) => store.appendEvent(projectId, { eventId, sequence, source: 'codex', eventType: 'user_prompt', role: 'user', content, turnId: eventId, repoIdentity: identity, capturedAt: '2026-08-24T00:00:00.000Z', identityConfidence: 'exact', captureStatus: 'captured' });
+    const boundary = (sha, cursor) => store.writeBoundary(projectId, { commitSha: sha, repoIdentity: identity, parentShas: [], branch: 'main', committedAt: '2026-08-24T00:00:00.000Z', bridgeCursorAtCommit: cursor, journalSequence: cursor, openTurnIdsAtCommit: [], operationId: `op-${cursor}` });
+    const b = 'b'.repeat(40); const c = 'c'.repeat(40); const d = 'd'.repeat(40);
+    await add(1, 'prompt-b', 'offline B'); boundary(b, 2);
+    await add(3, 'prompt-c', 'offline C'); boundary(c, 4);
+    await add(5, 'prompt-d', 'online D'); boundary(d, 6);
+    const snapshot = await binder.bind({ projectId, commitSha: d });
+    assert.deepEqual(snapshot.turns.map(turn => turn.turnId), ['prompt-d']);
+    assert.equal(JSON.stringify(snapshot).includes('offline B'), false);
+    assert.equal(JSON.stringify(snapshot).includes('offline C'), false);
+  } finally { fs.rmSync(root, { recursive: true, force: true }); }
+  console.log('offline-boundary-isolation-test PASS');
+})().catch(error => { console.error(error.stack || error.message); process.exit(1); });

package/_site/_test/packaged-ui-smoke-test.js

@@ -53,26 +53,28 @@ function buildAndInstallPackage() {
   let browser;
   try {
     const packagedRoot = buildAndInstallPackage();
-    assert(fs.existsSync(path.join(packagedRoot, 'ui', 'i18n.js')), 'packed UI must include ui/i18n.js');
+    for (const file of ['index.html', 'product.js', 'product.css']) assert(fs.existsSync(path.join(packagedRoot, 'ui', file)), `packed UI must include ${file}`);
+    for (const file of ['app.js', 'app.css', 'i18n.js']) assert(!fs.existsSync(path.join(packagedRoot, 'ui', file)), `obsolete shell resource must not be shipped: ${file}`);
 
-    server = spawnServer({ root: packagedRoot, port: PORT, tag: 'packaged-ui', stdio: 'ignore' });
+    server = spawnServer({ root: packagedRoot, port: PORT, dataDir: path.join(tempRoot, 'data'), tag: 'packaged-ui', analysisOwner: 'engine', stdio: 'ignore' });
     await waitFor(async () => {
       try { return (await fetch(`${BASE}/api/health`)).ok ? { ok: true } : null; }
       catch { return null; }
     }, 'packaged server', 20000);
 
-    const i18nResponse = await fetch(`${BASE}/i18n.js`);
-    assert.strictEqual(i18nResponse.status, 200, 'packaged server must serve /i18n.js');
-    assert.match(String(i18nResponse.headers.get('content-type') || ''), /javascript/i);
+    const productResponse = await fetch(`${BASE}/product.js`);
+    assert.strictEqual(productResponse.status, 200, 'packaged server must serve /product.js');
+    assert.match(String(productResponse.headers.get('content-type') || ''), /javascript/i);
 
-    browser = await launchCdpBrowser({ chrome: findChrome(), profileDir, url: `${BASE}/`, width: 1440, height: 900 });
+    browser = await launchCdpBrowser({ chrome: findChrome(), profileDir, url: `${BASE}/`, width: 1920, height: 1080 });
+    await browser.setViewport(1920, 1080);
     await waitFor(async () => {
-      const ready = await browser.evaluate('Boolean(window.I18N && window.__PK_APP__)');
+      const ready = await browser.evaluate("document.getElementById('homeContent').textContent.includes('第一个项目')");
       return ready ? { ok: true } : null;
     }, 'packaged UI bootstrap', 20000);
 
-    const state = await browser.evaluate('window.__PK_APP__.getState()');
-    assert.strictEqual(state.projects, 0);
+    assert.strictEqual(await browser.evaluate("document.getElementById('projectSelect').disabled"), true);
+    assert.strictEqual(await browser.evaluate("document.querySelectorAll('nav [data-view]').length"), 6);
     assert.strictEqual(browser.exceptions.length, 0, `packaged UI runtime exceptions: ${JSON.stringify(browser.exceptions)}`);
     console.log('packaged-ui-smoke-test PASS');
   } finally {

package/_site/_test/path-consistency-test.js

@@ -1,151 +1,151 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const { StorageLayout } = require('../lib/storage-layout');
-const { SettingsStore } = require('../lib/settings-store');
-const { ProjectRegistryStore } = require('../lib/project-registry-store');
-const { ProjectStore } = require('../lib/project-store');
-const { ProjectLifecycleService } = require('../lib/project-lifecycle-service');
-const { KnowledgeToolRuntime } = require('../lib/knowledge-tool-runtime');
-const { CommitReconciler } = require('../lib/commit-reconciler');
-const { handlePostCommitEvent } = require('../lib/post-commit-automation');
-const hookManager = require('../lib/hook-manager');
-const { callTool } = require('../../bin/project-knowledge-mcp');
-const { spawnServer } = require('./helpers/spawn-server');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const PORT = 7834;
-const BASE = `http://127.0.0.1:${PORT}`;
-const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-path-v2-'));
-const dataDir = path.join(temp, 'data');
-const rootA = path.join(temp, 'knowledge-a');
-const rootB = path.join(temp, 'knowledge-b');
-const oldRepo = path.join(temp, 'old-repo');
-const movedRepo = path.join(temp, 'moved-repo');
-const newRepo = path.join(temp, 'new-repo');
-
-function git(cwd, args) {
-  const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
-  assert.strictEqual(result.status, 0, result.stderr);
-  return String(result.stdout || '').trim();
-}
-
-function initializeRepo(cwd, title) {
-  fs.mkdirSync(cwd, { recursive: true });
-  git(cwd, ['init', '--initial-branch=main']);
-  git(cwd, ['config', 'user.email', 'path@example.test']);
-  git(cwd, ['config', 'user.name', 'Path Test']);
-  fs.writeFileSync(path.join(cwd, 'README.md'), `# ${title}\n`, 'utf8');
-  git(cwd, ['add', 'README.md']);
-  git(cwd, ['commit', '-m', 'baseline']);
-}
-
-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 () => {
-  let spawned;
-  try {
-    initializeRepo(oldRepo, 'Old');
-    initializeRepo(newRepo, 'New');
-    fs.mkdirSync(rootA, { recursive: true });
-    fs.mkdirSync(rootB, { recursive: true });
-    const oldKnowledge = path.join(rootA, 'old-fixed');
-    fs.mkdirSync(path.join(oldKnowledge, 'modules'), { recursive: true });
-    fs.writeFileSync(path.join(oldKnowledge, 'modules', 'identity.md'), '# Fixed identity\n\nOld project knowledge remains here.\n', 'utf8');
-
-    const layout = new StorageLayout({ dataDir });
-    const settingsStore = new SettingsStore({ layout });
-    const registryStore = new ProjectRegistryStore({ layout });
-    const projectStore = new ProjectStore({ layout });
-    await settingsStore.initialize({ knowledge: { rootPath: rootA } });
-    await registryStore.initialize();
-    const baseline = git(oldRepo, ['rev-parse', 'HEAD']);
-    const commonDir = git(oldRepo, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
-    await projectStore.create('project-stable', {
-      displayName: 'Before rename', storageName: 'old-fixed', repoPath: oldRepo, knowledgePath: oldKnowledge,
-      repoIdentity: { commonDir }, legacyExtensions: { slug: 'legacy-old' },
-    }, { trackingStartCommit: baseline, index: { dirty: true, generation: 1 } });
-    await registryStore.add('project-stable', { displayNameSnapshot: 'Before rename' });
-
-    await settingsStore.updatePatch({ knowledge: { rootPath: rootB } });
-    assert.strictEqual(projectStore.readConfig('project-stable').knowledgePath, oldKnowledge, 'global root changes must not move an existing project');
-    await projectStore.updateConfig('project-stable', { displayName: 'After rename' });
-    assert.strictEqual(projectStore.readConfig('project-stable').projectId, 'project-stable');
-
-    const lifecycle = new ProjectLifecycleService({ layout, settingsStore, registryStore, projectStore, hookManager, triggerScriptPath: path.join(ROOT, '_site', 'scripts', 'hook-trigger.js') });
-    const imported = await lifecycle.importProject({ localPath: newRepo, displayName: 'New root project' });
-    assert(layout.isPathInside(rootB, imported.config.knowledgePath, { realpath: true }));
-    assert(!layout.isPathInside(rootA, imported.config.knowledgePath, { realpath: true }));
-    await settingsStore.updatePatch({ ai: { schema: 'ai-profiles/v1', profiles: [{ id: 'secret', apiKey: 'never-print-this-secret' }] } });
-
-    fs.renameSync(oldRepo, movedRepo);
-    const reconciler = new CommitReconciler({ layout, registryStore, projectStore, requireAiProfile: false });
-    reconciler.processCommitEvent = async input => ({ ok: true, projectId: input.projectId, commitSha: input.commitSha, status: 'completed', processed: [] });
-    const moved = await handlePostCommitEvent({ schema: 'hook-event/v2', projectId: 'project-stable', repoRoot: movedRepo, head: baseline, branch: 'main' }, { layout, registryStore, projectStore, reconciler });
-    assert.strictEqual(moved.ok, true);
-    assert.strictEqual(projectStore.readConfig('project-stable').repoPath, path.resolve(movedRepo));
-    assert.strictEqual(projectStore.readConfig('project-stable').projectId, 'project-stable');
-
-    const runtime = new KnowledgeToolRuntime({ layout, settingsStore, registryStore, projectStore, cwd: movedRepo });
-    const resolved = runtime.resolveProject({ repoPath: movedRepo });
-    assert.strictEqual(resolved.projectId, 'project-stable');
-    assert.strictEqual(resolved.knowledgePath, oldKnowledge);
-    assert.strictEqual(resolved.indexPath, layout.getIndexPath());
-    const mcpResolved = await callTool(runtime, 'project_knowledge_resolve', { projectId: 'project-stable' });
-    assert.strictEqual(mcpResolved.knowledgePath, resolved.knowledgePath);
-    assert.strictEqual(mcpResolved.indexPath, resolved.indexPath);
-
-    const protectedFiles = [layout.getSettingsPath(), layout.getProjectRegistryPath(), layout.getProjectConfigPath('project-stable'), layout.getProjectStatePath('project-stable')];
-    const beforeRead = new Map(protectedFiles.map(file => [file, fs.readFileSync(file, 'utf8')]));
-    const entry = await runtime.get({ projectId: 'project-stable', entry: 'modules/identity.md' });
-    assert.match(entry.chunks[0].chunk_text, /Old project knowledge/);
-    const search = await runtime.search({ projectId: 'project-stable', query: 'Old project knowledge' });
-    assert.strictEqual(search.source, 'knowledge-retrieval-service');
-    assert.strictEqual(search.backend, 'markdown-hybrid-fallback');
-    const cli = spawnSync(process.execPath, [path.join(ROOT, 'bin', 'project-knowledge-kb.js'), 'get', '--project', 'project-stable', '--entry', 'modules/identity.md', '--json'], {
-      cwd: movedRepo, encoding: 'utf8', env: { ...process.env, KB_DATA_DIR: dataDir, KB_SKIP_MIGRATION: '1' },
-    });
-    assert.strictEqual(cli.status, 0, cli.stderr);
-    assert.match(JSON.parse(cli.stdout).chunks[0].chunk_text, /Old project knowledge/);
-    const cliError = spawnSync(process.execPath, [path.join(ROOT, 'bin', 'project-knowledge-kb.js'), 'get', '--project', 'missing-project', '--entry', 'README.md', '--json'], {
-      cwd: movedRepo, encoding: 'utf8', env: { ...process.env, KB_DATA_DIR: dataDir, KB_SKIP_MIGRATION: '1' },
-    });
-    assert.notStrictEqual(cliError.status, 0);
-    assert(!cliError.stderr.includes('never-print-this-secret'));
-    assert(!/\bstack\b/i.test(cliError.stderr));
-    for (const file of protectedFiles) assert.strictEqual(fs.readFileSync(file, 'utf8'), beforeRead.get(file), `read query mutated ${file}`);
-    await runtime.close();
-
-    spawned = spawnServer({ root: ROOT, port: PORT, dataDir, tag: 'path-v2' });
-    await waitForServer();
-    const response = await fetch(`${BASE}/api/projects`);
-    const body = await response.json();
-    const serverProject = body.projects.find(project => project.projectId === 'project-stable');
-    assert.strictEqual(serverProject.config.knowledgePath, oldKnowledge);
-    assert.strictEqual(layout.getIndexPath(), path.join(dataDir, 'index', 'knowledge.lancedb'));
-    console.log('path-consistency-test PASS');
-  } finally {
-    if (spawned) {
-      try { spawned.child.kill(); } catch {}
-      await Promise.race([
-        new Promise(resolve => spawned.child.once('exit', resolve)),
-        new Promise(resolve => setTimeout(resolve, 2000)),
-      ]);
-    }
-    for (let attempt = 0; attempt < 5; attempt += 1) {
-      try { fs.rmSync(temp, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); break; }
-      catch (error) {
-        if (attempt === 4) throw error;
-        await new Promise(resolve => setTimeout(resolve, 150));
-      }
-    }
-  }
-})().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 { StorageLayout } = require('../lib/storage-layout');
+const { SettingsStore } = require('../lib/settings-store');
+const { ProjectRegistryStore } = require('../lib/project-registry-store');
+const { ProjectStore } = require('../lib/project-store');
+const { ProjectLifecycleService } = require('../lib/project-lifecycle-service');
+const { KnowledgeToolRuntime } = require('../lib/knowledge-tool-runtime');
+const { CommitReconciler } = require('../lib/commit-reconciler');
+const { handlePostCommitEvent } = require('../lib/post-commit-automation');
+const hookManager = require('../lib/hook-manager');
+const { callTool } = require('../../bin/project-knowledge-mcp');
+const { spawnServer } = require('./helpers/spawn-server');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const PORT = 7834;
+const BASE = `http://127.0.0.1:${PORT}`;
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-path-v2-'));
+const dataDir = path.join(temp, 'data');
+const rootA = path.join(temp, 'knowledge-a');
+const rootB = path.join(temp, 'knowledge-b');
+const oldRepo = path.join(temp, 'old-repo');
+const movedRepo = path.join(temp, 'moved-repo');
+const newRepo = path.join(temp, 'new-repo');
+
+function git(cwd, args) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
+  assert.strictEqual(result.status, 0, result.stderr);
+  return String(result.stdout || '').trim();
+}
+
+function initializeRepo(cwd, title) {
+  fs.mkdirSync(cwd, { recursive: true });
+  git(cwd, ['init', '--initial-branch=main']);
+  git(cwd, ['config', 'user.email', 'path@example.test']);
+  git(cwd, ['config', 'user.name', 'Path Test']);
+  fs.writeFileSync(path.join(cwd, 'README.md'), `# ${title}\n`, 'utf8');
+  git(cwd, ['add', 'README.md']);
+  git(cwd, ['commit', '-m', 'baseline']);
+}
+
+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 () => {
+  let spawned;
+  try {
+    initializeRepo(oldRepo, 'Old');
+    initializeRepo(newRepo, 'New');
+    fs.mkdirSync(rootA, { recursive: true });
+    fs.mkdirSync(rootB, { recursive: true });
+    const oldKnowledge = path.join(rootA, 'old-fixed');
+    fs.mkdirSync(path.join(oldKnowledge, 'modules'), { recursive: true });
+    fs.writeFileSync(path.join(oldKnowledge, 'modules', 'identity.md'), '# Fixed identity\n\nOld project knowledge remains here.\n', 'utf8');
+
+    const layout = new StorageLayout({ dataDir });
+    const settingsStore = new SettingsStore({ layout });
+    const registryStore = new ProjectRegistryStore({ layout });
+    const projectStore = new ProjectStore({ layout });
+    await settingsStore.initialize({ knowledge: { rootPath: rootA } });
+    await registryStore.initialize();
+    const baseline = git(oldRepo, ['rev-parse', 'HEAD']);
+    const commonDir = git(oldRepo, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+    await projectStore.create('project-stable', {
+      displayName: 'Before rename', storageName: 'old-fixed', repoPath: oldRepo, knowledgePath: oldKnowledge,
+      repoIdentity: { commonDir }, legacyExtensions: { slug: 'legacy-old' },
+    }, { trackingStartCommit: baseline, index: { dirty: true, generation: 1 } });
+    await registryStore.add('project-stable', { displayNameSnapshot: 'Before rename' });
+
+    await settingsStore.updatePatch({ knowledge: { rootPath: rootB } });
+    assert.strictEqual(projectStore.readConfig('project-stable').knowledgePath, oldKnowledge, 'global root changes must not move an existing project');
+    await projectStore.updateConfig('project-stable', { displayName: 'After rename' });
+    assert.strictEqual(projectStore.readConfig('project-stable').projectId, 'project-stable');
+
+    const lifecycle = new ProjectLifecycleService({ layout, settingsStore, registryStore, projectStore, hookManager, triggerScriptPath: path.join(ROOT, '_site', 'scripts', 'hook-trigger.js') });
+    const imported = await lifecycle.importProject({ localPath: newRepo, displayName: 'New root project' });
+    assert(layout.isPathInside(rootB, imported.config.knowledgePath, { realpath: true }));
+    assert(!layout.isPathInside(rootA, imported.config.knowledgePath, { realpath: true }));
+    await settingsStore.updatePatch({ ai: { schema: 'ai-profiles/v1', profiles: [{ id: 'secret', apiKey: 'never-print-this-secret' }] } });
+
+    fs.renameSync(oldRepo, movedRepo);
+    const reconciler = new CommitReconciler({ layout, registryStore, projectStore, requireAiProfile: false });
+    reconciler.processCommitEvent = async input => ({ ok: true, projectId: input.projectId, commitSha: input.commitSha, status: 'completed', processed: [] });
+    const moved = await handlePostCommitEvent({ schema: 'hook-event/v2', projectId: 'project-stable', repoRoot: movedRepo, head: baseline, branch: 'main' }, { layout, registryStore, projectStore, reconciler });
+    assert.strictEqual(moved.ok, true);
+    assert.strictEqual(projectStore.readConfig('project-stable').repoPath, path.resolve(movedRepo));
+    assert.strictEqual(projectStore.readConfig('project-stable').projectId, 'project-stable');
+
+    const runtime = new KnowledgeToolRuntime({ layout, settingsStore, registryStore, projectStore, cwd: movedRepo });
+    const resolved = runtime.resolveProject({ repoPath: movedRepo });
+    assert.strictEqual(resolved.projectId, 'project-stable');
+    assert.strictEqual(resolved.knowledgePath, oldKnowledge);
+    assert.strictEqual(resolved.indexPath, layout.getIndexPath());
+    const mcpResolved = await callTool(runtime, 'project_knowledge_resolve', { projectId: 'project-stable' });
+    assert.strictEqual(mcpResolved.knowledgePath, resolved.knowledgePath);
+    assert.strictEqual(mcpResolved.indexPath, resolved.indexPath);
+
+    const protectedFiles = [layout.getSettingsPath(), layout.getProjectRegistryPath(), layout.getProjectConfigPath('project-stable'), layout.getProjectStatePath('project-stable')];
+    const beforeRead = new Map(protectedFiles.map(file => [file, fs.readFileSync(file, 'utf8')]));
+    const entry = await runtime.get({ projectId: 'project-stable', entry: 'modules/identity.md' });
+    assert.match(entry.chunks[0].chunk_text, /Old project knowledge/);
+    const search = await runtime.search({ projectId: 'project-stable', query: 'Old project knowledge' });
+    assert.strictEqual(search.source, 'knowledge-retrieval-service');
+    assert.strictEqual(search.backend, 'markdown-hybrid-fallback');
+    const cli = spawnSync(process.execPath, [path.join(ROOT, 'bin', 'project-knowledge-kb.js'), 'get', '--project', 'project-stable', '--entry', 'modules/identity.md', '--json'], {
+      cwd: movedRepo, encoding: 'utf8', env: { ...process.env, KB_DATA_DIR: dataDir, KB_SKIP_MIGRATION: '1' },
+    });
+    assert.strictEqual(cli.status, 0, cli.stderr);
+    assert.match(JSON.parse(cli.stdout).chunks[0].chunk_text, /Old project knowledge/);
+    const cliError = spawnSync(process.execPath, [path.join(ROOT, 'bin', 'project-knowledge-kb.js'), 'get', '--project', 'missing-project', '--entry', 'README.md', '--json'], {
+      cwd: movedRepo, encoding: 'utf8', env: { ...process.env, KB_DATA_DIR: dataDir, KB_SKIP_MIGRATION: '1' },
+    });
+    assert.notStrictEqual(cliError.status, 0);
+    assert(!cliError.stderr.includes('never-print-this-secret'));
+    assert(!/\bstack\b/i.test(cliError.stderr));
+    for (const file of protectedFiles) assert.strictEqual(fs.readFileSync(file, 'utf8'), beforeRead.get(file), `read query mutated ${file}`);
+    await runtime.close();
+
+    spawned = spawnServer({ root: ROOT, port: PORT, dataDir, tag: 'path-v2' });
+    await waitForServer();
+    const response = await fetch(`${BASE}/api/projects`);
+    const body = await response.json();
+    const serverProject = body.projects.find(project => project.projectId === 'project-stable');
+    assert.strictEqual(serverProject.config.knowledgePath, oldKnowledge);
+    assert.strictEqual(layout.getIndexPath(), path.join(dataDir, 'index', 'knowledge.lancedb'));
+    console.log('path-consistency-test PASS');
+  } finally {
+    if (spawned) {
+      try { spawned.child.kill(); } catch {}
+      await Promise.race([
+        new Promise(resolve => spawned.child.once('exit', resolve)),
+        new Promise(resolve => setTimeout(resolve, 2000)),
+      ]);
+    }
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+      try { fs.rmSync(temp, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); break; }
+      catch (error) {
+        if (attempt === 4) throw error;
+        await new Promise(resolve => setTimeout(resolve, 150));
+      }
+    }
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/pending-sweep-test.js

@@ -1,9 +1,9 @@
-const assert = require('assert');
-const automation = require('../lib/post-commit-automation');
-
-// Pending repository scans are not a recovery mechanism. A Hook event is the
-// only authority that can request analysis.
-assert.equal(Object.hasOwn(automation, 'dispatchPendingAutomations'), false);
-assert.equal(Object.hasOwn(automation, 'getQueueSize'), false);
-assert.equal(Object.hasOwn(automation, 'drainQueue'), false);
-console.log('pending-sweep-test PASS');
+const assert = require('assert');
+const automation = require('../lib/post-commit-automation');
+
+// Pending repository scans are not a recovery mechanism. A Hook event is the
+// only authority that can request analysis.
+assert.equal(Object.hasOwn(automation, 'dispatchPendingAutomations'), false);
+assert.equal(Object.hasOwn(automation, 'getQueueSize'), false);
+assert.equal(Object.hasOwn(automation, 'drainQueue'), false);
+console.log('pending-sweep-test PASS');

package/_site/_test/post-commit-automation-test.js

@@ -1,87 +1,87 @@
-// Run: node _site/_test/post-commit-automation-test.js
-
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-const automationConfig = require('../lib/automation-config');
-const automation = require('../lib/post-commit-automation');
-const { REQUIREMENT_UNAVAILABLE, renderCommitPrompt } = require('../lib/commit-prompt');
-
-(() => {
-  const normalized = automationConfig.normalizeAutomationConfig({
-    enabled: true,
-    hookPromptTemplate: 'Legacy instruction for {{commitHash}}.',
-    initPromptTemplate: 'must be ignored',
-    postCommitEnabled: true,
-    allowReadOnlyBash: true,
-  });
-  assert.strictEqual(normalized.commitPromptTemplate, 'Legacy instruction for {{commitHash}}.', 'legacy Hook prompt should be a read-only compatibility override');
-  assert.strictEqual(normalized.legacyPromptOverride, true);
-  assert(!Object.hasOwn(normalized, 'hookPromptTemplate'));
-  assert(!Object.hasOwn(normalized, 'initPromptTemplate'));
-  assert(!Object.hasOwn(normalized, 'postCommitEnabled'));
-  assert(!Object.hasOwn(normalized, 'allowReadOnlyBash'));
-  assert(!Object.hasOwn(automationConfig, 'DEFAULT_INIT_PROMPT_TEMPLATE'), 'init prompt constant must not be exported');
-  assert(!Object.hasOwn(automation, 'dispatchProjectInit'), 'project init dispatch must not be public');
-  assert(!Object.hasOwn(automation, 'dispatchAutomation'), 'generic automation dispatch must not be public');
-
-  const staging = path.resolve('runtime', 'staging', 'run-test');
-  const evidenceRoot = path.resolve('runtime', 'runs', 'run-test', 'input', 'evidence');
-  const policy = automationConfig.buildAutomationToolPolicy({ stagingPath: staging, evidenceRoot });
-  assert.strictEqual(policy.canWriteKb, false, 'AI must never write final knowledge directly');
-  assert.strictEqual(policy.canWriteStaging, true);
-  assert(!policy.allowedTools.includes('Bash'), 'generic Bash must not be available to analysis');
-  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Write', { file_path: path.join(staging, 'manifest.json') }).behavior, 'allow');
-  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Write', { file_path: path.resolve('source.js') }).behavior, 'deny');
-  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Read', { file_path: path.join(evidenceRoot, 'patch-manifest.json') }).behavior, 'allow');
-  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Write', { file_path: path.join(evidenceRoot, 'patches', '000001.patch') }).behavior, 'deny');
-  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Read', { file_path: path.resolve('repo', 'source.js') }).behavior, 'deny');
-  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Bash', { command: 'git show' }).behavior, 'deny');
-
-  const evidence = {
-    commitSha: 'a'.repeat(40),
-    parents: ['b'.repeat(40)],
-    author: 'Test Author',
-    date: '2026-08-17T00:00:00Z',
-    subject: 'feat: exact evidence',
-    branch: 'main',
-    patchMode: 'parent',
-    patchHash: 'sha256:patch',
-    patchBytes: 42,
-    patchOmitted: false,
-    patch: 'diff --git a/a.js b/a.js\n+implemented\n',
-    files: [{ status: 'M', path: 'a.js', oldPath: null, binary: false, added: 1, deleted: 0 }],
-  };
-  const config = {
-    projectId: 'project-test',
-    displayName: 'Prompt Test',
-    repoPath: path.resolve('repo'),
-    knowledgePath: path.resolve('knowledge'),
-    automation: { commitPromptTemplate: automationConfig.DEFAULT_COMMIT_PROMPT_TEMPLATE },
-  };
-  const missing = renderCommitPrompt({ config, evidence, requirements: [], existingKnowledge: { entries: [], omitted: [] } });
-  assert(missing.prompt.includes(REQUIREMENT_UNAVAILABLE), 'unavailable requirement must use the fixed non-guessing text');
-  assert(missing.prompt.includes(evidence.patch), 'prompt must contain the actual patch');
-  assert(missing.prompt.includes('现有相关知识'), 'prompt must contain existing knowledge section');
-  assert(missing.prompt.includes('新增、更新或删除'), 'prompt must ask for add/update/delete decisions');
-  assert(!missing.prompt.includes('git-hook') && !missing.prompt.includes('startup'), 'trigger must not affect prompt content');
-
-  const requirement = { id: 'req-1', client: 'codex', sessionId: 'session-1', ts: '2026-08-17T00:00:00Z', requirement: 'Implement the exact feature.' };
-  const fromHook = renderCommitPrompt({ config, evidence, requirements: [requirement], existingKnowledge: { entries: [] } });
-  const fromStartup = renderCommitPrompt({ config, evidence, requirements: [requirement], existingKnowledge: { entries: [] } });
-  assert.strictEqual(fromHook.promptHash, fromStartup.promptHash, 'Hook and startup must render the identical prompt hash');
-  assert(fromHook.prompt.includes('Implement the exact feature.'), 'recorded user requirement must be present');
-
-  const legacy = renderCommitPrompt({
-    config: { ...config, automation: { hookPromptTemplate: 'Legacy {{commitHash}}' } },
-    evidence,
-    requirements: [],
-    existingKnowledge: { entries: [] },
-  });
-  assert(legacy.prompt.includes('Legacy ' + evidence.commitSha), 'legacy Hook prompt override should still render');
-  assert(legacy.prompt.includes(REQUIREMENT_UNAVAILABLE) && legacy.prompt.includes(evidence.patch), 'mandatory evidence sections must be appended to incomplete legacy templates');
-
-  const source = fs.readFileSync(path.join(__dirname, '..', 'lib', 'post-commit-automation.js'), 'utf8');
-  assert(!/dispatchProjectInit|renderProjectInitPrompt|project-init|startup-recovery/.test(source), 'automation source must not retain init or a third trigger name');
-  console.log('post-commit-automation-test PASS');
-})();
+// Run: node _site/_test/post-commit-automation-test.js
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const automationConfig = require('../lib/automation-config');
+const automation = require('../lib/post-commit-automation');
+const { REQUIREMENT_UNAVAILABLE, renderCommitPrompt } = require('../lib/commit-prompt');
+
+(() => {
+  const normalized = automationConfig.normalizeAutomationConfig({
+    enabled: true,
+    hookPromptTemplate: 'Legacy instruction for {{commitHash}}.',
+    initPromptTemplate: 'must be ignored',
+    postCommitEnabled: true,
+    allowReadOnlyBash: true,
+  });
+  assert.strictEqual(normalized.commitPromptTemplate, 'Legacy instruction for {{commitHash}}.', 'legacy Hook prompt should be a read-only compatibility override');
+  assert.strictEqual(normalized.legacyPromptOverride, true);
+  assert(!Object.hasOwn(normalized, 'hookPromptTemplate'));
+  assert(!Object.hasOwn(normalized, 'initPromptTemplate'));
+  assert(!Object.hasOwn(normalized, 'postCommitEnabled'));
+  assert(!Object.hasOwn(normalized, 'allowReadOnlyBash'));
+  assert(!Object.hasOwn(automationConfig, 'DEFAULT_INIT_PROMPT_TEMPLATE'), 'init prompt constant must not be exported');
+  assert(!Object.hasOwn(automation, 'dispatchProjectInit'), 'project init dispatch must not be public');
+  assert(!Object.hasOwn(automation, 'dispatchAutomation'), 'generic automation dispatch must not be public');
+
+  const staging = path.resolve('runtime', 'staging', 'run-test');
+  const evidenceRoot = path.resolve('runtime', 'runs', 'run-test', 'input', 'evidence');
+  const policy = automationConfig.buildAutomationToolPolicy({ stagingPath: staging, evidenceRoot });
+  assert.strictEqual(policy.canWriteKb, false, 'AI must never write final knowledge directly');
+  assert.strictEqual(policy.canWriteStaging, true);
+  assert(!policy.allowedTools.includes('Bash'), 'generic Bash must not be available to analysis');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Write', { file_path: path.join(staging, 'manifest.json') }).behavior, 'allow');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Write', { file_path: path.resolve('source.js') }).behavior, 'deny');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Read', { file_path: path.join(evidenceRoot, 'patch-manifest.json') }).behavior, 'allow');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Write', { file_path: path.join(evidenceRoot, 'patches', '000001.patch') }).behavior, 'deny');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Read', { file_path: path.resolve('repo', 'source.js') }).behavior, 'deny');
+  assert.strictEqual(automationConfig.evaluateAutomationToolUse(policy, 'Bash', { command: 'git show' }).behavior, 'deny');
+
+  const evidence = {
+    commitSha: 'a'.repeat(40),
+    parents: ['b'.repeat(40)],
+    author: 'Test Author',
+    date: '2026-08-17T00:00:00Z',
+    subject: 'feat: exact evidence',
+    branch: 'main',
+    patchMode: 'parent',
+    patchHash: 'sha256:patch',
+    patchBytes: 42,
+    patchOmitted: false,
+    patch: 'diff --git a/a.js b/a.js\n+implemented\n',
+    files: [{ status: 'M', path: 'a.js', oldPath: null, binary: false, added: 1, deleted: 0 }],
+  };
+  const config = {
+    projectId: 'project-test',
+    displayName: 'Prompt Test',
+    repoPath: path.resolve('repo'),
+    knowledgePath: path.resolve('knowledge'),
+    automation: { commitPromptTemplate: automationConfig.DEFAULT_COMMIT_PROMPT_TEMPLATE },
+  };
+  const missing = renderCommitPrompt({ config, evidence, requirements: [], existingKnowledge: { entries: [], omitted: [] } });
+  assert(missing.prompt.includes(REQUIREMENT_UNAVAILABLE), 'unavailable requirement must use the fixed non-guessing text');
+  assert(missing.prompt.includes(evidence.patch), 'prompt must contain the actual patch');
+  assert(missing.prompt.includes('现有相关知识'), 'prompt must contain existing knowledge section');
+  assert(missing.prompt.includes('新增、更新或删除'), 'prompt must ask for add/update/delete decisions');
+  assert(!missing.prompt.includes('git-hook') && !missing.prompt.includes('startup'), 'trigger must not affect prompt content');
+
+  const requirement = { id: 'req-1', client: 'codex', sessionId: 'session-1', ts: '2026-08-17T00:00:00Z', requirement: 'Implement the exact feature.' };
+  const fromHook = renderCommitPrompt({ config, evidence, requirements: [requirement], existingKnowledge: { entries: [] } });
+  const fromStartup = renderCommitPrompt({ config, evidence, requirements: [requirement], existingKnowledge: { entries: [] } });
+  assert.strictEqual(fromHook.promptHash, fromStartup.promptHash, 'Hook and startup must render the identical prompt hash');
+  assert(fromHook.prompt.includes('Implement the exact feature.'), 'recorded user requirement must be present');
+
+  const legacy = renderCommitPrompt({
+    config: { ...config, automation: { hookPromptTemplate: 'Legacy {{commitHash}}' } },
+    evidence,
+    requirements: [],
+    existingKnowledge: { entries: [] },
+  });
+  assert(legacy.prompt.includes('Legacy ' + evidence.commitSha), 'legacy Hook prompt override should still render');
+  assert(legacy.prompt.includes(REQUIREMENT_UNAVAILABLE) && legacy.prompt.includes(evidence.patch), 'mandatory evidence sections must be appended to incomplete legacy templates');
+
+  const source = fs.readFileSync(path.join(__dirname, '..', 'lib', 'post-commit-automation.js'), 'utf8');
+  assert(!/dispatchProjectInit|renderProjectInitPrompt|project-init|startup-recovery/.test(source), 'automation source must not retain init or a third trigger name');
+  console.log('post-commit-automation-test PASS');
+})();