@sanqianx/project-knowledge 5.0.18 → 5.0.20-rc.1

package/_site/_test/candidate-bin-content-test.js

@@ -0,0 +1,35 @@
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { installedFileBytes } = require('../scripts/pack-module-candidates');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-bin-content-'));
+const npmCli = process.env.npm_execpath || path.join(path.dirname(process.execPath), 'node_modules/npm/bin/npm-cli.js');
+function npm(args, cwd) {
+  const result = spawnSync(process.execPath, [npmCli, ...args], { cwd, encoding: 'utf8', windowsHide: true });
+  assert.equal(result.status, 0, result.stderr);
+  return result.stdout;
+}
+try {
+  const source = path.join(root, 'source'), installed = path.join(root, 'installed');
+  fs.mkdirSync(source); fs.mkdirSync(installed);
+  const pkg = { name: 'kb-bin-content-fixture', version: '1.0.0', bin: { 'kb-content-fixture': './bin.js' }, files: ['bin.js', 'readme.txt'] };
+  const bytes = Buffer.from('#!/usr/bin/env node\r\nconsole.log("安装验收");\r\n');
+  fs.writeFileSync(path.join(source, 'package.json'), JSON.stringify(pkg));
+  fs.writeFileSync(path.join(source, 'bin.js'), bytes);
+  fs.writeFileSync(path.join(source, 'readme.txt'), bytes);
+  assert.equal(typeof installedFileBytes, 'function', 'candidate hashes must model npm bin normalization');
+  const packed = JSON.parse(npm(['pack', '--ignore-scripts', '--json', '--pack-destination', root], source))[0];
+  fs.writeFileSync(path.join(installed, 'package.json'), JSON.stringify({ name: 'kb-bin-consumer', version: '1.0.0', private: true }));
+  npm(['install', `file:${path.join(root, packed.filename)}`, '--ignore-scripts', '--no-audit', '--no-fund', '--package-lock=false'], installed);
+  const actual = fs.readFileSync(path.join(installed, 'node_modules', pkg.name, 'bin.js'));
+  assert.notDeepEqual(actual, bytes, 'npm changes a CRLF shebang on installation');
+  assert.deepEqual(installedFileBytes(pkg, 'bin.js', bytes), actual, 'manifest bytes match actual npm installation');
+  assert.deepEqual(installedFileBytes(pkg, 'readme.txt', bytes), bytes, 'ordinary files retain their exact bytes');
+  assert.deepEqual(installedFileBytes({ bin: 'bin.js' }, 'bin.js', bytes), actual, 'string bin form is supported');
+  assert.deepEqual(installedFileBytes(pkg, 'bin.js', actual), actual, 'an already normalized bin is unchanged');
+  assert.ok(actual.includes(Buffer.from('验收");\r\n')), 'only the shebang is normalized');
+  console.log('candidate-bin-content-test PASS');
+} finally { fs.rmSync(root, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); }

package/_site/_test/candidate-product-assets-test.js

@@ -0,0 +1,13 @@
+'use strict';
+const assert=require('node:assert/strict'),fs=require('node:fs'),path=require('node:path'),os=require('node:os'),crypto=require('node:crypto');
+const {productFiles}=require('../scripts/pack-module-candidates');
+const root=fs.mkdtempSync(path.join(os.tmpdir(),'kb-candidate-assets-'));
+try{
+  const files=['ui/index.html','ui/knowledge-panel.html','ui/product.js','ui/live-client.js','ui/product.css','ui/favicon.svg','plugins/project-knowledge/scripts/context-hook.cjs'];
+  for(const file of files){fs.mkdirSync(path.dirname(path.join(root,file)),{recursive:true});fs.writeFileSync(path.join(root,file),file+' changed');}
+  fs.writeFileSync(path.join(root,'module-runtime-manifest.json'),JSON.stringify({productFiles:{[files.at(-1)]:'old-hash'}}));
+  const result=productFiles(root);
+  assert.equal(Object.keys(result).length,7);
+  assert.equal(result[files.at(-1)],crypto.createHash('sha256').update(files.at(-1)+' changed').digest('hex'));
+  console.log('candidate-product-assets-test PASS');
+}finally{fs.rmSync(root,{recursive:true,force:true,maxRetries:3,retryDelay:100});}

package/_site/_test/candidate-release-contract-test.js

@@ -1,14 +1,14 @@
-'use strict';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const { isPinnedModuleVersion } = require('../scripts/verify-module-runtime');
-for (const name of ['claude-ai-workbench', '@sanqianx/vector-hub', '@sanqianx/ai-coding-event-bridge-console']) {
-  for (const version of ['1.2.3', '1.2.3-rc.1', '1.2.3-rc.12']) assert.ok(isPinnedModuleVersion(name, version));
-  for (const version of ['latest', 'next', '^1.2.3', '~1.2.3', '>=1.2.3', 'file:../module', 'link:module', 'workspace:*', '1.2.3-beta.1', '1.2.3-rc', undefined]) assert.equal(isPinnedModuleVersion(name, version), false, String(version));
-}
-assert.ok(isPinnedModuleVersion('claude-ai-workbench', 'npm:@sanqianx/claude-ai-workbench@0.13.2-rc.1'));
-assert.equal(isPinnedModuleVersion('@sanqianx/vector-hub', 'npm:@sanqianx/claude-ai-workbench@0.13.2-rc.1'), false);
-const manifest = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../module-runtime-manifest.json')));
-for (const file of ['ui/index.html', 'ui/product.js', 'ui/product.css', 'ui/favicon.svg']) assert.match(manifest.productFiles[file], /^[a-f0-9]{64}$/);
-console.log('candidate-release-contract-test PASS');
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { isPinnedModuleVersion } = require('../scripts/verify-module-runtime');
+for (const name of ['claude-ai-workbench', '@sanqianx/vector-hub', '@sanqianx/ai-coding-event-bridge-console']) {
+  for (const version of ['1.2.3', '1.2.3-rc.1', '1.2.3-rc.12']) assert.ok(isPinnedModuleVersion(name, version));
+  for (const version of ['latest', 'next', '^1.2.3', '~1.2.3', '>=1.2.3', 'file:../module', 'link:module', 'workspace:*', '1.2.3-beta.1', '1.2.3-rc', undefined]) assert.equal(isPinnedModuleVersion(name, version), false, String(version));
+}
+assert.ok(isPinnedModuleVersion('claude-ai-workbench', 'npm:@sanqianx/claude-ai-workbench@0.13.2-rc.1'));
+assert.equal(isPinnedModuleVersion('@sanqianx/vector-hub', 'npm:@sanqianx/claude-ai-workbench@0.13.2-rc.1'), false);
+const manifest = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../module-runtime-manifest.json')));
+for (const file of ['ui/index.html', 'ui/knowledge-panel.html', 'ui/product.js', 'ui/product.css', 'ui/favicon.svg']) assert.match(manifest.productFiles[file], /^[a-f0-9]{64}$/);
+console.log('candidate-release-contract-test PASS');

package/_site/_test/capture-hook-dedup-test.js

@@ -1,158 +1,158 @@
-'use strict';
-
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const { IntegrationManager } = require(process.env.PK_TEST_INTEGRATION_ROOT
-  ? path.join(process.env.PK_TEST_INTEGRATION_ROOT, '_site/lib/integration-installer') : '../lib/integration-installer');
-const { bridgeBinding, planCaptureHooks, repairCaptureHooks } = require('../lib/capture-hook-config');
-const bridge = require('@sanqianx/ai-coding-event-bridge-console/src/bridge');
-const ROOT = path.resolve(__dirname, '../..');
-const TEMP = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-capture-dedup-'));
-const HOME = path.join(TEMP, '用户 空格');
-const OLD = path.join(HOME, '.ai-coding-event-bridge');
-const CURRENT = path.join(HOME, '.project-knowledge-v5/events');
-const options = { homeDir: HOME, bridgeHomeDir: CURRENT };
-const shim = home => path.join(home, 'bin/bridge-hook.cjs');
-const cmd = home => ({ type: 'command', command: `node "${shim(home)}"` });
-const processHook = home => ({ type: 'process', command: 'node', args: [shim(home), '--source', 'zcode'], timeoutMs: 15000 });
-const events = ['UserPromptSubmit', 'Stop'];
-const read = file => JSON.parse(fs.readFileSync(file, 'utf8'));
-function write(file, object) { fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, JSON.stringify(object, null, 2) + '\n'); }
-function manager(extra = {}) { return new IntegrationManager({ rootDir: ROOT, env: {}, ...options, ...extra }); }
-
-async function main() {
-  const claude = path.join(HOME, '.claude/settings.json');
-  const third = { type: 'command', command: 'node "notify-user.cjs"', timeout: 10 };
-  const context = { type: 'command', command: 'node "context-hook.cjs" --client claude' };
-  const lookalike = { type: 'command', command: `node "${shim(OLD)}" && echo keep-user-wrapper` };
-  const customHome = path.join(HOME, 'independent-third-party-bridge');
-  const unrelated = { model: 'user-model', env: { PRIVATE_TEST_TOKEN: 'do-not-back-up-unrelated-secret' } };
-  write(claude, { ...unrelated, hooks: Object.fromEntries(events.map(event => [event, [
-    { matcher: '*', hooks: [cmd(OLD), third, cmd(CURRENT)] },
-    { matcher: '*', hooks: [cmd(OLD), cmd(CURRENT), context, lookalike, cmd(customHome)] },
-  ]])) });
-  const before = fs.readFileSync(claude, 'utf8');
-  const logs = [];
-  const item = manager({ logger: { info: (...args) => logs.push(args), error: (...args) => logs.push(args) } });
-  assert.equal((await item.statusCaptureClaude()).state, 'needs-repair', 'duplicate capture cannot be reported healthy');
-  assert.equal(fs.readFileSync(claude, 'utf8'), before, 'status is read-only');
-  const installed = await item.captureOperation('install', 'claude');
-  assert.equal(installed.removedLegacy, 4);
-  assert.equal(installed.removedDuplicates, 2);
-  assert(logs.some(row => row[2]?.context?.removedLegacy === 4 && row[2]?.context?.removedDuplicates === 2), 'repair counts are persisted without raw configuration');
-  assert(!JSON.stringify(logs).includes('do-not-back-up-unrelated-secret'));
-  let saved = read(claude);
-  assert.equal(saved.model, unrelated.model); assert.deepEqual(saved.env, unrelated.env);
-  for (const event of events) {
-    const hooks = saved.hooks[event].flatMap(group => group.hooks);
-    assert.equal(hooks.filter(hook => hook.command === cmd(CURRENT).command).length, 1);
-    assert.equal(hooks.filter(hook => hook.command === cmd(OLD).command).length, 0);
-    for (const keep of [third, context, lookalike, cmd(customHome)]) assert(hooks.some(hook => JSON.stringify(hook) === JSON.stringify(keep)), 'mixed-group third-party hooks survive');
-  }
-  assert(!fs.readFileSync(installed.backupFile, 'utf8').includes('do-not-back-up-unrelated-secret'), 'backup contains only removed owned invocations');
-  assert.equal((await item.statusCaptureClaude()).state, 'installed');
-  const after = fs.readFileSync(claude, 'utf8');
-  assert.equal((await item.installCaptureClaude()).changed, false);
-  assert.equal(fs.readFileSync(claude, 'utf8'), after, 'repeat repair is byte-idempotent');
-  await item.uninstallCaptureClaude();
-  saved = read(claude);
-  for (const event of events) assert(saved.hooks[event].flatMap(group => group.hooks).some(hook => hook.command === third.command), 'uninstall keeps other hooks in the same group');
-
-  const zcode = path.join(HOME, '.zcode/cli/config.json');
-  const zContext = { type: 'process', command: 'node', args: ['context-hook.cjs', '--client', 'zcode'] };
-  write(zcode, { ...unrelated, hooks: { enabled: true, events: Object.fromEntries(events.map(event => [event, [{ hooks: [processHook(OLD), third, processHook(CURRENT), processHook(CURRENT), zContext] }]])) } });
-  assert.equal((await item.statusCaptureZCode()).state, 'needs-repair');
-  const zInstalled = await item.installCaptureZCode();
-  assert.equal(zInstalled.removedLegacy, 2); assert.equal(zInstalled.removedDuplicates, 2);
-  const zBeforeRepeat = fs.readFileSync(zcode, 'utf8');
-  await item.installCaptureZCode();
-  assert.equal(fs.readFileSync(zcode, 'utf8'), zBeforeRepeat);
-  await item.uninstallCaptureZCode();
-  assert.deepEqual(read(zcode).env, unrelated.env);
-  assert.deepEqual(read(zcode).hooks.events.UserPromptSubmit[0].hooks, [third, zContext]);
-
-  write(claude, { hooks: Object.fromEntries(events.map(event => [event, [{ hooks: [cmd(OLD)] }]])) });
-  const onlyLegacy = fs.readFileSync(claude, 'utf8');
-  assert.throws(() => repairCaptureHooks(claude, 'claude', options), /入口未完整/);
-  const failed = manager({ bridgeModule: { installers: { claudeCode: { installClaudeCodeHook: async () => { throw new Error('runtime materialization failed'); } } } } });
-  await assert.rejects(failed.installCaptureClaude(), /materialization failed/);
-  assert.equal(fs.readFileSync(claude, 'utf8'), onlyLegacy, 'failed runtime install cannot retire working old capture');
-  const conflict = manager({ bridgeModule: { installers: { claudeCode: { installClaudeCodeHook: async () => ({ added: [], runtime: { conflict: true } }) } } } });
-  await assert.rejects(conflict.installCaptureClaude(), /版本冲突/);
-  assert.equal(fs.readFileSync(claude, 'utf8'), onlyLegacy, 'a runtime conflict cannot retire old capture');
-  const dry = manager({ dryRun: true });
-  await dry.installCaptureClaude(); await dry.uninstallCaptureClaude();
-  assert.equal(fs.readFileSync(claude, 'utf8'), onlyLegacy);
-  fs.writeFileSync(claude, '{invalid JSON');
-  assert.throws(() => planCaptureHooks(claude, 'claude', options), /JSON/);
-  assert.equal(fs.readFileSync(claude, 'utf8'), '{invalid JSON');
-  assert.equal(bridgeBinding(['node', `${shim(OLD)}.user-script`], options), '');
-  assert.equal(bridgeBinding(['node', shim(OLD), '--custom-argument'], options), '');
-  assert.equal(bridgeBinding([['node'], shim(OLD)], options), '');
-  write(claude, { hooks: { UserPromptSubmit: [null, { hooks: [cmd(OLD), cmd(CURRENT)] }], Stop: [{ hooks: [cmd(CURRENT)] }] } });
-  repairCaptureHooks(claude, 'claude', options);
-  assert.equal(read(claude).hooks.UserPromptSubmit[0], null, 'repair does not silently drop unrelated malformed groups');
-  write(claude, { hooks: Object.fromEntries(events.map(event => [event, [{ hooks: [cmd(OLD), cmd(CURRENT)] }]])) });
-  const originalRead = fs.readFileSync;
-  let reads = 0;
-  fs.readFileSync = function(file, ...args) {
-    const value = originalRead.call(this, file, ...args);
-    if (file === claude && ++reads === 2) write(claude, { ...JSON.parse(value), userConcurrentEdit: 'kept' });
-    return value;
-  };
-  try { assert.throws(() => repairCaptureHooks(claude, 'claude', options), error => error.code === 'CONFIG_CHANGED'); }
-  finally { fs.readFileSync = originalRead; }
-  assert.equal(read(claude).userConcurrentEdit, 'kept', 'a concurrent user edit is never overwritten');
-
-  // Real Git + real installed shims: the stale store is registered, but no
-  // repaired client invocation recreates it or sends duplicate events.
-  const repo = path.join(TEMP, '代码 中文 project');
-  fs.mkdirSync(repo, { recursive: true });
-  const git = spawnSync('git', ['init', '-q'], { cwd: repo, encoding: 'utf8', windowsHide: true });
-  assert.equal(git.status, 0, git.stderr);
-  const obsoleteStore = path.join(TEMP, 'knowledge/old-slug/dev-conversations');
-  const canonicalStore = path.join(TEMP, 'knowledge/Canonical-abcdef/dev-conversations');
-  await bridge.ensureRuntimeHome({ homeDir: OLD });
-  await bridge.projectRegistry.addProject({ home: OLD, path: repo, store: obsoleteStore });
-  await bridge.projectRegistry.addProject({ home: CURRENT, path: repo, store: canonicalStore });
-  fs.rmSync(path.join(TEMP, 'knowledge/old-slug'), { recursive: true, force: true });
-  write(claude, { hooks: Object.fromEntries(events.map(event => [event, [{ hooks: [cmd(OLD), cmd(CURRENT), cmd(CURRENT)] }]])) });
-  await item.installCaptureClaude();
-  const env = { ...process.env }; delete env.AI_CODING_EVENT_BRIDGE_HOME;
-  for (const [event, payload] of [
-    ['UserPromptSubmit', { prompt: 'isolated dedup test request' }],
-    ['Stop', { last_assistant_message: 'isolated dedup test answer' }],
-  ]) {
-    const hooks = read(claude).hooks[event].flatMap(group => group.hooks);
-    assert.equal(hooks.length, 1);
-    const call = spawnSync(process.execPath, [shim(CURRENT)], { cwd: repo, env, input: JSON.stringify({ hook_event_name: event, cwd: repo, session_id: 'dedup-test', ...payload }), encoding: 'utf8', windowsHide: true, timeout: 10000 });
-    assert.equal(call.status, 0, call.stderr);
-  }
-  const journal = path.join(canonicalStore, 'journal/events.jsonl');
-  const captured = fs.readFileSync(journal, 'utf8').trim().split(/\r?\n/).map(line => JSON.parse(line));
-  assert.deepEqual(captured.map(row => row.eventType), ['user_prompt', 'assistant_response']);
-  assert(!fs.existsSync(obsoleteStore), 'the stale second directory is not recreated');
-  write(zcode, { hooks: { enabled: true, events: Object.fromEntries(events.map(event => [event, [{ hooks: [processHook(OLD), processHook(CURRENT), processHook(CURRENT)] }]])) } });
-  await item.installCaptureZCode();
-  for (const [event, payload] of [
-    ['UserPromptSubmit', { prompt: 'isolated zcode dedup request' }],
-    ['Stop', { last_assistant_message: 'isolated zcode dedup answer' }],
-  ]) {
-    const hooks = read(zcode).hooks.events[event].flatMap(group => group.hooks);
-    assert.equal(hooks.length, 1);
-    const call = spawnSync(process.execPath, hooks[0].args, { cwd: repo, env, input: JSON.stringify({ hook_event_name: event, cwd: repo, session_id: 'zcode-dedup-test', ...payload }), encoding: 'utf8', windowsHide: true, timeout: 10000 });
-    assert.equal(call.status, 0, call.stderr);
-  }
-  const afterZCode = fs.readFileSync(journal, 'utf8').trim().split(/\r?\n/).map(line => JSON.parse(line));
-  assert.deepEqual(afterZCode.map(row => row.source), ['claude-code', 'claude-code', 'zcode', 'zcode']);
-  assert(!fs.existsSync(obsoleteStore), 'ZCode also cannot recreate the old knowledge folder');
-  console.log('capture-hook-dedup-test PASS (duplicate status, exact ownership, mixed-group preservation, idempotency, runtime failure and real journal capture)');
-}
-
-main().catch(error => { console.error(error.stack); process.exitCode = 1; }).finally(() => {
-  assert(path.resolve(TEMP).startsWith(path.resolve(os.tmpdir()) + path.sep));
-  fs.rmSync(TEMP, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-});
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { IntegrationManager } = require(process.env.PK_TEST_INTEGRATION_ROOT
+  ? path.join(process.env.PK_TEST_INTEGRATION_ROOT, '_site/lib/integration-installer') : '../lib/integration-installer');
+const { bridgeBinding, planCaptureHooks, repairCaptureHooks } = require('../lib/capture-hook-config');
+const bridge = require('@sanqianx/ai-coding-event-bridge-console/src/bridge');
+const ROOT = path.resolve(__dirname, '../..');
+const TEMP = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-capture-dedup-'));
+const HOME = path.join(TEMP, '用户 空格');
+const OLD = path.join(HOME, '.ai-coding-event-bridge');
+const CURRENT = path.join(HOME, '.project-knowledge-v5/events');
+const options = { homeDir: HOME, bridgeHomeDir: CURRENT };
+const shim = home => path.join(home, 'bin/bridge-hook.cjs');
+const cmd = home => ({ type: 'command', command: `node "${shim(home)}"` });
+const processHook = home => ({ type: 'process', command: 'node', args: [shim(home), '--source', 'zcode'], timeoutMs: 15000 });
+const events = ['UserPromptSubmit', 'Stop'];
+const read = file => JSON.parse(fs.readFileSync(file, 'utf8'));
+function write(file, object) { fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, JSON.stringify(object, null, 2) + '\n'); }
+function manager(extra = {}) { return new IntegrationManager({ rootDir: ROOT, env: {}, ...options, ...extra }); }
+
+async function main() {
+  const claude = path.join(HOME, '.claude/settings.json');
+  const third = { type: 'command', command: 'node "notify-user.cjs"', timeout: 10 };
+  const context = { type: 'command', command: 'node "context-hook.cjs" --client claude' };
+  const lookalike = { type: 'command', command: `node "${shim(OLD)}" && echo keep-user-wrapper` };
+  const customHome = path.join(HOME, 'independent-third-party-bridge');
+  const unrelated = { model: 'user-model', env: { PRIVATE_TEST_TOKEN: 'do-not-back-up-unrelated-secret' } };
+  write(claude, { ...unrelated, hooks: Object.fromEntries(events.map(event => [event, [
+    { matcher: '*', hooks: [cmd(OLD), third, cmd(CURRENT)] },
+    { matcher: '*', hooks: [cmd(OLD), cmd(CURRENT), context, lookalike, cmd(customHome)] },
+  ]])) });
+  const before = fs.readFileSync(claude, 'utf8');
+  const logs = [];
+  const item = manager({ logger: { info: (...args) => logs.push(args), error: (...args) => logs.push(args) } });
+  assert.equal((await item.statusCaptureClaude()).state, 'needs-repair', 'duplicate capture cannot be reported healthy');
+  assert.equal(fs.readFileSync(claude, 'utf8'), before, 'status is read-only');
+  const installed = await item.captureOperation('install', 'claude');
+  assert.equal(installed.removedLegacy, 4);
+  assert.equal(installed.removedDuplicates, 2);
+  assert(logs.some(row => row[2]?.context?.removedLegacy === 4 && row[2]?.context?.removedDuplicates === 2), 'repair counts are persisted without raw configuration');
+  assert(!JSON.stringify(logs).includes('do-not-back-up-unrelated-secret'));
+  let saved = read(claude);
+  assert.equal(saved.model, unrelated.model); assert.deepEqual(saved.env, unrelated.env);
+  for (const event of events) {
+    const hooks = saved.hooks[event].flatMap(group => group.hooks);
+    assert.equal(hooks.filter(hook => hook.command === cmd(CURRENT).command).length, 1);
+    assert.equal(hooks.filter(hook => hook.command === cmd(OLD).command).length, 0);
+    for (const keep of [third, context, lookalike, cmd(customHome)]) assert(hooks.some(hook => JSON.stringify(hook) === JSON.stringify(keep)), 'mixed-group third-party hooks survive');
+  }
+  assert(!fs.readFileSync(installed.backupFile, 'utf8').includes('do-not-back-up-unrelated-secret'), 'backup contains only removed owned invocations');
+  assert.equal((await item.statusCaptureClaude()).state, 'installed');
+  const after = fs.readFileSync(claude, 'utf8');
+  assert.equal((await item.installCaptureClaude()).changed, false);
+  assert.equal(fs.readFileSync(claude, 'utf8'), after, 'repeat repair is byte-idempotent');
+  await item.uninstallCaptureClaude();
+  saved = read(claude);
+  for (const event of events) assert(saved.hooks[event].flatMap(group => group.hooks).some(hook => hook.command === third.command), 'uninstall keeps other hooks in the same group');
+
+  const zcode = path.join(HOME, '.zcode/cli/config.json');
+  const zContext = { type: 'process', command: 'node', args: ['context-hook.cjs', '--client', 'zcode'] };
+  write(zcode, { ...unrelated, hooks: { enabled: true, events: Object.fromEntries(events.map(event => [event, [{ hooks: [processHook(OLD), third, processHook(CURRENT), processHook(CURRENT), zContext] }]])) } });
+  assert.equal((await item.statusCaptureZCode()).state, 'needs-repair');
+  const zInstalled = await item.installCaptureZCode();
+  assert.equal(zInstalled.removedLegacy, 2); assert.equal(zInstalled.removedDuplicates, 2);
+  const zBeforeRepeat = fs.readFileSync(zcode, 'utf8');
+  await item.installCaptureZCode();
+  assert.equal(fs.readFileSync(zcode, 'utf8'), zBeforeRepeat);
+  await item.uninstallCaptureZCode();
+  assert.deepEqual(read(zcode).env, unrelated.env);
+  assert.deepEqual(read(zcode).hooks.events.UserPromptSubmit[0].hooks, [third, zContext]);
+
+  write(claude, { hooks: Object.fromEntries(events.map(event => [event, [{ hooks: [cmd(OLD)] }]])) });
+  const onlyLegacy = fs.readFileSync(claude, 'utf8');
+  assert.throws(() => repairCaptureHooks(claude, 'claude', options), /入口未完整/);
+  const failed = manager({ bridgeModule: { installers: { claudeCode: { installClaudeCodeHook: async () => { throw new Error('runtime materialization failed'); } } } } });
+  await assert.rejects(failed.installCaptureClaude(), /materialization failed/);
+  assert.equal(fs.readFileSync(claude, 'utf8'), onlyLegacy, 'failed runtime install cannot retire working old capture');
+  const conflict = manager({ bridgeModule: { installers: { claudeCode: { installClaudeCodeHook: async () => ({ added: [], runtime: { conflict: true } }) } } } });
+  await assert.rejects(conflict.installCaptureClaude(), /版本冲突/);
+  assert.equal(fs.readFileSync(claude, 'utf8'), onlyLegacy, 'a runtime conflict cannot retire old capture');
+  const dry = manager({ dryRun: true });
+  await dry.installCaptureClaude(); await dry.uninstallCaptureClaude();
+  assert.equal(fs.readFileSync(claude, 'utf8'), onlyLegacy);
+  fs.writeFileSync(claude, '{invalid JSON');
+  assert.throws(() => planCaptureHooks(claude, 'claude', options), /JSON/);
+  assert.equal(fs.readFileSync(claude, 'utf8'), '{invalid JSON');
+  assert.equal(bridgeBinding(['node', `${shim(OLD)}.user-script`], options), '');
+  assert.equal(bridgeBinding(['node', shim(OLD), '--custom-argument'], options), '');
+  assert.equal(bridgeBinding([['node'], shim(OLD)], options), '');
+  write(claude, { hooks: { UserPromptSubmit: [null, { hooks: [cmd(OLD), cmd(CURRENT)] }], Stop: [{ hooks: [cmd(CURRENT)] }] } });
+  repairCaptureHooks(claude, 'claude', options);
+  assert.equal(read(claude).hooks.UserPromptSubmit[0], null, 'repair does not silently drop unrelated malformed groups');
+  write(claude, { hooks: Object.fromEntries(events.map(event => [event, [{ hooks: [cmd(OLD), cmd(CURRENT)] }]])) });
+  const originalRead = fs.readFileSync;
+  let reads = 0;
+  fs.readFileSync = function(file, ...args) {
+    const value = originalRead.call(this, file, ...args);
+    if (file === claude && ++reads === 2) write(claude, { ...JSON.parse(value), userConcurrentEdit: 'kept' });
+    return value;
+  };
+  try { assert.throws(() => repairCaptureHooks(claude, 'claude', options), error => error.code === 'CONFIG_CHANGED'); }
+  finally { fs.readFileSync = originalRead; }
+  assert.equal(read(claude).userConcurrentEdit, 'kept', 'a concurrent user edit is never overwritten');
+
+  // Real Git + real installed shims: the stale store is registered, but no
+  // repaired client invocation recreates it or sends duplicate events.
+  const repo = path.join(TEMP, '代码 中文 project');
+  fs.mkdirSync(repo, { recursive: true });
+  const git = spawnSync('git', ['init', '-q'], { cwd: repo, encoding: 'utf8', windowsHide: true });
+  assert.equal(git.status, 0, git.stderr);
+  const obsoleteStore = path.join(TEMP, 'knowledge/old-slug/dev-conversations');
+  const canonicalStore = path.join(TEMP, 'knowledge/Canonical-abcdef/dev-conversations');
+  await bridge.ensureRuntimeHome({ homeDir: OLD });
+  await bridge.projectRegistry.addProject({ home: OLD, path: repo, store: obsoleteStore });
+  await bridge.projectRegistry.addProject({ home: CURRENT, path: repo, store: canonicalStore });
+  fs.rmSync(path.join(TEMP, 'knowledge/old-slug'), { recursive: true, force: true });
+  write(claude, { hooks: Object.fromEntries(events.map(event => [event, [{ hooks: [cmd(OLD), cmd(CURRENT), cmd(CURRENT)] }]])) });
+  await item.installCaptureClaude();
+  const env = { ...process.env }; delete env.AI_CODING_EVENT_BRIDGE_HOME;
+  for (const [event, payload] of [
+    ['UserPromptSubmit', { prompt: 'isolated dedup test request' }],
+    ['Stop', { last_assistant_message: 'isolated dedup test answer' }],
+  ]) {
+    const hooks = read(claude).hooks[event].flatMap(group => group.hooks);
+    assert.equal(hooks.length, 1);
+    const call = spawnSync(process.execPath, [shim(CURRENT)], { cwd: repo, env, input: JSON.stringify({ hook_event_name: event, cwd: repo, session_id: 'dedup-test', ...payload }), encoding: 'utf8', windowsHide: true, timeout: 10000 });
+    assert.equal(call.status, 0, call.stderr);
+  }
+  const journal = path.join(canonicalStore, 'journal/events.jsonl');
+  const captured = fs.readFileSync(journal, 'utf8').trim().split(/\r?\n/).map(line => JSON.parse(line));
+  assert.deepEqual(captured.map(row => row.eventType), ['user_prompt', 'assistant_response']);
+  assert(!fs.existsSync(obsoleteStore), 'the stale second directory is not recreated');
+  write(zcode, { hooks: { enabled: true, events: Object.fromEntries(events.map(event => [event, [{ hooks: [processHook(OLD), processHook(CURRENT), processHook(CURRENT)] }]])) } });
+  await item.installCaptureZCode();
+  for (const [event, payload] of [
+    ['UserPromptSubmit', { prompt: 'isolated zcode dedup request' }],
+    ['Stop', { last_assistant_message: 'isolated zcode dedup answer' }],
+  ]) {
+    const hooks = read(zcode).hooks.events[event].flatMap(group => group.hooks);
+    assert.equal(hooks.length, 1);
+    const call = spawnSync(process.execPath, hooks[0].args, { cwd: repo, env, input: JSON.stringify({ hook_event_name: event, cwd: repo, session_id: 'zcode-dedup-test', ...payload }), encoding: 'utf8', windowsHide: true, timeout: 10000 });
+    assert.equal(call.status, 0, call.stderr);
+  }
+  const afterZCode = fs.readFileSync(journal, 'utf8').trim().split(/\r?\n/).map(line => JSON.parse(line));
+  assert.deepEqual(afterZCode.map(row => row.source), ['claude-code', 'claude-code', 'zcode', 'zcode']);
+  assert(!fs.existsSync(obsoleteStore), 'ZCode also cannot recreate the old knowledge folder');
+  console.log('capture-hook-dedup-test PASS (duplicate status, exact ownership, mixed-group preservation, idempotency, runtime failure and real journal capture)');
+}
+
+main().catch(error => { console.error(error.stack); process.exitCode = 1; }).finally(() => {
+  assert(path.resolve(TEMP).startsWith(path.resolve(os.tmpdir()) + path.sep));
+  fs.rmSync(TEMP, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+});

package/_site/_test/claude-executable-discovery-test.js

@@ -1,9 +1,9 @@
 const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const runner = require('../lib/claude-cli-runner');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const runner = require('../lib/claude-cli-runner');
 
 const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-discovery-test-'));
 
@@ -46,33 +46,33 @@ const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-discovery-test-'));
     assert.equal(fromExtensionlessNpmShim.cmd, npmExe,
       'extensionless npm shell shim should resolve to the package native executable');
 
-    const fromCmdNpmShim = await runner.findClaudeExecutableForSdk({
+    const fromCmdNpmShim = await runner.findClaudeExecutableForSdk({
       platform: 'win32',
       env: { CLAUDE_CODE_EXECPATH: npmShim },
       runCommand: () => ({ status: 1, stdout: '' }),
     });
-    assert.equal(fromCmdNpmShim.cmd, npmExe,
-      'configured npm .cmd shim should resolve to the package native executable');
-    assert.equal(fromCmdNpmShim.runtimeExecutable, null,
-      'native Claude executable should not need a JavaScript runtime launcher');
-
-    fs.rmSync(npmExe);
-    const fromCliScript = await runner.findClaudeExecutableForSdk({
-      platform: 'win32',
-      env: { CLAUDE_CODE_EXECPATH: npmShim },
-      runtimeExecutable: process.execPath,
-      runCommand: () => ({ status: 1, stdout: '' }),
-    });
-    assert.equal(fromCliScript.cmd, npmCli,
-      'npm shim should fall back to the installed Claude cli.js');
-    assert.equal(fromCliScript.runtimeExecutable, process.execPath,
-      'Claude cli.js must use the current runtime instead of PATH node');
-    const scriptLaunch = spawnSync(fromCliScript.runtimeExecutable, [fromCliScript.cmd], {
-      encoding: 'utf8',
-      windowsHide: true,
-    });
-    assert.equal(scriptLaunch.status, 0,
-      `resolved Claude cli.js should launch through the selected runtime: ${scriptLaunch.stderr}`);
+    assert.equal(fromCmdNpmShim.cmd, npmExe,
+      'configured npm .cmd shim should resolve to the package native executable');
+    assert.equal(fromCmdNpmShim.runtimeExecutable, null,
+      'native Claude executable should not need a JavaScript runtime launcher');
+
+    fs.rmSync(npmExe);
+    const fromCliScript = await runner.findClaudeExecutableForSdk({
+      platform: 'win32',
+      env: { CLAUDE_CODE_EXECPATH: npmShim },
+      runtimeExecutable: process.execPath,
+      runCommand: () => ({ status: 1, stdout: '' }),
+    });
+    assert.equal(fromCliScript.cmd, npmCli,
+      'npm shim should fall back to the installed Claude cli.js');
+    assert.equal(fromCliScript.runtimeExecutable, process.execPath,
+      'Claude cli.js must use the current runtime instead of PATH node');
+    const scriptLaunch = spawnSync(fromCliScript.runtimeExecutable, [fromCliScript.cmd], {
+      encoding: 'utf8',
+      windowsHide: true,
+    });
+    assert.equal(scriptLaunch.status, 0,
+      `resolved Claude cli.js should launch through the selected runtime: ${scriptLaunch.stderr}`);
 
     const missing = await runner.findClaudeExecutableForSdk({
       platform: 'win32',