@sanqianx/project-knowledge 4.7.0 → 4.8.0

package/_site/_test/index-writer-concurrency-test.js

@@ -1,135 +1,135 @@
-// Run: node _site/_test/index-writer-concurrency-test.js
-
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { StorageLayout } = require('../lib/storage-layout');
-const { ProjectRegistryStore } = require('../lib/project-registry-store');
-const { ProjectStore } = require('../lib/project-store');
-const { IndexService } = require('../lib/index-service');
-
-const temp = fs.mkdtempSync(path.join(os.tmpdir(), `kb-index-writer-${process.pid}-`));
-const layout = new StorageLayout({ dataDir: path.join(temp, 'data') });
-const registry = new ProjectRegistryStore({ layout });
-const projects = new ProjectStore({ layout });
-
-async function addProject(projectId) {
-  const knowledgePath = path.join(temp, 'knowledge', projectId);
-  fs.mkdirSync(knowledgePath, { recursive: true });
-  fs.writeFileSync(path.join(knowledgePath, 'README.md'), `# ${projectId}\n\nMarkdown remains authoritative.\n`, 'utf8');
-  await projects.create(projectId, {
-    displayName: projectId,
-    storageName: projectId,
-    repoPath: path.join(temp, 'repos', projectId),
-    knowledgePath,
-  });
-  await registry.add(projectId, { displayName: projectId });
-  await markDirty(projectId, `commit-${projectId}`);
-}
-
-async function markDirty(projectId, commitSha) {
-  await projects.updateState(projectId, state => {
-    state.index.dirty = true;
-    state.index.sinceCommit = state.index.sinceCommit || commitSha;
-    state.index.generation += 1;
-  });
-}
-
-(async () => {
-  await registry.initialize();
-  await addProject('project-a');
-  await addProject('project-b');
-  let active = 0;
-  let maxActive = 0;
-  const calls = [];
-  let releaseFirst;
-  let firstStarted;
-  const firstStart = new Promise(resolve => { firstStarted = resolve; });
-  const firstGate = new Promise(resolve => { releaseFirst = resolve; });
-  const adapter = {
-    async indexProject(input) {
-      active += 1;
-      maxActive = Math.max(maxActive, active);
-      calls.push({ projectId: input.projectId, generation: input.generation });
-      if (input.projectId === 'project-a' && calls.filter(call => call.projectId === 'project-a').length === 1) {
-        firstStarted();
-        await firstGate;
-      }
-      await new Promise(resolve => setTimeout(resolve, 20));
-      active -= 1;
-      return { indexed: true };
-    },
-  };
-  const service = new IndexService({ layout, registryStore: registry, projectStore: projects, adapter });
-  const firstA = service.enqueue('project-a');
-  await firstStart;
-  await markDirty('project-a', 'commit-new-during-index');
-  const coalescedA = service.enqueue('project-a');
-  const firstB = service.enqueue('project-b');
-  releaseFirst();
-  await Promise.all([firstA, coalescedA, firstB]);
-  assert.strictEqual(maxActive, 1, 'all index mutations must share one process-global writer');
-  assert.strictEqual(calls.filter(call => call.projectId === 'project-a').length, 2, 'new generation during an old write must be indexed again');
-  assert.strictEqual(projects.readState('project-a').index.dirty, false);
-  assert.strictEqual(projects.readState('project-b').index.dirty, false);
-  const sourceManifest = JSON.parse(fs.readFileSync(layout.getRuntimePath('index-sources', 'project-a.json'), 'utf8'));
-  assert.strictEqual(sourceManifest.schema, 'knowledge-index-source-manifest/v1');
-  assert(sourceManifest.entries['README.md'].documentHash, 'successful indexing must persist the authoritative source document hash');
-  assert.strictEqual(sourceManifest.generation, projects.readState('project-a').index.generation);
-
-  await markDirty('project-b', 'commit-index-failure');
-  let fail = true;
-  const retryService = new IndexService({
-    layout,
-    registryStore: registry,
-    projectStore: projects,
-    adapter: {
-      indexProject: async () => {
-        if (fail) { fail = false; throw new Error('injected index failure'); }
-        return { indexed: true };
-      },
-    },
-  });
-  const failed = await retryService.enqueue('project-b');
-  assert.strictEqual(failed.ok, false);
-  const failedState = projects.readState('project-b');
-  assert.strictEqual(failedState.index.dirty, true, 'index failure must keep dirty state');
-  assert(failedState.index.lastError && failedState.index.lastError.message.includes('injected'));
-  assert(fs.existsSync(path.join(projects.readConfig('project-b').knowledgePath, 'README.md')), 'index failure must not remove truthful Markdown');
-  const retried = await retryService.enqueue('project-b');
-  assert.strictEqual(retried.ok, true);
-  assert.strictEqual(projects.readState('project-b').index.dirty, false);
-
-  const indexPath = layout.getIndexPath();
-  fs.mkdirSync(indexPath, { recursive: true });
-  fs.writeFileSync(path.join(indexPath, 'marker.txt'), 'old-index', 'utf8');
-  let validationOk = false;
-  const rebuildService = new IndexService({
-    layout,
-    registryStore: registry,
-    projectStore: projects,
-    adapter: {
-      indexProject: async () => ({}),
-      buildFull: async ({ targetPath }) => {
-        fs.mkdirSync(targetPath, { recursive: true });
-        fs.writeFileSync(path.join(targetPath, 'marker.txt'), 'new-index', 'utf8');
-      },
-      validateIndex: async targetPath => ({ ok: validationOk, marker: fs.readFileSync(path.join(targetPath, 'marker.txt'), 'utf8') }),
-    },
-  });
-  await assert.rejects(rebuildService.fullRebuild(), error => error.code === 'DATA_CORRUPT');
-  assert.strictEqual(fs.readFileSync(path.join(indexPath, 'marker.txt'), 'utf8'), 'old-index', 'failed rebuild validation must retain the live DB');
-  validationOk = true;
-  const rebuilt = await rebuildService.fullRebuild();
-  assert.strictEqual(fs.readFileSync(path.join(indexPath, 'marker.txt'), 'utf8'), 'new-index');
-  assert(rebuilt.backup && fs.readFileSync(path.join(rebuilt.backup, 'marker.txt'), 'utf8') === 'old-index', 'successful swap should retain a recovery copy of the old DB');
-
-  await IndexService.flush();
-  console.log('index-writer-concurrency-test PASS');
-})().catch(error => {
-  console.error(error.stack || error.message);
-  process.exitCode = 1;
-}).finally(() => {
-  fs.rmSync(temp, { recursive: true, force: true });
-});
+// Run: node _site/_test/index-writer-concurrency-test.js
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { StorageLayout } = require('../lib/storage-layout');
+const { ProjectRegistryStore } = require('../lib/project-registry-store');
+const { ProjectStore } = require('../lib/project-store');
+const { IndexService } = require('../lib/index-service');
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), `kb-index-writer-${process.pid}-`));
+const layout = new StorageLayout({ dataDir: path.join(temp, 'data') });
+const registry = new ProjectRegistryStore({ layout });
+const projects = new ProjectStore({ layout });
+
+async function addProject(projectId) {
+  const knowledgePath = path.join(temp, 'knowledge', projectId);
+  fs.mkdirSync(knowledgePath, { recursive: true });
+  fs.writeFileSync(path.join(knowledgePath, 'README.md'), `# ${projectId}\n\nMarkdown remains authoritative.\n`, 'utf8');
+  await projects.create(projectId, {
+    displayName: projectId,
+    storageName: projectId,
+    repoPath: path.join(temp, 'repos', projectId),
+    knowledgePath,
+  });
+  await registry.add(projectId, { displayName: projectId });
+  await markDirty(projectId, `commit-${projectId}`);
+}
+
+async function markDirty(projectId, commitSha) {
+  await projects.updateState(projectId, state => {
+    state.index.dirty = true;
+    state.index.sinceCommit = state.index.sinceCommit || commitSha;
+    state.index.generation += 1;
+  });
+}
+
+(async () => {
+  await registry.initialize();
+  await addProject('project-a');
+  await addProject('project-b');
+  let active = 0;
+  let maxActive = 0;
+  const calls = [];
+  let releaseFirst;
+  let firstStarted;
+  const firstStart = new Promise(resolve => { firstStarted = resolve; });
+  const firstGate = new Promise(resolve => { releaseFirst = resolve; });
+  const adapter = {
+    async indexProject(input) {
+      active += 1;
+      maxActive = Math.max(maxActive, active);
+      calls.push({ projectId: input.projectId, generation: input.generation });
+      if (input.projectId === 'project-a' && calls.filter(call => call.projectId === 'project-a').length === 1) {
+        firstStarted();
+        await firstGate;
+      }
+      await new Promise(resolve => setTimeout(resolve, 20));
+      active -= 1;
+      return { indexed: true };
+    },
+  };
+  const service = new IndexService({ layout, registryStore: registry, projectStore: projects, adapter });
+  const firstA = service.enqueue('project-a');
+  await firstStart;
+  await markDirty('project-a', 'commit-new-during-index');
+  const coalescedA = service.enqueue('project-a');
+  const firstB = service.enqueue('project-b');
+  releaseFirst();
+  await Promise.all([firstA, coalescedA, firstB]);
+  assert.strictEqual(maxActive, 1, 'all index mutations must share one process-global writer');
+  assert.strictEqual(calls.filter(call => call.projectId === 'project-a').length, 2, 'new generation during an old write must be indexed again');
+  assert.strictEqual(projects.readState('project-a').index.dirty, false);
+  assert.strictEqual(projects.readState('project-b').index.dirty, false);
+  const sourceManifest = JSON.parse(fs.readFileSync(layout.getRuntimePath('index-sources', 'project-a.json'), 'utf8'));
+  assert.strictEqual(sourceManifest.schema, 'knowledge-index-source-manifest/v1');
+  assert(sourceManifest.entries['README.md'].documentHash, 'successful indexing must persist the authoritative source document hash');
+  assert.strictEqual(sourceManifest.generation, projects.readState('project-a').index.generation);
+
+  await markDirty('project-b', 'commit-index-failure');
+  let fail = true;
+  const retryService = new IndexService({
+    layout,
+    registryStore: registry,
+    projectStore: projects,
+    adapter: {
+      indexProject: async () => {
+        if (fail) { fail = false; throw new Error('injected index failure'); }
+        return { indexed: true };
+      },
+    },
+  });
+  const failed = await retryService.enqueue('project-b');
+  assert.strictEqual(failed.ok, false);
+  const failedState = projects.readState('project-b');
+  assert.strictEqual(failedState.index.dirty, true, 'index failure must keep dirty state');
+  assert(failedState.index.lastError && failedState.index.lastError.message.includes('injected'));
+  assert(fs.existsSync(path.join(projects.readConfig('project-b').knowledgePath, 'README.md')), 'index failure must not remove truthful Markdown');
+  const retried = await retryService.enqueue('project-b');
+  assert.strictEqual(retried.ok, true);
+  assert.strictEqual(projects.readState('project-b').index.dirty, false);
+
+  const indexPath = layout.getIndexPath();
+  fs.mkdirSync(indexPath, { recursive: true });
+  fs.writeFileSync(path.join(indexPath, 'marker.txt'), 'old-index', 'utf8');
+  let validationOk = false;
+  const rebuildService = new IndexService({
+    layout,
+    registryStore: registry,
+    projectStore: projects,
+    adapter: {
+      indexProject: async () => ({}),
+      buildFull: async ({ targetPath }) => {
+        fs.mkdirSync(targetPath, { recursive: true });
+        fs.writeFileSync(path.join(targetPath, 'marker.txt'), 'new-index', 'utf8');
+      },
+      validateIndex: async targetPath => ({ ok: validationOk, marker: fs.readFileSync(path.join(targetPath, 'marker.txt'), 'utf8') }),
+    },
+  });
+  await assert.rejects(rebuildService.fullRebuild(), error => error.code === 'DATA_CORRUPT');
+  assert.strictEqual(fs.readFileSync(path.join(indexPath, 'marker.txt'), 'utf8'), 'old-index', 'failed rebuild validation must retain the live DB');
+  validationOk = true;
+  const rebuilt = await rebuildService.fullRebuild();
+  assert.strictEqual(fs.readFileSync(path.join(indexPath, 'marker.txt'), 'utf8'), 'new-index');
+  assert(rebuilt.backup && fs.readFileSync(path.join(rebuilt.backup, 'marker.txt'), 'utf8') === 'old-index', 'successful swap should retain a recovery copy of the old DB');
+
+  await IndexService.flush();
+  console.log('index-writer-concurrency-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+}).finally(() => {
+  fs.rmSync(temp, { recursive: true, force: true });
+});

package/_site/_test/integration-adapters-test.js

@@ -1,134 +1,134 @@
-// Run: node _site/_test/integration-adapters-test.js
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const {
-  IntegrationManager,
-  removeOpenCodeMcpConfig,
-  removeOpenCodeInstructionConfig,
-} = require('../lib/integration-installer');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const TEMP = fs.mkdtempSync(path.join(os.tmpdir(), `project-knowledge-integrations-${process.pid}-`));
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-}
-
-async function main() {
-  const packageInfo = readJson(path.join(ROOT, 'package.json'));
-  const pluginRoot = path.join(ROOT, 'plugins', 'project-knowledge');
-  const claudeManifest = readJson(path.join(pluginRoot, '.claude-plugin', 'plugin.json'));
-  const codexManifest = readJson(path.join(pluginRoot, '.codex-plugin', 'plugin.json'));
-  const mcpManifest = readJson(path.join(pluginRoot, '.mcp.json'));
-  const claudeMarketplace = readJson(path.join(ROOT, '.claude-plugin', 'marketplace.json'));
-  const codexMarketplace = readJson(path.join(ROOT, '.agents', 'plugins', 'marketplace.json'));
-  const skillPath = path.join(pluginRoot, 'skills', 'project-knowledge', 'SKILL.md');
-  const skill = fs.readFileSync(skillPath, 'utf8');
-
-  assert(claudeManifest.version === packageInfo.version, 'Claude plugin version should match the npm package');
-  assert(codexManifest.version === packageInfo.version, 'Codex plugin version should match the npm package');
-  assert(claudeMarketplace.plugins[0].version === packageInfo.version, 'Claude marketplace version should match the npm package');
-  assert(codexMarketplace.name === 'project-knowledge', 'Codex marketplace should have a stable public name');
-  assert(codexMarketplace.plugins[0].source.path === './plugins/project-knowledge', 'Codex marketplace should point at the shared plugin');
-  assert(mcpManifest.mcpServers['project-knowledge'].args.includes(`project-knowledge@${packageInfo.version}`), 'plugin MCP should pin the matching package version');
-  assert(!skill.includes('[TODO:'), 'bundled Skill should not contain scaffold placeholders');
-  assert(skill.includes('project_knowledge_resolve'), 'bundled Skill should teach the resolve-first workflow');
-  assert(skill.includes('project_knowledge_record_requirement'), 'bundled Skill should document the explicit supplemental adapter');
-  assert(skill.includes('only when the user explicitly requests supplemental capture'), 'bundled Skill must not make cooperative requirement recording mandatory');
-  assert(!/Before implementing a user request, call `project_knowledge_record_requirement`/.test(skill), 'automatic capture must remain primary');
-
-  const calls = [];
-  const homeDir = path.join(TEMP, 'home');
-  const manager = new IntegrationManager({
-    rootDir: ROOT,
-    homeDir,
-    env: {},
-    commandResolver: name => name,
-    runner: (command, args) => {
-      calls.push({ command, args });
-      return { status: 0, stdout: '', stderr: '' };
-    },
-  });
-  const openCodeResult = await manager.operate('install', ['opencode']);
-  assert(openCodeResult[0].ok, 'OpenCode installation should complete');
-  assert(fs.existsSync(path.join(homeDir, '.config', 'opencode', 'skills', 'project-knowledge', 'SKILL.md')), 'OpenCode should receive the global Skill');
-  const installedInstruction = path.join(homeDir, '.config', 'opencode', 'instructions', 'project-knowledge.md');
-  assert(fs.existsSync(installedInstruction), 'OpenCode should receive the global Instructions file');
-  const installedConfig = fs.readFileSync(path.join(homeDir, '.config', 'opencode', 'opencode.jsonc'), 'utf8');
-  assert(installedConfig.includes(installedInstruction.replace(/\\/g, '\\\\')), 'OpenCode config should reference the installed Instructions file');
-  const openCodeCall = calls.find(call => call.command === 'opencode');
-  assert(openCodeCall?.args.join(' ') === `mcp add project-knowledge -- npx -y --package project-knowledge@${packageInfo.version} project-knowledge-mcp`, 'OpenCode should receive the versioned MCP command');
-
-  const configDir = path.join(TEMP, 'opencode-config');
-  fs.mkdirSync(configDir, { recursive: true });
-  const configPath = path.join(configDir, 'opencode.jsonc');
-  fs.writeFileSync(configPath, `{
-  // Keep this user comment.
-  "instructions": [
-    "C:\\\\keep\\\\team-rules.md",
-    "${path.join(configDir, 'instructions', 'project-knowledge.md').replace(/\\/g, '\\\\')}"
-  ],
-  "mcp": {
-    "project-knowledge": { "type": "local", "command": ["npx"] },
-    "other": { "type": "remote", "url": "https://example.test/mcp" }
-  }
-}
-`, 'utf8');
-  assert(removeOpenCodeMcpConfig(configDir), 'OpenCode uninstall should remove its MCP entry');
-  const updatedConfig = fs.readFileSync(configPath, 'utf8');
-  assert(updatedConfig.includes('Keep this user comment'), 'OpenCode config comments should be preserved');
-  assert(updatedConfig.includes('"other"'), 'uninstall should preserve unrelated MCP servers');
-  assert(!updatedConfig.includes('"project-knowledge"'), 'uninstall should remove only the Project Knowledge MCP');
-  const instructionPath = path.join(configDir, 'instructions', 'project-knowledge.md');
-  assert(removeOpenCodeInstructionConfig(configDir, instructionPath), 'OpenCode uninstall should remove its Instructions reference');
-  const instructionUpdated = fs.readFileSync(configPath, 'utf8');
-  assert(instructionUpdated.includes('team-rules.md'), 'uninstall should preserve unrelated OpenCode instructions');
-  assert(!instructionUpdated.includes(instructionPath.replace(/\\/g, '\\\\')), 'uninstall should remove only its Instructions reference');
-
-  const claudeCalls = [];
-  const claudeManager = new IntegrationManager({
-    rootDir: ROOT,
-    commandResolver: name => name,
-    runner: (command, args) => {
-      claudeCalls.push({ command, args });
-      if (args.join(' ') === 'plugin marketplace list --json') return { status: 0, stdout: '[]', stderr: '' };
-      if (args.join(' ') === 'plugin list --json') return { status: 0, stdout: '[]', stderr: '' };
-      return { status: 0, stdout: '', stderr: '' };
-    },
-  });
-  const claudeResult = await claudeManager.operate('install', ['claude'], { scope: 'user' });
-  assert(claudeResult[0].ok, 'Claude Code installation should complete');
-  assert(claudeCalls.some(call => call.args.join(' ') === 'plugin marketplace add SanQianX/project-knowledge-base'), 'Claude Code should register the GitHub marketplace');
-  assert(claudeCalls.some(call => call.args.join(' ') === 'plugin install project-knowledge@project-knowledge --scope user'), 'Claude Code should install the native plugin');
-
-  const codexCalls = [];
-  const codexManager = new IntegrationManager({
-    rootDir: ROOT,
-    commandResolver: name => name,
-    runner: (command, args) => {
-      codexCalls.push({ command, args });
-      if (args.join(' ') === 'plugin marketplace list') {
-        return { status: 0, stdout: `MARKETPLACE ROOT\nproject-knowledge ${ROOT}\n`, stderr: '' };
-      }
-      if (args.join(' ') === 'plugin list --json') {
-        return {
-          status: 0,
-          stdout: JSON.stringify({ installed: [{ pluginId: 'project-knowledge@project-knowledge' }] }),
-          stderr: '',
-        };
-      }
-      return { status: 0, stdout: '', stderr: '' };
-    },
-  });
-  const codexResult = await codexManager.operate('update', ['codex']);
-  assert(codexResult[0].ok, 'Codex update should complete');
+// Run: node _site/_test/integration-adapters-test.js
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const {
+  IntegrationManager,
+  removeOpenCodeMcpConfig,
+  removeOpenCodeInstructionConfig,
+} = require('../lib/integration-installer');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const TEMP = fs.mkdtempSync(path.join(os.tmpdir(), `project-knowledge-integrations-${process.pid}-`));
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+async function main() {
+  const packageInfo = readJson(path.join(ROOT, 'package.json'));
+  const pluginRoot = path.join(ROOT, 'plugins', 'project-knowledge');
+  const claudeManifest = readJson(path.join(pluginRoot, '.claude-plugin', 'plugin.json'));
+  const codexManifest = readJson(path.join(pluginRoot, '.codex-plugin', 'plugin.json'));
+  const mcpManifest = readJson(path.join(pluginRoot, '.mcp.json'));
+  const claudeMarketplace = readJson(path.join(ROOT, '.claude-plugin', 'marketplace.json'));
+  const codexMarketplace = readJson(path.join(ROOT, '.agents', 'plugins', 'marketplace.json'));
+  const skillPath = path.join(pluginRoot, 'skills', 'project-knowledge', 'SKILL.md');
+  const skill = fs.readFileSync(skillPath, 'utf8');
+
+  assert(claudeManifest.version === packageInfo.version, 'Claude plugin version should match the npm package');
+  assert(codexManifest.version === packageInfo.version, 'Codex plugin version should match the npm package');
+  assert(claudeMarketplace.plugins[0].version === packageInfo.version, 'Claude marketplace version should match the npm package');
+  assert(codexMarketplace.name === 'project-knowledge', 'Codex marketplace should have a stable public name');
+  assert(codexMarketplace.plugins[0].source.path === './plugins/project-knowledge', 'Codex marketplace should point at the shared plugin');
+  assert(mcpManifest.mcpServers['project-knowledge'].args.includes(`${packageInfo.name}@${packageInfo.version}`), 'plugin MCP should pin the matching package name and version');
+  assert(!skill.includes('[TODO:'), 'bundled Skill should not contain scaffold placeholders');
+  assert(skill.includes('project_knowledge_resolve'), 'bundled Skill should teach the resolve-first workflow');
+  assert(skill.includes('project_knowledge_record_requirement'), 'bundled Skill should document the explicit supplemental adapter');
+  assert(skill.includes('only when the user explicitly requests supplemental capture'), 'bundled Skill must not make cooperative requirement recording mandatory');
+  assert(!/Before implementing a user request, call `project_knowledge_record_requirement`/.test(skill), 'automatic capture must remain primary');
+
+  const calls = [];
+  const homeDir = path.join(TEMP, 'home');
+  const manager = new IntegrationManager({
+    rootDir: ROOT,
+    homeDir,
+    env: {},
+    commandResolver: name => name,
+    runner: (command, args) => {
+      calls.push({ command, args });
+      return { status: 0, stdout: '', stderr: '' };
+    },
+  });
+  const openCodeResult = await manager.operate('install', ['opencode']);
+  assert(openCodeResult[0].ok, 'OpenCode installation should complete');
+  assert(fs.existsSync(path.join(homeDir, '.config', 'opencode', 'skills', 'project-knowledge', 'SKILL.md')), 'OpenCode should receive the global Skill');
+  const installedInstruction = path.join(homeDir, '.config', 'opencode', 'instructions', 'project-knowledge.md');
+  assert(fs.existsSync(installedInstruction), 'OpenCode should receive the global Instructions file');
+  const installedConfig = fs.readFileSync(path.join(homeDir, '.config', 'opencode', 'opencode.jsonc'), 'utf8');
+  assert(installedConfig.includes(installedInstruction.replace(/\\/g, '\\\\')), 'OpenCode config should reference the installed Instructions file');
+  const openCodeCall = calls.find(call => call.command === 'opencode');
+  assert(openCodeCall?.args.join(' ') === `mcp add project-knowledge -- npx -y --package ${packageInfo.name}@${packageInfo.version} project-knowledge-mcp`, 'OpenCode should receive the versioned MCP command');
+
+  const configDir = path.join(TEMP, 'opencode-config');
+  fs.mkdirSync(configDir, { recursive: true });
+  const configPath = path.join(configDir, 'opencode.jsonc');
+  fs.writeFileSync(configPath, `{
+  // Keep this user comment.
+  "instructions": [
+    "C:\\\\keep\\\\team-rules.md",
+    "${path.join(configDir, 'instructions', 'project-knowledge.md').replace(/\\/g, '\\\\')}"
+  ],
+  "mcp": {
+    "project-knowledge": { "type": "local", "command": ["npx"] },
+    "other": { "type": "remote", "url": "https://example.test/mcp" }
+  }
+}
+`, 'utf8');
+  assert(removeOpenCodeMcpConfig(configDir), 'OpenCode uninstall should remove its MCP entry');
+  const updatedConfig = fs.readFileSync(configPath, 'utf8');
+  assert(updatedConfig.includes('Keep this user comment'), 'OpenCode config comments should be preserved');
+  assert(updatedConfig.includes('"other"'), 'uninstall should preserve unrelated MCP servers');
+  assert(!updatedConfig.includes('"project-knowledge"'), 'uninstall should remove only the Project Knowledge MCP');
+  const instructionPath = path.join(configDir, 'instructions', 'project-knowledge.md');
+  assert(removeOpenCodeInstructionConfig(configDir, instructionPath), 'OpenCode uninstall should remove its Instructions reference');
+  const instructionUpdated = fs.readFileSync(configPath, 'utf8');
+  assert(instructionUpdated.includes('team-rules.md'), 'uninstall should preserve unrelated OpenCode instructions');
+  assert(!instructionUpdated.includes(instructionPath.replace(/\\/g, '\\\\')), 'uninstall should remove only its Instructions reference');
+
+  const claudeCalls = [];
+  const claudeManager = new IntegrationManager({
+    rootDir: ROOT,
+    commandResolver: name => name,
+    runner: (command, args) => {
+      claudeCalls.push({ command, args });
+      if (args.join(' ') === 'plugin marketplace list --json') return { status: 0, stdout: '[]', stderr: '' };
+      if (args.join(' ') === 'plugin list --json') return { status: 0, stdout: '[]', stderr: '' };
+      return { status: 0, stdout: '', stderr: '' };
+    },
+  });
+  const claudeResult = await claudeManager.operate('install', ['claude'], { scope: 'user' });
+  assert(claudeResult[0].ok, 'Claude Code installation should complete');
+  assert(claudeCalls.some(call => call.args.join(' ') === 'plugin marketplace add SanQianX/project-knowledge-base'), 'Claude Code should register the GitHub marketplace');
+  assert(claudeCalls.some(call => call.args.join(' ') === 'plugin install project-knowledge@project-knowledge --scope user'), 'Claude Code should install the native plugin');
+
+  const codexCalls = [];
+  const codexManager = new IntegrationManager({
+    rootDir: ROOT,
+    commandResolver: name => name,
+    runner: (command, args) => {
+      codexCalls.push({ command, args });
+      if (args.join(' ') === 'plugin marketplace list') {
+        return { status: 0, stdout: `MARKETPLACE ROOT\nproject-knowledge ${ROOT}\n`, stderr: '' };
+      }
+      if (args.join(' ') === 'plugin list --json') {
+        return {
+          status: 0,
+          stdout: JSON.stringify({ installed: [{ pluginId: 'project-knowledge@project-knowledge' }] }),
+          stderr: '',
+        };
+      }
+      return { status: 0, stdout: '', stderr: '' };
+    },
+  });
+  const codexResult = await codexManager.operate('update', ['codex']);
+  assert(codexResult[0].ok, 'Codex update should complete');
   assert(codexCalls.some(call => call.args.join(' ') === 'plugin marketplace upgrade project-knowledge'), 'Codex should refresh its marketplace');
   assert(codexCalls.some(call => call.args.join(' ') === 'plugin remove project-knowledge@project-knowledge'), 'Codex should remove the cached plugin during update');
   assert(codexCalls.some(call => call.args.join(' ') === 'plugin add project-knowledge@project-knowledge'), 'Codex should install the refreshed plugin');
@@ -201,43 +201,43 @@ async function main() {
   assert(bridgeOnly.installed && !bridgeOnly.conflict, 'a fresh Codex install should use the payload-preserving fan-out wrapper');
   const bridgeOnlyArgs = JSON.parse(fs.readFileSync(bridgeOnlyConfig, 'utf8').replace(/^\s*notify\s*=\s*/, '').trim());
   assert(bridgeOnlyArgs.join(' ').includes('codex-notify-fanout.cjs'), 'fresh Codex install should use the Project Knowledge fan-out wrapper');
-
-  const integrationLogs = [];
-  const failingManager = new IntegrationManager({
-    rootDir: ROOT,
-    commandResolver: name => name,
-    runner: () => ({ status: 9, stdout: '', stderr: 'failure includes sk-do-not-log' }),
-    logger: {
-      info: async (event, message, payload) => integrationLogs.push({ event, message, payload }),
-      error: async (event, message, payload) => integrationLogs.push({ event, message, payload }),
-    },
-  });
-  const failedIntegration = await failingManager.operate('install', ['claude']);
-  assert(!failedIntegration[0].ok, 'integration command failure should remain visible to the caller');
-  assert(integrationLogs.some(entry => entry.event === 'integration.command_started'));
-  assert(integrationLogs.some(entry => entry.event === 'integration.command_failed' && entry.payload.error.code === 'INTEGRATION_COMMAND_FAILED'));
-  assert(!JSON.stringify(integrationLogs).includes('sk-do-not-log'), 'integration logs must hash command output instead of recording it');
-
-  const routed = spawnSync(process.execPath, [
-    path.join(ROOT, 'bin', 'project-knowledge.js'),
-    'install',
-    '--ide',
-    'opencode',
-    '--dry-run',
-  ], {
-    cwd: ROOT,
-    encoding: 'utf8',
-    windowsHide: true,
-  });
-  assert(routed.status === 0, `main CLI should route integration commands: ${routed.stderr}`);
-  assert(routed.stdout.includes('project-knowledge-mcp'), 'routed dry-run should show the MCP installation');
-
-  console.log('integration-adapters-test PASS');
-}
-
-main().catch(error => {
-  console.error(error.stack || error.message);
-  process.exitCode = 1;
-}).finally(() => {
-  fs.rmSync(TEMP, { recursive: true, force: true });
-});
+
+  const integrationLogs = [];
+  const failingManager = new IntegrationManager({
+    rootDir: ROOT,
+    commandResolver: name => name,
+    runner: () => ({ status: 9, stdout: '', stderr: 'failure includes sk-do-not-log' }),
+    logger: {
+      info: async (event, message, payload) => integrationLogs.push({ event, message, payload }),
+      error: async (event, message, payload) => integrationLogs.push({ event, message, payload }),
+    },
+  });
+  const failedIntegration = await failingManager.operate('install', ['claude']);
+  assert(!failedIntegration[0].ok, 'integration command failure should remain visible to the caller');
+  assert(integrationLogs.some(entry => entry.event === 'integration.command_started'));
+  assert(integrationLogs.some(entry => entry.event === 'integration.command_failed' && entry.payload.error.code === 'INTEGRATION_COMMAND_FAILED'));
+  assert(!JSON.stringify(integrationLogs).includes('sk-do-not-log'), 'integration logs must hash command output instead of recording it');
+
+  const routed = spawnSync(process.execPath, [
+    path.join(ROOT, 'bin', 'project-knowledge.js'),
+    'install',
+    '--ide',
+    'opencode',
+    '--dry-run',
+  ], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    windowsHide: true,
+  });
+  assert(routed.status === 0, `main CLI should route integration commands: ${routed.stderr}`);
+  assert(routed.stdout.includes('project-knowledge-mcp'), 'routed dry-run should show the MCP installation');
+
+  console.log('integration-adapters-test PASS');
+}
+
+main().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+}).finally(() => {
+  fs.rmSync(TEMP, { recursive: true, force: true });
+});