@sanqianx/project-knowledge 4.6.1 → 4.8.0

package/_site/_test/conversation-store-test.js

@@ -1,136 +1,136 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { SCHEMAS } = require('../lib/contracts');
-const { StorageLayout } = require('../lib/storage-layout');
-const { ConversationStore, sha256 } = require('../lib/conversation-store');
-
-(async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-conversation-store-'));
-  const dataDir = path.join(root, 'data');
-  const knowledgeRoot = path.join(root, 'knowledge');
-  fs.mkdirSync(knowledgeRoot, { recursive: true });
-  const layout = new StorageLayout({ dataDir });
-  const logRecords = [];
-  const store = new ConversationStore({
-    layout,
-    logger: { async info(event, message, input) { logRecords.push({ event, message, input }); } },
-  });
-  const projectId = 'project-conversation';
-  const eventsPath = layout.getProjectConversationEventsPath(projectId);
-  assert.strictEqual(fs.existsSync(eventsPath), false, 'conversation business data must be lazy-created');
-
-  const privatePrompt = 'Implement secret conversation behavior without logging this body.';
-  const user = {
-    eventId: 'event-user-1',
-    sequence: 10,
-    source: 'codex',
-    eventType: 'user_prompt',
-    role: 'user',
-    content: privatePrompt,
-    sessionId: 'session-1',
-    turnId: 'turn-1',
-    projectPath: path.join(root, 'repo'),
-    repoIdentity: { commonDir: path.join(root, 'repo', '.git') },
-    branch: 'main',
-    headAtCapture: 'a'.repeat(40),
-    capturedAt: '2026-08-18T01:00:00.000Z',
-    rawEventType: 'user-prompt-submit',
-    identityConfidence: 'high',
-    captureStatus: 'captured',
-  };
-  const concurrent = await Promise.all(Array.from({ length: 8 }, () => store.appendEvent(projectId, user)));
-  assert.strictEqual(concurrent.filter(result => result.appended).length, 1, 'eventId dedupe must be atomic under overlap');
-  assert.strictEqual(store.readEvents(projectId).length, 1);
-  assert.strictEqual(store.readEvents(projectId)[0].content, privatePrompt, 'full prompt belongs in the private business store');
-  assert.strictEqual(store.readEvents(projectId)[0].contentHash, sha256(privatePrompt));
-  assert(!JSON.stringify(logRecords).includes(privatePrompt), 'conversation body must never enter structured logs');
-  assert(JSON.stringify(logRecords).includes(sha256(privatePrompt)), 'logs may retain body hash for correlation');
-
-  await assert.rejects(
-    () => store.appendEvent(projectId, { ...user, content: 'different body' }),
-    error => error.code === 'DATA_CORRUPT',
-    'same eventId with different content must never be silently deduplicated',
-  );
-  await store.appendEvent(projectId, {
-    ...user,
-    eventId: 'event-assistant-1',
-    sequence: 11,
-    eventType: 'assistant_response',
-    role: 'assistant',
-    content: 'Implemented and verified.',
-    capturedAt: '2026-08-18T01:01:00.000Z',
-  });
-
-  const legacy = {
-    schema: SCHEMAS.requirement,
-    id: 'req-legacy-1',
-    projectId,
-    ts: '2026-08-18T00:30:00.000Z',
-    client: 'claude',
-    sessionId: 'legacy-session',
-    branch: 'main',
-    headAtRecord: 'b'.repeat(40),
-    requirement: 'Legacy explicit requirement.',
-    requirementHash: sha256('Legacy explicit requirement.'),
-    commitSha: 'c'.repeat(40),
-  };
-  const imported = await store.importLegacyRequirements(projectId, [legacy, legacy]);
-  assert.strictEqual(imported.filter(result => result.appended).length, 1, 'legacy adapter must share eventId dedupe with Bridge events');
-  const legacyEvent = store.readEvents(projectId).find(event => event.legacyRequirementId === legacy.id);
-  assert.strictEqual(legacyEvent.source, 'claude-code');
-  assert.strictEqual(legacyEvent.captureStatus, 'legacy-explicit-adapter');
-  assert.strictEqual(legacyEvent.sequence, null, 'legacy evidence must not invent a Bridge cursor');
-
-  const commitSha = 'd'.repeat(40);
-  const boundary = store.writeBoundary(projectId, {
-    commitSha,
-    repoIdentity: user.repoIdentity,
-    parentShas: ['c'.repeat(40)],
-    branch: 'main',
-    committedAt: '2026-08-18T01:00:30.000Z',
-    bridgeCursorAtCommit: 10,
-    openTurnIdsAtCommit: ['turn-1'],
-    operationId: 'op-boundary-1',
-  });
-  assert.strictEqual(boundary.schema, SCHEMAS.gitCommitBoundary);
-  assert(fs.existsSync(layout.getProjectCommitBoundaryPath(projectId, commitSha)));
-
-  const snapshot = store.writeSnapshot(projectId, {
-    commitSha,
-    repoIdentity: user.repoIdentity,
-    parentSha: 'c'.repeat(40),
-    boundaryStartCursor: 0,
-    boundaryEndCursor: 10,
-    status: 'available',
-    turns: [{
-      turnId: 'turn-1',
-      source: 'codex',
-      sessionId: 'session-1',
-      bindingKind: 'direct',
-      userEvents: [{ eventId: 'event-user-1', sequence: 10, content: privatePrompt, contentHash: sha256(privatePrompt), capturedAt: user.capturedAt }],
-      assistantEvents: [],
-    }],
-    excludedFuturePromptCount: 0,
-    finalizedAt: '2026-08-18T01:02:00.000Z',
-  });
-  assert(snapshot.snapshotHash.startsWith('sha256:'));
-  assert.strictEqual(store.readSnapshot(projectId, commitSha).turns[0].userEvents[0].content, privatePrompt);
-  await assert.rejects(
-    async () => store.writeSnapshot(projectId, { ...snapshot, status: 'ambiguous', finalizedAt: snapshot.finalizedAt }),
-    error => error.code === 'IMMUTABLE_FIELD',
-  );
-  assert(!layout.getProjectCommitConversationPath(projectId, commitSha).startsWith(knowledgeRoot), 'conversation evidence must remain outside the user Markdown root');
-
-  const failingProject = 'project-append-failure';
-  const blocker = layout.getProjectConversationEventsPath(failingProject);
-  fs.mkdirSync(blocker, { recursive: true });
-  await assert.rejects(() => store.appendEvent(failingProject, { ...user, eventId: 'event-fail-1' }));
-  assert.deepStrictEqual(fs.readdirSync(blocker), [], 'failed append must not create partial event data');
-
-  console.log('conversation-store-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 { SCHEMAS } = require('../lib/contracts');
+const { StorageLayout } = require('../lib/storage-layout');
+const { ConversationStore, sha256 } = require('../lib/conversation-store');
+
+(async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-conversation-store-'));
+  const dataDir = path.join(root, 'data');
+  const knowledgeRoot = path.join(root, 'knowledge');
+  fs.mkdirSync(knowledgeRoot, { recursive: true });
+  const layout = new StorageLayout({ dataDir });
+  const logRecords = [];
+  const store = new ConversationStore({
+    layout,
+    logger: { async info(event, message, input) { logRecords.push({ event, message, input }); } },
+  });
+  const projectId = 'project-conversation';
+  const eventsPath = layout.getProjectConversationEventsPath(projectId);
+  assert.strictEqual(fs.existsSync(eventsPath), false, 'conversation business data must be lazy-created');
+
+  const privatePrompt = 'Implement secret conversation behavior without logging this body.';
+  const user = {
+    eventId: 'event-user-1',
+    sequence: 10,
+    source: 'codex',
+    eventType: 'user_prompt',
+    role: 'user',
+    content: privatePrompt,
+    sessionId: 'session-1',
+    turnId: 'turn-1',
+    projectPath: path.join(root, 'repo'),
+    repoIdentity: { commonDir: path.join(root, 'repo', '.git') },
+    branch: 'main',
+    headAtCapture: 'a'.repeat(40),
+    capturedAt: '2026-08-18T01:00:00.000Z',
+    rawEventType: 'user-prompt-submit',
+    identityConfidence: 'high',
+    captureStatus: 'captured',
+  };
+  const concurrent = await Promise.all(Array.from({ length: 8 }, () => store.appendEvent(projectId, user)));
+  assert.strictEqual(concurrent.filter(result => result.appended).length, 1, 'eventId dedupe must be atomic under overlap');
+  assert.strictEqual(store.readEvents(projectId).length, 1);
+  assert.strictEqual(store.readEvents(projectId)[0].content, privatePrompt, 'full prompt belongs in the private business store');
+  assert.strictEqual(store.readEvents(projectId)[0].contentHash, sha256(privatePrompt));
+  assert(!JSON.stringify(logRecords).includes(privatePrompt), 'conversation body must never enter structured logs');
+  assert(JSON.stringify(logRecords).includes(sha256(privatePrompt)), 'logs may retain body hash for correlation');
+
+  await assert.rejects(
+    () => store.appendEvent(projectId, { ...user, content: 'different body' }),
+    error => error.code === 'DATA_CORRUPT',
+    'same eventId with different content must never be silently deduplicated',
+  );
+  await store.appendEvent(projectId, {
+    ...user,
+    eventId: 'event-assistant-1',
+    sequence: 11,
+    eventType: 'assistant_response',
+    role: 'assistant',
+    content: 'Implemented and verified.',
+    capturedAt: '2026-08-18T01:01:00.000Z',
+  });
+
+  const legacy = {
+    schema: SCHEMAS.requirement,
+    id: 'req-legacy-1',
+    projectId,
+    ts: '2026-08-18T00:30:00.000Z',
+    client: 'claude',
+    sessionId: 'legacy-session',
+    branch: 'main',
+    headAtRecord: 'b'.repeat(40),
+    requirement: 'Legacy explicit requirement.',
+    requirementHash: sha256('Legacy explicit requirement.'),
+    commitSha: 'c'.repeat(40),
+  };
+  const imported = await store.importLegacyRequirements(projectId, [legacy, legacy]);
+  assert.strictEqual(imported.filter(result => result.appended).length, 1, 'legacy adapter must share eventId dedupe with Bridge events');
+  const legacyEvent = store.readEvents(projectId).find(event => event.legacyRequirementId === legacy.id);
+  assert.strictEqual(legacyEvent.source, 'claude-code');
+  assert.strictEqual(legacyEvent.captureStatus, 'legacy-explicit-adapter');
+  assert.strictEqual(legacyEvent.sequence, null, 'legacy evidence must not invent a Bridge cursor');
+
+  const commitSha = 'd'.repeat(40);
+  const boundary = store.writeBoundary(projectId, {
+    commitSha,
+    repoIdentity: user.repoIdentity,
+    parentShas: ['c'.repeat(40)],
+    branch: 'main',
+    committedAt: '2026-08-18T01:00:30.000Z',
+    bridgeCursorAtCommit: 10,
+    openTurnIdsAtCommit: ['turn-1'],
+    operationId: 'op-boundary-1',
+  });
+  assert.strictEqual(boundary.schema, SCHEMAS.gitCommitBoundary);
+  assert(fs.existsSync(layout.getProjectCommitBoundaryPath(projectId, commitSha)));
+
+  const snapshot = store.writeSnapshot(projectId, {
+    commitSha,
+    repoIdentity: user.repoIdentity,
+    parentSha: 'c'.repeat(40),
+    boundaryStartCursor: 0,
+    boundaryEndCursor: 10,
+    status: 'available',
+    turns: [{
+      turnId: 'turn-1',
+      source: 'codex',
+      sessionId: 'session-1',
+      bindingKind: 'direct',
+      userEvents: [{ eventId: 'event-user-1', sequence: 10, content: privatePrompt, contentHash: sha256(privatePrompt), capturedAt: user.capturedAt }],
+      assistantEvents: [],
+    }],
+    excludedFuturePromptCount: 0,
+    finalizedAt: '2026-08-18T01:02:00.000Z',
+  });
+  assert(snapshot.snapshotHash.startsWith('sha256:'));
+  assert.strictEqual(store.readSnapshot(projectId, commitSha).turns[0].userEvents[0].content, privatePrompt);
+  await assert.rejects(
+    async () => store.writeSnapshot(projectId, { ...snapshot, status: 'ambiguous', finalizedAt: snapshot.finalizedAt }),
+    error => error.code === 'IMMUTABLE_FIELD',
+  );
+  assert(!layout.getProjectCommitConversationPath(projectId, commitSha).startsWith(knowledgeRoot), 'conversation evidence must remain outside the user Markdown root');
+
+  const failingProject = 'project-append-failure';
+  const blocker = layout.getProjectConversationEventsPath(failingProject);
+  fs.mkdirSync(blocker, { recursive: true });
+  await assert.rejects(() => store.appendEvent(failingProject, { ...user, eventId: 'event-fail-1' }));
+  assert.deepStrictEqual(fs.readdirSync(blocker), [], 'failed append must not create partial event data');
+
+  console.log('conversation-store-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/_site/_test/cross-repo-isolation-e2e-test.js

@@ -18,8 +18,8 @@ const { ConversationStore } = require('../lib/conversation-store');
 const { BridgeAdapter } = require('../lib/bridge-adapter');
 const { BridgeConsumerService } = require('../lib/bridge-consumer-service');
 const { CommitConversationBinder } = require('../lib/commit-conversation-binder');
-const claudeConnector = require('@sanqianx/ai-coding-event-bridge').claudeHookEntry;
-const bridgeModule = require('@sanqianx/ai-coding-event-bridge');
+const claudeConnector = require('@sanqianx/ai-coding-event-bridge-console/src/bridge').claudeHookEntry;
+const bridgeModule = require('@sanqianx/ai-coding-event-bridge-console/src/bridge');
 
 const temp = fs.mkdtempSync(path.join(os.tmpdir(), `kb-cross-repo-e2e-${process.pid}-`));
 const layout = new StorageLayout({ dataDir: path.join(temp, 'data') });

package/_site/_test/data-dir-migration-test.js

@@ -1,60 +1,60 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const dataDir = require('../lib/data-dir');
-const { LEGACY_ASSETS } = require('../lib/legacy-data-manifest');
-
-function temp(name) { return fs.mkdtempSync(path.join(os.tmpdir(), `pk-data-dir-${name}-`)); }
-function clean(dir) { fs.rmSync(dir, { recursive: true, force: true }); }
-function write(file, value = '{}') { fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, value); }
-
-(() => {
-  // Resolution must be diagnostic-safe: resolving never creates the candidate.
-  const missing = path.join(temp('resolve'), 'not-created');
-  try {
-    assert.equal(dataDir.resolveDataDirPath({ dataDir: missing }), path.resolve(missing));
-    assert.equal(fs.existsSync(missing), false);
-    dataDir.ensureDataDir(missing);
-    assert.equal(fs.existsSync(missing), true);
-  } finally { clean(path.dirname(missing)); }
-
-  const legacy = temp('legacy');
-  const target = temp('target');
-  const saved = process.env.KB_DATA_DIR;
-  try {
-    write(path.join(legacy, 'projects.json'), JSON.stringify({ old: { repoPath: 'C:/legacy' } }));
-    write(path.join(legacy, 'ai-profiles.json'), JSON.stringify({ profiles: [{ id: 'primary', apiKey: 'test-secret' }] }));
-    write(path.join(legacy, 'knowledge-store.json'), JSON.stringify({ rootPath: 'C:/knowledge' }));
-    write(path.join(legacy, 'embedding-config.json'), JSON.stringify({ modelId: 'model', localModelPath: 'C:/models', localFilesOnly: true }));
-    write(path.join(legacy, 'knowledge-scopes.json'), JSON.stringify({ scopes: ['p'] }));
-    write(path.join(legacy, 'models', 'nested', 'model.onnx'), 'model-bytes');
-    // An empty target registry is non-authoritative and must not suppress legacy data.
-    write(path.join(target, 'projects.json'), '{}');
-    process.env.KB_DATA_DIR = target;
-    dataDir._resetCache();
-    const result = dataDir.migrateFromLegacy({ legacyRoot: legacy });
-    assert.equal(result.ok, true);
-    assert.equal(result.migrated, true);
-    assert.equal(JSON.parse(fs.readFileSync(path.join(target, 'projects.json'))).old.repoPath, 'C:/legacy');
-    assert.equal(JSON.parse(fs.readFileSync(path.join(target, 'ai-profiles.json'))).profiles.length, 1);
-    assert.equal(JSON.parse(fs.readFileSync(path.join(target, 'embedding-config.json'))).modelId, 'model');
-    assert.equal(fs.readFileSync(path.join(target, 'models', 'nested', 'model.onnx'), 'utf8'), 'model-bytes');
-    assert(LEGACY_ASSETS.some(asset => asset.source === 'embedding-config.json'));
-    assert(LEGACY_ASSETS.some(asset => asset.source === 'models'));
-  } finally { process.env.KB_DATA_DIR = saved; dataDir._resetCache(); clean(legacy); clean(target); }
-
-  const source = temp('conflict-source');
-  const destination = temp('conflict-destination');
-  try {
-    write(path.join(source, 'projects.json'), JSON.stringify({ old: { repoPath: 'C:/old' } }));
-    write(path.join(destination, 'projects.json'), JSON.stringify({ newer: { repoPath: 'C:/new' } }));
-    process.env.KB_DATA_DIR = destination;
-    dataDir._resetCache();
-    const result = dataDir.migrateFromLegacy({ legacyRoot: source });
-    assert.equal(result.ok, false);
-    assert.equal(result.requiresManualRecovery, true);
-    assert.equal(JSON.parse(fs.readFileSync(path.join(destination, 'projects.json'))).newer.repoPath, 'C:/new');
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const dataDir = require('../lib/data-dir');
+const { LEGACY_ASSETS } = require('../lib/legacy-data-manifest');
+
+function temp(name) { return fs.mkdtempSync(path.join(os.tmpdir(), `pk-data-dir-${name}-`)); }
+function clean(dir) { fs.rmSync(dir, { recursive: true, force: true }); }
+function write(file, value = '{}') { fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, value); }
+
+(() => {
+  // Resolution must be diagnostic-safe: resolving never creates the candidate.
+  const missing = path.join(temp('resolve'), 'not-created');
+  try {
+    assert.equal(dataDir.resolveDataDirPath({ dataDir: missing }), path.resolve(missing));
+    assert.equal(fs.existsSync(missing), false);
+    dataDir.ensureDataDir(missing);
+    assert.equal(fs.existsSync(missing), true);
+  } finally { clean(path.dirname(missing)); }
+
+  const legacy = temp('legacy');
+  const target = temp('target');
+  const saved = process.env.KB_DATA_DIR;
+  try {
+    write(path.join(legacy, 'projects.json'), JSON.stringify({ old: { repoPath: 'C:/legacy' } }));
+    write(path.join(legacy, 'ai-profiles.json'), JSON.stringify({ profiles: [{ id: 'primary', apiKey: 'test-secret' }] }));
+    write(path.join(legacy, 'knowledge-store.json'), JSON.stringify({ rootPath: 'C:/knowledge' }));
+    write(path.join(legacy, 'embedding-config.json'), JSON.stringify({ modelId: 'model', localModelPath: 'C:/models', localFilesOnly: true }));
+    write(path.join(legacy, 'knowledge-scopes.json'), JSON.stringify({ scopes: ['p'] }));
+    write(path.join(legacy, 'models', 'nested', 'model.onnx'), 'model-bytes');
+    // An empty target registry is non-authoritative and must not suppress legacy data.
+    write(path.join(target, 'projects.json'), '{}');
+    process.env.KB_DATA_DIR = target;
+    dataDir._resetCache();
+    const result = dataDir.migrateFromLegacy({ legacyRoot: legacy });
+    assert.equal(result.ok, true);
+    assert.equal(result.migrated, true);
+    assert.equal(JSON.parse(fs.readFileSync(path.join(target, 'projects.json'))).old.repoPath, 'C:/legacy');
+    assert.equal(JSON.parse(fs.readFileSync(path.join(target, 'ai-profiles.json'))).profiles.length, 1);
+    assert.equal(JSON.parse(fs.readFileSync(path.join(target, 'embedding-config.json'))).modelId, 'model');
+    assert.equal(fs.readFileSync(path.join(target, 'models', 'nested', 'model.onnx'), 'utf8'), 'model-bytes');
+    assert(LEGACY_ASSETS.some(asset => asset.source === 'embedding-config.json'));
+    assert(LEGACY_ASSETS.some(asset => asset.source === 'models'));
+  } finally { process.env.KB_DATA_DIR = saved; dataDir._resetCache(); clean(legacy); clean(target); }
+
+  const source = temp('conflict-source');
+  const destination = temp('conflict-destination');
+  try {
+    write(path.join(source, 'projects.json'), JSON.stringify({ old: { repoPath: 'C:/old' } }));
+    write(path.join(destination, 'projects.json'), JSON.stringify({ newer: { repoPath: 'C:/new' } }));
+    process.env.KB_DATA_DIR = destination;
+    dataDir._resetCache();
+    const result = dataDir.migrateFromLegacy({ legacyRoot: source });
+    assert.equal(result.ok, false);
+    assert.equal(result.requiresManualRecovery, true);
+    assert.equal(JSON.parse(fs.readFileSync(path.join(destination, 'projects.json'))).newer.repoPath, 'C:/new');
   } finally { process.env.KB_DATA_DIR = saved; dataDir._resetCache(); clean(source); clean(destination); }
 
   // The installed package can contain empty scaffolding directories (for

package/_site/_test/desktop-browser-compat-test.js

@@ -1,28 +1,28 @@
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const ui = fs.readFileSync(path.join(ROOT, 'ui', 'index.html'), 'utf8');
-const app = fs.readFileSync(path.join(ROOT, 'ui', 'app.js'), 'utf8');
-const css = fs.readFileSync(path.join(ROOT, 'ui', 'app.css'), 'utf8');
-const preload = fs.readFileSync(path.join(ROOT, 'desktop', 'preload.cjs'), 'utf8');
-const main = fs.readFileSync(path.join(ROOT, 'desktop', 'main.cjs'), 'utf8');
-const runtime = require(path.join(ROOT, 'desktop', 'lib', 'backend-runtime.cjs'));
-
-assert(ui.includes('<script src="/app.js"></script>'), 'product shell script is missing');
-assert.doesNotThrow(() => new Function(app), 'product shell must parse in the desktop Chromium runtime');
-assert(!app.includes('window.open('), 'product shell must not open untrusted browser windows');
-assert(!(ui + app).includes('file://'), 'product shell must not expose local file URLs');
-assert(app.includes('URL.createObjectURL(blob)') && app.includes('URL.revokeObjectURL(url)'), 'diagnostic export must use a bounded blob URL');
-assert(app.includes('navigator.clipboard') && app.includes("document.execCommand('copy')"), 'copy must have a desktop-compatible fallback');
-assert(css.includes('@media(prefers-reduced-motion:reduce)'), 'reduced-motion compatibility is required');
-assert(css.includes('@media(max-width:760px)'), 'desktop narrow-window layout is required');
-
-assert(preload.includes('project-knowledge:open-external') && preload.includes('openExternal:'), 'desktop preload bounded external-link bridge regressed');
-assert(main.includes('externalLink.registerExternalLink'), 'desktop main external-link policy regressed');
-assert(runtime.isAllowedExternalUrl('https://github.com/login/device'), 'HTTPS authorization URL policy regressed');
-assert(!runtime.isAllowedExternalUrl('file:///C:/Users/test/token.txt'), 'local files must not cross the desktop boundary');
-assert(!runtime.isAllowedExternalUrl('javascript:alert(1)'), 'script URLs must not cross the desktop boundary');
-
-console.log('desktop browser compatibility test PASS');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const ui = fs.readFileSync(path.join(ROOT, 'ui', 'index.html'), 'utf8');
+const app = fs.readFileSync(path.join(ROOT, 'ui', 'product.js'), 'utf8');
+const css = fs.readFileSync(path.join(ROOT, 'ui', 'product.css'), 'utf8');
+const preload = fs.readFileSync(path.join(ROOT, 'desktop', 'preload.cjs'), 'utf8');
+const main = fs.readFileSync(path.join(ROOT, 'desktop', 'main.cjs'), 'utf8');
+const runtime = require(path.join(ROOT, 'desktop', 'lib', 'backend-runtime.cjs'));
+
+assert(ui.includes('<script src="/product.js"></script>'), 'product shell script is missing');
+assert.doesNotThrow(() => new Function(app), 'product shell must parse in the desktop Chromium runtime');
+assert(!app.includes('window.open('), 'product shell must not open untrusted browser windows');
+assert(!(ui + app).includes('file://'), 'product shell must not expose local file URLs');
+assert(app.includes('URL.createObjectURL(blob)') && app.includes('URL.revokeObjectURL(url)'), 'diagnostic export must use a bounded blob URL');
+assert(app.includes('navigator.clipboard') && app.includes("document.execCommand('copy')"), 'copy must have a desktop-compatible fallback');
+assert(css.includes('@media(prefers-reduced-motion:reduce)'), 'reduced-motion compatibility is required');
+assert(css.includes('grid-template-columns:232px minmax(0,1fr)') && css.includes('min-width:0'), 'desktop shell must bound its content layout');
+
+assert(preload.includes('project-knowledge:open-external') && preload.includes('openExternal:'), 'desktop preload bounded external-link bridge regressed');
+assert(main.includes('externalLink.registerExternalLink'), 'desktop main external-link policy regressed');
+assert(runtime.isAllowedExternalUrl('https://github.com/login/device'), 'HTTPS authorization URL policy regressed');
+assert(!runtime.isAllowedExternalUrl('file:///C:/Users/test/token.txt'), 'local files must not cross the desktop boundary');
+assert(!runtime.isAllowedExternalUrl('javascript:alert(1)'), 'script URLs must not cross the desktop boundary');
+
+console.log('desktop browser compatibility test PASS');