@sanqianx/project-knowledge 5.0.24 → 5.0.25

package/_site/_test/knowledge-store-logs-supervision-test.js

@@ -1,89 +1,89 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnServer } = require('./helpers/spawn-server');
-const { makeRepo } = require('./fixtures/make-git-repos');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const PORT = Number(process.env.KB_TASK_012_013_TEST_PORT || 7814);
-const BASE_URL = `http://127.0.0.1:${PORT}`;
-const DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), `kb-store-logs-v2-${process.pid}-`));
-
-async function waitForServer() {
-  for (let attempt = 0; attempt < 100; attempt += 1) {
-    try { if ((await fetch(`${BASE_URL}/api/health`)).ok) return; } catch {}
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-  throw new Error('server did not start');
-}
-
-async function json(method, route, body) {
-  const response = await fetch(`${BASE_URL}${route}`, {
-    method,
-    headers: body ? { 'Content-Type': 'application/json' } : undefined,
-    body: body ? JSON.stringify(body) : undefined,
-  });
-  const text = await response.text();
-  return { response, body: text ? JSON.parse(text) : {} };
-}
-
-(async () => {
-  const repoOne = makeRepo({ kind: 'multi-commit' });
-  const repoTwo = makeRepo({ kind: 'one-commit' });
-  const spawned = spawnServer({ root: ROOT, port: PORT, dataDir: DATA_DIR, tag: 'knowledge-store-logs-v2', extraEnv: { KB_EMBEDDING_FAKE: '1' } });
-  let output = '';
-  spawned.child.stdout.on('data', chunk => { output += chunk; });
-  spawned.child.stderr.on('data', chunk => { output += chunk; });
-  try {
-    await waitForServer();
-    const rootOne = path.join(DATA_DIR, 'knowledge-one');
-    let result = await json('PATCH', '/api/settings', { knowledge: { rootPath: rootOne } });
-    assert(result.response.ok, JSON.stringify(result.body));
-    result = await json('POST', '/api/projects/import', { projectId: 'store-project-one', localPath: repoOne.path, displayName: 'Store one' });
-    assert.strictEqual(result.response.status, 201, JSON.stringify(result.body));
-    const fixedPath = result.body.config.knowledgePath;
-    assert(path.resolve(fixedPath).startsWith(`${path.resolve(rootOne)}${path.sep}`));
-    assert.deepStrictEqual(fs.readdirSync(fixedPath), [], 'import must not generate TODO or initialization knowledge');
-
-    const rootTwo = path.join(DATA_DIR, 'knowledge-two');
-    result = await json('PATCH', '/api/settings', { knowledge: { rootPath: rootTwo } });
-    assert(result.response.ok);
-    result = await json('POST', '/api/projects/import', { projectId: 'store-project-two', localPath: repoTwo.path, displayName: 'Store two' });
-    assert.strictEqual(result.response.status, 201, JSON.stringify(result.body));
-    assert(path.resolve(result.body.config.knowledgePath).startsWith(`${path.resolve(rootTwo)}${path.sep}`));
-    result = await json('GET', '/api/projects/store-project-one');
-    assert.strictEqual(result.body.project.config.knowledgePath, fixedPath, 'global root changes affect only future imports');
-
-    result = await json('PATCH', '/api/settings', { logging: { levels: ['trace', 'debug', 'info', 'warn', 'error', 'fatal'] } });
-    assert.strictEqual(result.response.status, 409, 'logging capture policy must not be a mutable product setting');
-    const publicSettings = await json('GET', '/api/settings');
-    assert.strictEqual(Object.prototype.hasOwnProperty.call(publicSettings.body.settings.logging, 'retentionDays'), false);
-    result = await json('PATCH', '/api/settings', { logging: { retentionDays: 0 } });
-    assert.strictEqual(result.response.status, 409, 'automatic retention settings must be removed');
-    result = await json('PATCH', '/api/settings', { logging: { rootPath: path.join(DATA_DIR, 'external-logs') } });
-    assert.strictEqual(result.response.status, 409, 'logging root must not be configurable');
-    assert(!fs.existsSync(path.join(DATA_DIR, 'external-logs')));
-
-    result = await json('GET', '/api/logs?levels=info,error&pageSize=100');
-    assert(result.response.ok, JSON.stringify(result.body));
-    assert(result.body.entries.some(log => log.event === 'project.import.completed' && log.projectId === 'store-project-one'));
-    assert(result.body.health && ['ok', 'degraded'].includes(result.body.health.status));
-    const state = await json('GET', '/api/state');
-    const one = state.body.projects.find(project => project.projectId === 'store-project-one');
-    assert(one && one.state.trackingStartCommit, 'v2 state should expose the import tracking baseline');
-    assert.strictEqual(one.state.analysis.status, 'idle');
-    assert.strictEqual(one.state.hook.managedVersion, 2);
-
-    result = await json('POST', '/api/knowledge-store/migrate', { execute: false });
-    assert.strictEqual(result.response.status, 404, 'the old storage relocation API must remain removed');
-    console.log('TASK-012/TASK-013 knowledge store, logs, supervision test passed');
-  } catch (error) {
-    if (output) process.stderr.write(output);
-    throw error;
-  } finally {
-    spawned.child.kill();
-    repoOne.cleanup();
-    repoTwo.cleanup();
-  }
-})().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 { spawnServer } = require('./helpers/spawn-server');
+const { makeRepo } = require('./fixtures/make-git-repos');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const PORT = Number(process.env.KB_TASK_012_013_TEST_PORT || 7814);
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+const DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), `kb-store-logs-v2-${process.pid}-`));
+
+async function waitForServer() {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    try { if ((await fetch(`${BASE_URL}/api/health`)).ok) return; } catch {}
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error('server did not start');
+}
+
+async function json(method, route, body) {
+  const response = await fetch(`${BASE_URL}${route}`, {
+    method,
+    headers: body ? { 'Content-Type': 'application/json' } : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await response.text();
+  return { response, body: text ? JSON.parse(text) : {} };
+}
+
+(async () => {
+  const repoOne = makeRepo({ kind: 'multi-commit' });
+  const repoTwo = makeRepo({ kind: 'one-commit' });
+  const spawned = spawnServer({ root: ROOT, port: PORT, dataDir: DATA_DIR, tag: 'knowledge-store-logs-v2', extraEnv: { KB_EMBEDDING_FAKE: '1' } });
+  let output = '';
+  spawned.child.stdout.on('data', chunk => { output += chunk; });
+  spawned.child.stderr.on('data', chunk => { output += chunk; });
+  try {
+    await waitForServer();
+    const rootOne = path.join(DATA_DIR, 'knowledge-one');
+    let result = await json('PATCH', '/api/settings', { knowledge: { rootPath: rootOne } });
+    assert(result.response.ok, JSON.stringify(result.body));
+    result = await json('POST', '/api/projects/import', { projectId: 'store-project-one', localPath: repoOne.path, displayName: 'Store one' });
+    assert.strictEqual(result.response.status, 201, JSON.stringify(result.body));
+    const fixedPath = result.body.config.knowledgePath;
+    assert(path.resolve(fixedPath).startsWith(`${path.resolve(rootOne)}${path.sep}`));
+    assert.deepStrictEqual(fs.readdirSync(fixedPath), [], 'import must not generate TODO or initialization knowledge');
+
+    const rootTwo = path.join(DATA_DIR, 'knowledge-two');
+    result = await json('PATCH', '/api/settings', { knowledge: { rootPath: rootTwo } });
+    assert(result.response.ok);
+    result = await json('POST', '/api/projects/import', { projectId: 'store-project-two', localPath: repoTwo.path, displayName: 'Store two' });
+    assert.strictEqual(result.response.status, 201, JSON.stringify(result.body));
+    assert(path.resolve(result.body.config.knowledgePath).startsWith(`${path.resolve(rootTwo)}${path.sep}`));
+    result = await json('GET', '/api/projects/store-project-one');
+    assert.strictEqual(result.body.project.config.knowledgePath, fixedPath, 'global root changes affect only future imports');
+
+    result = await json('PATCH', '/api/settings', { logging: { levels: ['trace', 'debug', 'info', 'warn', 'error', 'fatal'] } });
+    assert.strictEqual(result.response.status, 409, 'logging capture policy must not be a mutable product setting');
+    const publicSettings = await json('GET', '/api/settings');
+    assert.strictEqual(Object.prototype.hasOwnProperty.call(publicSettings.body.settings.logging, 'retentionDays'), false);
+    result = await json('PATCH', '/api/settings', { logging: { retentionDays: 0 } });
+    assert.strictEqual(result.response.status, 409, 'automatic retention settings must be removed');
+    result = await json('PATCH', '/api/settings', { logging: { rootPath: path.join(DATA_DIR, 'external-logs') } });
+    assert.strictEqual(result.response.status, 409, 'logging root must not be configurable');
+    assert(!fs.existsSync(path.join(DATA_DIR, 'external-logs')));
+
+    result = await json('GET', '/api/logs?levels=info,error&pageSize=100');
+    assert(result.response.ok, JSON.stringify(result.body));
+    assert(result.body.entries.some(log => log.event === 'project.import.completed' && log.projectId === 'store-project-one'));
+    assert(result.body.health && ['ok', 'degraded'].includes(result.body.health.status));
+    const state = await json('GET', '/api/state');
+    const one = state.body.projects.find(project => project.projectId === 'store-project-one');
+    assert(one && one.state.trackingStartCommit, 'v2 state should expose the import tracking baseline');
+    assert.strictEqual(one.state.analysis.status, 'idle');
+    assert.strictEqual(one.state.hook.managedVersion, 2);
+
+    result = await json('POST', '/api/knowledge-store/migrate', { execute: false });
+    assert.strictEqual(result.response.status, 404, 'the old storage relocation API must remain removed');
+    console.log('TASK-012/TASK-013 knowledge store, logs, supervision test passed');
+  } catch (error) {
+    if (output) process.stderr.write(output);
+    throw error;
+  } finally {
+    spawned.child.kill();
+    repoOne.cleanup();
+    repoTwo.cleanup();
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/launcher-readiness-test.js

@@ -1,80 +1,80 @@
-'use strict';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const net = require('node:net');
-const { spawn } = require('node:child_process');
-const endpoint = require('../lib/runtime-endpoint');
-
-const packageRoot = process.env.KB_LAUNCHER_TEST_PACKAGE || path.resolve(__dirname, '../..');
-const bin = path.join(packageRoot, 'bin/project-knowledge.js');
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-launcher-readiness-'));
-const data = path.join(root, '.project-knowledge-v5');
-const record = path.join(data, 'runtime/claude-sessions/project-a/session.json');
-const recordBytes = JSON.stringify({ schema: 'claude-workbench-session/v1', sessionId: 'old-test', projectSlug: 'project-a', state: 'running', metadata: { automation: true } });
-fs.mkdirSync(path.dirname(record), { recursive: true });
-fs.writeFileSync(record, recordBytes);
-const env = { ...process.env, KB_DATA_DIR: data, KB_MODULES_AUTOSTART: '0', AI_CODING_EVENT_BRIDGE_HOME: path.join(root, 'bridge') };
-let serverPid;
-
-function run(args, overrides = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [bin, ...args], { cwd: root, env: { ...env, ...overrides }, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
-    let stdout = '', stderr = '';
-    const timer = setTimeout(() => { child.kill(); reject(new Error(`CLI timed out: ${stdout} ${stderr}`)); }, 25000);
-    child.stdout.on('data', chunk => { stdout += chunk; });
-    child.stderr.on('data', chunk => { stderr += chunk; });
-    child.once('error', reject);
-    child.once('exit', code => { clearTimeout(timer); resolve({ code, stdout, stderr }); });
-  });
-}
-async function freePort() {
-  const server = net.createServer();
-  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
-  const port = server.address().port;
-  await new Promise(resolve => server.close(resolve));
-  return port;
-}
-
-(async () => {
-  const port = await freePort();
-  const launched = await run(['--no-open'], { KB_SITE_PORT: String(port) });
-  serverPid = endpoint.readEndpoint(data)?.pid;
-  assert.equal(launched.code, 0, launched.stderr);
-  assert.match(launched.stdout, new RegExp(`is ready at http://127.0.0.1:${port}`));
-  assert(serverPid && endpoint.isProcessAlive(serverPid));
-  const response = await fetch(`http://127.0.0.1:${port}/api/state`);
-  assert.equal(response.status, 200, 'ready must mean HTTP is usable, not only a PID exists');
-  const state = await response.json();
-  assert.deepEqual(state.projects, [], 'abandoned sessions must not import projects or enqueue analysis');
-  assert.equal(fs.readFileSync(record, 'utf8'), recordBytes);
-  const again = await run(['--no-open']);
-  assert.equal(again.code, 0);
-  assert.match(again.stdout, /Already running/);
-  const stopped = await run(['stop']);
-  assert.equal(stopped.code, 0);
-  for (let attempt = 0; attempt < 50 && endpoint.isProcessAlive(serverPid); attempt++) await new Promise(resolve => setTimeout(resolve, 100));
-  assert.equal(endpoint.isProcessAlive(serverPid), false);
-  serverPid = null;
-
-  const oldData = path.join(root, 'actual-old-data');
-  fs.mkdirSync(oldData);
-  const original = JSON.stringify({ projectOrder: ['old-project'] });
-  fs.writeFileSync(path.join(oldData, 'projects.json'), original);
-  const failed = await run(['--no-open', '--port', String(port)], { KB_DATA_DIR: oldData });
-  assert.equal(failed.code, 1, 'background failures must return nonzero to the invoking terminal');
-  assert.match(failed.stderr, /启动失败/);
-  assert.match(failed.stderr, /projects\.json/);
-  assert(!/is ready|Listening at/.test(failed.stdout));
-  assert.equal(fs.readFileSync(path.join(oldData, 'projects.json'), 'utf8'), original);
-  assert.equal(fs.existsSync(path.join(oldData, 'product-data.json')), false);
-  const log = fs.readFileSync(path.join(oldData, 'launcher.log'), 'utf8');
-  assert.match(log, /startup failed/);
-  assert(!/Listening at/.test(log), 'never advertise a listener before initialization succeeds');
-  console.log('launcher readiness PASS: unrelated cwd, abandoned records, HTTP readiness, stop, terminal failure, legacy preservation');
-})().catch(error => { console.error(error); process.exitCode = 1; }).finally(() => {
-  if (serverPid && endpoint.readEndpoint(data)?.pid === serverPid) {
-    try { process.kill(serverPid); } catch {}
-  }
-});
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const net = require('node:net');
+const { spawn } = require('node:child_process');
+const endpoint = require('../lib/runtime-endpoint');
+
+const packageRoot = process.env.KB_LAUNCHER_TEST_PACKAGE || path.resolve(__dirname, '../..');
+const bin = path.join(packageRoot, 'bin/project-knowledge.js');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-launcher-readiness-'));
+const data = path.join(root, '.project-knowledge-v5');
+const record = path.join(data, 'runtime/claude-sessions/project-a/session.json');
+const recordBytes = JSON.stringify({ schema: 'claude-workbench-session/v1', sessionId: 'old-test', projectSlug: 'project-a', state: 'running', metadata: { automation: true } });
+fs.mkdirSync(path.dirname(record), { recursive: true });
+fs.writeFileSync(record, recordBytes);
+const env = { ...process.env, KB_DATA_DIR: data, KB_MODULES_AUTOSTART: '0', AI_CODING_EVENT_BRIDGE_HOME: path.join(root, 'bridge') };
+let serverPid;
+
+function run(args, overrides = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [bin, ...args], { cwd: root, env: { ...env, ...overrides }, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    let stdout = '', stderr = '';
+    const timer = setTimeout(() => { child.kill(); reject(new Error(`CLI timed out: ${stdout} ${stderr}`)); }, 25000);
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.once('error', reject);
+    child.once('exit', code => { clearTimeout(timer); resolve({ code, stdout, stderr }); });
+  });
+}
+async function freePort() {
+  const server = net.createServer();
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+  await new Promise(resolve => server.close(resolve));
+  return port;
+}
+
+(async () => {
+  const port = await freePort();
+  const launched = await run(['--no-open'], { KB_SITE_PORT: String(port) });
+  serverPid = endpoint.readEndpoint(data)?.pid;
+  assert.equal(launched.code, 0, launched.stderr);
+  assert.match(launched.stdout, new RegExp(`is ready at http://127.0.0.1:${port}`));
+  assert(serverPid && endpoint.isProcessAlive(serverPid));
+  const response = await fetch(`http://127.0.0.1:${port}/api/state`);
+  assert.equal(response.status, 200, 'ready must mean HTTP is usable, not only a PID exists');
+  const state = await response.json();
+  assert.deepEqual(state.projects, [], 'abandoned sessions must not import projects or enqueue analysis');
+  assert.equal(fs.readFileSync(record, 'utf8'), recordBytes);
+  const again = await run(['--no-open']);
+  assert.equal(again.code, 0);
+  assert.match(again.stdout, /Already running/);
+  const stopped = await run(['stop']);
+  assert.equal(stopped.code, 0);
+  for (let attempt = 0; attempt < 50 && endpoint.isProcessAlive(serverPid); attempt++) await new Promise(resolve => setTimeout(resolve, 100));
+  assert.equal(endpoint.isProcessAlive(serverPid), false);
+  serverPid = null;
+
+  const oldData = path.join(root, 'actual-old-data');
+  fs.mkdirSync(oldData);
+  const original = JSON.stringify({ projectOrder: ['old-project'] });
+  fs.writeFileSync(path.join(oldData, 'projects.json'), original);
+  const failed = await run(['--no-open', '--port', String(port)], { KB_DATA_DIR: oldData });
+  assert.equal(failed.code, 1, 'background failures must return nonzero to the invoking terminal');
+  assert.match(failed.stderr, /启动失败/);
+  assert.match(failed.stderr, /projects\.json/);
+  assert(!/is ready|Listening at/.test(failed.stdout));
+  assert.equal(fs.readFileSync(path.join(oldData, 'projects.json'), 'utf8'), original);
+  assert.equal(fs.existsSync(path.join(oldData, 'product-data.json')), false);
+  const log = fs.readFileSync(path.join(oldData, 'launcher.log'), 'utf8');
+  assert.match(log, /startup failed/);
+  assert(!/Listening at/.test(log), 'never advertise a listener before initialization succeeds');
+  console.log('launcher readiness PASS: unrelated cwd, abandoned records, HTTP readiness, stop, terminal failure, legacy preservation');
+})().catch(error => { console.error(error); process.exitCode = 1; }).finally(() => {
+  if (serverPid && endpoint.readEndpoint(data)?.pid === serverPid) {
+    try { process.kill(serverPid); } catch {}
+  }
+});

package/_site/_test/legacy-claude-session-alias-test.js

@@ -1,106 +1,106 @@
-// Run: node _site/_test/legacy-claude-session-alias-test.js
-
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), `kb-legacy-session-${process.pid}-`));
-const projectId = 'project-stable-id';
-const legacySlug = 'legacy-project-slug';
-const knowledgePath = path.join(dataDir, 'knowledge', legacySlug);
-const metadataPath = path.join(dataDir, 'projects', projectId);
-const now = new Date().toISOString();
-process.env.KB_DATA_DIR = dataDir;
-require('../lib/data-dir')._resetCache();
-
-const { defaultProjectConfig, defaultProjectState } = require('../lib/project-store');
-
-function writeRecord(root, record) {
-  fs.mkdirSync(root, { recursive: true });
-  fs.writeFileSync(path.join(root, `${record.sessionId}.json`), `${JSON.stringify({
-    schema: 'claude-workbench-session/v1',
-    projectPath: dataDir,
-    kbPath: knowledgePath,
-    promptKey: 'post-commit-automation',
-    runner: 'sdk',
-    state: 'idle',
-    model: 'test-model',
-    startedAt: now,
-    endedAt: now,
-    exitCode: 0,
-    turns: 1,
-    pendingPermission: null,
-    updatedAt: now,
-    ...record,
-  }, null, 2)}\n`, 'utf8');
-}
-
-try {
-  fs.mkdirSync(metadataPath, { recursive: true });
-  fs.mkdirSync(knowledgePath, { recursive: true });
-  fs.writeFileSync(path.join(metadataPath, 'config.json'), `${JSON.stringify(defaultProjectConfig(projectId, {
-    displayName: 'Legacy project',
-    storageName: 'legacy-project',
-    repoPath: dataDir,
-    knowledgePath,
-    legacyExtensions: { slug: legacySlug, sourceSchema: 'legacy-v1' },
-  }), null, 2)}\n`, 'utf8');
-  fs.writeFileSync(path.join(metadataPath, 'state.json'), `${JSON.stringify(defaultProjectState(), null, 2)}\n`, 'utf8');
-  fs.writeFileSync(path.join(dataDir, 'projects.json'), `${JSON.stringify({
-    schema: 'project-registry/v2',
-    schemaVersion: 2,
-    projectOrder: [projectId],
-    projects: { [projectId]: { createdAt: now, displayNameSnapshot: 'Legacy project' } },
-    revision: 1,
-    updatedAt: now,
-  }, null, 2)}\n`, 'utf8');
-
-  const legacyRoot = path.join(dataDir, '_ai', legacySlug, 'claude-workbench');
-  const currentRoot = path.join(dataDir, 'runtime', 'claude-sessions', projectId);
-  writeRecord(legacyRoot, {
-    sessionId: 'sess-legacy-only',
-    projectSlug: legacySlug,
-    source: 'git-hook',
-    automation: true,
-    events: [
-      { type: 'claude/user-prompt', text: 'historical hook prompt' },
-      { type: 'claude/result', result: 'historical analysis result' },
-    ],
-  });
-  writeRecord(legacyRoot, {
-    sessionId: 'sess-duplicate',
-    projectSlug: legacySlug,
-    source: 'legacy-copy',
-    events: [{ type: 'claude/result', result: 'legacy duplicate' }],
-  });
-  writeRecord(currentRoot, {
-    sessionId: 'sess-duplicate',
-    projectSlug: projectId,
-    source: 'current-runtime',
-    events: [{ type: 'claude/result', result: 'current duplicate' }],
-  });
-
-  const runner = require('../lib/claude-cli-runner');
-  const listed = runner.listSessions({ projectSlug: projectId });
-  assert.strictEqual(listed.length, 2);
-  const legacy = listed.find(session => session.sessionId === 'sess-legacy-only');
-  assert(legacy, 'legacy alias session must be discoverable under the stable projectId');
-  assert.strictEqual(legacy.projectSlug, projectId);
-  assert.strictEqual(legacy.legacyProjectSlug, legacySlug);
-  assert.strictEqual(legacy.legacySource, true);
-  assert.strictEqual(listed.find(session => session.sessionId === 'sess-duplicate').source, 'current-runtime', 'canonical runtime record must win duplicate IDs');
-
-  const events = [];
-  const unsubscribe = runner.subscribe('sess-legacy-only', event => events.push(event));
-  unsubscribe();
-  assert(events.some(event => event.type === 'claude/user-prompt' && event.text === 'historical hook prompt'));
-  assert(events.some(event => event.type === 'claude/result' && event.result === 'historical analysis result'));
-  assert.strictEqual(runner.getState('sess-legacy-only').projectSlug, projectId);
-  console.log('legacy-claude-session-alias-test PASS');
-} catch (error) {
-  console.error(error.stack || error.message);
-  process.exitCode = 1;
-} finally {
-  fs.rmSync(dataDir, { recursive: true, force: true });
-}
+// Run: node _site/_test/legacy-claude-session-alias-test.js
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), `kb-legacy-session-${process.pid}-`));
+const projectId = 'project-stable-id';
+const legacySlug = 'legacy-project-slug';
+const knowledgePath = path.join(dataDir, 'knowledge', legacySlug);
+const metadataPath = path.join(dataDir, 'projects', projectId);
+const now = new Date().toISOString();
+process.env.KB_DATA_DIR = dataDir;
+require('../lib/data-dir')._resetCache();
+
+const { defaultProjectConfig, defaultProjectState } = require('../lib/project-store');
+
+function writeRecord(root, record) {
+  fs.mkdirSync(root, { recursive: true });
+  fs.writeFileSync(path.join(root, `${record.sessionId}.json`), `${JSON.stringify({
+    schema: 'claude-workbench-session/v1',
+    projectPath: dataDir,
+    kbPath: knowledgePath,
+    promptKey: 'post-commit-automation',
+    runner: 'sdk',
+    state: 'idle',
+    model: 'test-model',
+    startedAt: now,
+    endedAt: now,
+    exitCode: 0,
+    turns: 1,
+    pendingPermission: null,
+    updatedAt: now,
+    ...record,
+  }, null, 2)}\n`, 'utf8');
+}
+
+try {
+  fs.mkdirSync(metadataPath, { recursive: true });
+  fs.mkdirSync(knowledgePath, { recursive: true });
+  fs.writeFileSync(path.join(metadataPath, 'config.json'), `${JSON.stringify(defaultProjectConfig(projectId, {
+    displayName: 'Legacy project',
+    storageName: 'legacy-project',
+    repoPath: dataDir,
+    knowledgePath,
+    legacyExtensions: { slug: legacySlug, sourceSchema: 'legacy-v1' },
+  }), null, 2)}\n`, 'utf8');
+  fs.writeFileSync(path.join(metadataPath, 'state.json'), `${JSON.stringify(defaultProjectState(), null, 2)}\n`, 'utf8');
+  fs.writeFileSync(path.join(dataDir, 'projects.json'), `${JSON.stringify({
+    schema: 'project-registry/v2',
+    schemaVersion: 2,
+    projectOrder: [projectId],
+    projects: { [projectId]: { createdAt: now, displayNameSnapshot: 'Legacy project' } },
+    revision: 1,
+    updatedAt: now,
+  }, null, 2)}\n`, 'utf8');
+
+  const legacyRoot = path.join(dataDir, '_ai', legacySlug, 'claude-workbench');
+  const currentRoot = path.join(dataDir, 'runtime', 'claude-sessions', projectId);
+  writeRecord(legacyRoot, {
+    sessionId: 'sess-legacy-only',
+    projectSlug: legacySlug,
+    source: 'git-hook',
+    automation: true,
+    events: [
+      { type: 'claude/user-prompt', text: 'historical hook prompt' },
+      { type: 'claude/result', result: 'historical analysis result' },
+    ],
+  });
+  writeRecord(legacyRoot, {
+    sessionId: 'sess-duplicate',
+    projectSlug: legacySlug,
+    source: 'legacy-copy',
+    events: [{ type: 'claude/result', result: 'legacy duplicate' }],
+  });
+  writeRecord(currentRoot, {
+    sessionId: 'sess-duplicate',
+    projectSlug: projectId,
+    source: 'current-runtime',
+    events: [{ type: 'claude/result', result: 'current duplicate' }],
+  });
+
+  const runner = require('../lib/claude-cli-runner');
+  const listed = runner.listSessions({ projectSlug: projectId });
+  assert.strictEqual(listed.length, 2);
+  const legacy = listed.find(session => session.sessionId === 'sess-legacy-only');
+  assert(legacy, 'legacy alias session must be discoverable under the stable projectId');
+  assert.strictEqual(legacy.projectSlug, projectId);
+  assert.strictEqual(legacy.legacyProjectSlug, legacySlug);
+  assert.strictEqual(legacy.legacySource, true);
+  assert.strictEqual(listed.find(session => session.sessionId === 'sess-duplicate').source, 'current-runtime', 'canonical runtime record must win duplicate IDs');
+
+  const events = [];
+  const unsubscribe = runner.subscribe('sess-legacy-only', event => events.push(event));
+  unsubscribe();
+  assert(events.some(event => event.type === 'claude/user-prompt' && event.text === 'historical hook prompt'));
+  assert(events.some(event => event.type === 'claude/result' && event.result === 'historical analysis result'));
+  assert.strictEqual(runner.getState('sess-legacy-only').projectSlug, projectId);
+  console.log('legacy-claude-session-alias-test PASS');
+} catch (error) {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+} finally {
+  fs.rmSync(dataDir, { recursive: true, force: true });
+}