@sanqianx/project-knowledge 5.0.23 → 5.0.25

package/_site/_test/module-terminal-restart-test.js

@@ -1,63 +1,63 @@
-'use strict';
-const assert = require('node:assert/strict');
-const { ModuleBridge } = require('../lib/module-bridge');
-const { connectEngine } = require('../lib/engine-connection');
-
-async function main() {
-  const state = { modules: { terminal: { projectId: 'terminal-original' } } };
-  const config = { repoPath: process.cwd(), knowledgePath: process.cwd(), displayName: 'Restart' };
-  const projects = ['terminal-original', 'terminal-duplicate'].map(id => ({ id, rootPath: config.repoPath }));
-  let listFailure = 'status';
-  let creations = 0;
-  const bridge = new ModuleBridge({
-    terminalUrl: 'http://terminal.test', vectorHubUrl: 'http://vector.test',
-    eventBridgeUrl: 'http://event.test', engineUrl: 'http://engine.test',
-    registryStore: { listIds: () => ['project-restart'], readDisplaySnapshot: () => ({}) },
-    projectStore: { readConfig: () => config, readState: () => state, updateState: async (_id, apply) => apply(state) },
-  });
-  bridge.modulesHealth = async () => ({ modules: Object.fromEntries(['terminal', 'vectorHub', 'eventBridge', 'engine'].map(key => [key, { up: true }])) });
-  bridge._fetch = async (url, options = {}) => {
-    if (url === 'http://terminal.test/api/claude-workbench/v1/projects') {
-      if (options.method === 'POST') { creations += 1; return { ok: true, status: 201, json: async () => ({ id: 'unexpected-new' }) }; }
-      if (listFailure === 'network') throw new Error('service starting');
-      if (listFailure === 'status') return { ok: false, status: 503 };
-      return { ok: true, json: async () => listFailure === 'payload' ? {} : { projects } };
-    }
-    return { ok: true, status: 200, json: async () => ({ projects: [], project: { id: 'journal-restart' }, sequence: 0 }) };
-  };
-  const input = { projectId: 'project-restart', name: config.displayName, workspacePath: config.repoPath, knowledgePath: config.knowledgePath };
-  for (const failure of ['status', 'network', 'payload']) {
-    listFailure = failure;
-    const result = await bridge.registerProjectLinks(input);
-    assert.equal(result.terminal.status, 'pending', `${failure} is not an empty registry`);
-    assert.equal(creations, 0, 'a failed registry read must never create a workspace');
-    assert.equal(state.modules.terminal.projectId, 'terminal-original', 'retain the last known binding');
-  }
-  listFailure = null;
-  const recovered = await bridge.registerProjectLinks(input);
-  assert.equal(recovered.terminal.projectId, 'terminal-original');
-  assert.equal(recovered.terminal.reused, true);
-  const projection = await bridge.aggregatedProjects();
-  assert.equal(projection.projects[0].modules.terminal.projectId, 'terminal-original', 'saved binding wins over duplicate path entries');
-  assert.equal(creations, 0);
-  let wiringCalls = 0;
-  const runtime = {
-    registryStore: bridge.registryStore, projectStore: bridge.projectStore,
-    moduleBridge: {
-      engineUrl: 'http://engine.test', runtimeToken: 'fixture',
-      _fetch: async () => ({ ok: true, status: 200, json: async () => ({ name: 'knowledge-engine', dataSchemaVersion: 3 }) }),
-      _listEngineProjects: async () => [{ projectId: 'project-restart', ...config }],
-      registerProjectLinks: async () => ({ engine: { ok: true }, eventBridge: { ok: true }, terminal: { ok: ++wiringCalls > 1 } }),
-      syncEngineConfiguration: async () => ({}),
-    },
-    logger: { warn: async () => {} },
-  };
-  await connectEngine(runtime);
-  assert.equal(runtime.ownership.ready, true, 'terminal recovery does not block the knowledge engine');
-  assert.equal(runtime.projectConnections.has('project-restart'), false, 'incomplete terminal wiring must remain retryable');
-  await connectEngine(runtime);
-  assert.equal(wiringCalls, 2, 'the next connection pass retries incomplete terminal wiring');
-  assert.equal(runtime.projectConnections.has('project-restart'), true);
-  console.log('module-terminal-restart-test PASS');
-}
-main().catch(error => { console.error(error); process.exitCode = 1; });
+'use strict';
+const assert = require('node:assert/strict');
+const { ModuleBridge } = require('../lib/module-bridge');
+const { connectEngine } = require('../lib/engine-connection');
+
+async function main() {
+  const state = { modules: { terminal: { projectId: 'terminal-original' } } };
+  const config = { repoPath: process.cwd(), knowledgePath: process.cwd(), displayName: 'Restart' };
+  const projects = ['terminal-original', 'terminal-duplicate'].map(id => ({ id, rootPath: config.repoPath }));
+  let listFailure = 'status';
+  let creations = 0;
+  const bridge = new ModuleBridge({
+    terminalUrl: 'http://terminal.test', vectorHubUrl: 'http://vector.test',
+    eventBridgeUrl: 'http://event.test', engineUrl: 'http://engine.test',
+    registryStore: { listIds: () => ['project-restart'], readDisplaySnapshot: () => ({}) },
+    projectStore: { readConfig: () => config, readState: () => state, updateState: async (_id, apply) => apply(state) },
+  });
+  bridge.modulesHealth = async () => ({ modules: Object.fromEntries(['terminal', 'vectorHub', 'eventBridge', 'engine'].map(key => [key, { up: true }])) });
+  bridge._fetch = async (url, options = {}) => {
+    if (url === 'http://terminal.test/api/claude-workbench/v1/projects') {
+      if (options.method === 'POST') { creations += 1; return { ok: true, status: 201, json: async () => ({ id: 'unexpected-new' }) }; }
+      if (listFailure === 'network') throw new Error('service starting');
+      if (listFailure === 'status') return { ok: false, status: 503 };
+      return { ok: true, json: async () => listFailure === 'payload' ? {} : { projects } };
+    }
+    return { ok: true, status: 200, json: async () => ({ projects: [], project: { id: 'journal-restart' }, sequence: 0 }) };
+  };
+  const input = { projectId: 'project-restart', name: config.displayName, workspacePath: config.repoPath, knowledgePath: config.knowledgePath };
+  for (const failure of ['status', 'network', 'payload']) {
+    listFailure = failure;
+    const result = await bridge.registerProjectLinks(input);
+    assert.equal(result.terminal.status, 'pending', `${failure} is not an empty registry`);
+    assert.equal(creations, 0, 'a failed registry read must never create a workspace');
+    assert.equal(state.modules.terminal.projectId, 'terminal-original', 'retain the last known binding');
+  }
+  listFailure = null;
+  const recovered = await bridge.registerProjectLinks(input);
+  assert.equal(recovered.terminal.projectId, 'terminal-original');
+  assert.equal(recovered.terminal.reused, true);
+  const projection = await bridge.aggregatedProjects();
+  assert.equal(projection.projects[0].modules.terminal.projectId, 'terminal-original', 'saved binding wins over duplicate path entries');
+  assert.equal(creations, 0);
+  let wiringCalls = 0;
+  const runtime = {
+    registryStore: bridge.registryStore, projectStore: bridge.projectStore,
+    moduleBridge: {
+      engineUrl: 'http://engine.test', runtimeToken: 'fixture',
+      _fetch: async () => ({ ok: true, status: 200, json: async () => ({ name: 'knowledge-engine', dataSchemaVersion: 3 }) }),
+      _listEngineProjects: async () => [{ projectId: 'project-restart', ...config }],
+      registerProjectLinks: async () => ({ engine: { ok: true }, eventBridge: { ok: true }, terminal: { ok: ++wiringCalls > 1 } }),
+      syncEngineConfiguration: async () => ({}),
+    },
+    logger: { warn: async () => {} },
+  };
+  await connectEngine(runtime);
+  assert.equal(runtime.ownership.ready, true, 'terminal recovery does not block the knowledge engine');
+  assert.equal(runtime.projectConnections.has('project-restart'), false, 'incomplete terminal wiring must remain retryable');
+  await connectEngine(runtime);
+  assert.equal(wiringCalls, 2, 'the next connection pass retries incomplete terminal wiring');
+  assert.equal(runtime.projectConnections.has('project-restart'), true);
+  console.log('module-terminal-restart-test PASS');
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/module-wiring-unbind-race-test.js

@@ -1,59 +1,59 @@
-'use strict';
-const assert = require('node:assert/strict');
-const http = require('node:http');
-const { ModuleBridge } = require('../lib/module-bridge');
-
-async function main() {
-  let releaseRegister, registerStarted, registered = true;
-  const started = new Promise(resolve => { registerStarted = resolve; });
-  const gate = new Promise(resolve => { releaseRegister = resolve; });
-  const engineProjects = new Set();
-  const calls = [];
-  const server = http.createServer(async (req, res) => {
-    req.resume();
-    if (req.method === 'POST' && req.url === '/engine/api/projects') {
-      registerStarted(); await gate;
-      engineProjects.add('project-race'); calls.push('register');
-    }
-    if (req.method === 'DELETE' && req.url === '/engine/api/projects/project-race') { engineProjects.delete('project-race'); calls.push('remove'); }
-    res.setHeader('Content-Type', 'application/json');
-    res.end(JSON.stringify({ ok: true, projects: [], id: 'terminal-race', project: { id: 'event-race' }, sequence: 0 }));
-  });
-  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
-  const base = `http://127.0.0.1:${server.address().port}`;
-  const state = { modules: {} };
-  const bridge = new ModuleBridge({ terminalUrl: base + '/terminal', vectorHubUrl: base + '/vector', eventBridgeUrl: base + '/event', engineUrl: base + '/engine', registryStore: { readDisplaySnapshot: () => registered ? { displayName: 'Race' } : null }, projectStore: { readState: () => state, readConfig: () => ({}), updateState: async (_id, apply) => { apply(state); } } });
-  try {
-    const input = { projectId: 'project-race', name: 'Race', workspacePath: process.cwd(), knowledgePath: process.cwd() };
-    const wiring = bridge.registerProjectLinks(input);
-    await started;
-    const removing = bridge.removeProjectLinks({ projectId: 'project-race', onRemoved: async () => { registered = false; } }).then(() => { registered = false; });
-    // A delayed supervisor registration must settle before removal, never after.
-    await new Promise(resolve => setTimeout(resolve, 100)); releaseRegister();
-    await Promise.all([wiring, removing]);
-    assert.deepEqual([...engineProjects], [], 'delayed wiring must not resurrect a removed engine project');
-    assert.deepEqual(calls, ['register', 'remove']);
-    const before = calls.length;
-    const stale = await bridge.registerProjectLinks(input);
-    assert.equal(calls.length, before, 'a stale registry snapshot cannot register an absent project');
-    assert.equal(stale.engine.status, 'removed');
-    assert.equal(bridge.projectWiringQueue?.size || 0, 0, 'settled operations must not leak per-project queues');
-    let releaseOther;
-    const otherGate = new Promise(resolve => { releaseOther = resolve; });
-    const order = [];
-    const held = bridge._withProjectWiring('project-a', async () => { await otherGate; order.push('a'); });
-    const independent = bridge._withProjectWiring('project-b', async () => { order.push('b'); });
-    await independent; assert.deepEqual(order, ['b'], 'unrelated projects do not share a global wiring lock');
-    releaseOther(); await held; assert.deepEqual(order, ['b', 'a']);
-    // Failed deletion keeps its registry, then a retry can still repair/remove it.
-    registered = true;
-    await assert.rejects(bridge.removeProjectLinks({ projectId: 'project-race', onRemoved: async () => { throw new Error('controlled hook conflict'); } }), /controlled hook conflict/);
-    assert.equal(registered, true);
-    await bridge.registerProjectLinks(input);
-    assert.ok(engineProjects.has('project-race'));
-    await bridge.removeProjectLinks({ projectId: 'project-race', onRemoved: async () => { registered = false; } });
-    assert.deepEqual([...engineProjects], []);
-    console.log('module-wiring-unbind-race-test PASS');
-  } finally { releaseRegister(); server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
-}
-main().catch(error => { console.error(error); process.exitCode = 1; });
+'use strict';
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { ModuleBridge } = require('../lib/module-bridge');
+
+async function main() {
+  let releaseRegister, registerStarted, registered = true;
+  const started = new Promise(resolve => { registerStarted = resolve; });
+  const gate = new Promise(resolve => { releaseRegister = resolve; });
+  const engineProjects = new Set();
+  const calls = [];
+  const server = http.createServer(async (req, res) => {
+    req.resume();
+    if (req.method === 'POST' && req.url === '/engine/api/projects') {
+      registerStarted(); await gate;
+      engineProjects.add('project-race'); calls.push('register');
+    }
+    if (req.method === 'DELETE' && req.url === '/engine/api/projects/project-race') { engineProjects.delete('project-race'); calls.push('remove'); }
+    res.setHeader('Content-Type', 'application/json');
+    res.end(JSON.stringify({ ok: true, projects: [], id: 'terminal-race', project: { id: 'event-race' }, sequence: 0 }));
+  });
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const base = `http://127.0.0.1:${server.address().port}`;
+  const state = { modules: {} };
+  const bridge = new ModuleBridge({ terminalUrl: base + '/terminal', vectorHubUrl: base + '/vector', eventBridgeUrl: base + '/event', engineUrl: base + '/engine', registryStore: { readDisplaySnapshot: () => registered ? { displayName: 'Race' } : null }, projectStore: { readState: () => state, readConfig: () => ({}), updateState: async (_id, apply) => { apply(state); } } });
+  try {
+    const input = { projectId: 'project-race', name: 'Race', workspacePath: process.cwd(), knowledgePath: process.cwd() };
+    const wiring = bridge.registerProjectLinks(input);
+    await started;
+    const removing = bridge.removeProjectLinks({ projectId: 'project-race', onRemoved: async () => { registered = false; } }).then(() => { registered = false; });
+    // A delayed supervisor registration must settle before removal, never after.
+    await new Promise(resolve => setTimeout(resolve, 100)); releaseRegister();
+    await Promise.all([wiring, removing]);
+    assert.deepEqual([...engineProjects], [], 'delayed wiring must not resurrect a removed engine project');
+    assert.deepEqual(calls, ['register', 'remove']);
+    const before = calls.length;
+    const stale = await bridge.registerProjectLinks(input);
+    assert.equal(calls.length, before, 'a stale registry snapshot cannot register an absent project');
+    assert.equal(stale.engine.status, 'removed');
+    assert.equal(bridge.projectWiringQueue?.size || 0, 0, 'settled operations must not leak per-project queues');
+    let releaseOther;
+    const otherGate = new Promise(resolve => { releaseOther = resolve; });
+    const order = [];
+    const held = bridge._withProjectWiring('project-a', async () => { await otherGate; order.push('a'); });
+    const independent = bridge._withProjectWiring('project-b', async () => { order.push('b'); });
+    await independent; assert.deepEqual(order, ['b'], 'unrelated projects do not share a global wiring lock');
+    releaseOther(); await held; assert.deepEqual(order, ['b', 'a']);
+    // Failed deletion keeps its registry, then a retry can still repair/remove it.
+    registered = true;
+    await assert.rejects(bridge.removeProjectLinks({ projectId: 'project-race', onRemoved: async () => { throw new Error('controlled hook conflict'); } }), /controlled hook conflict/);
+    assert.equal(registered, true);
+    await bridge.registerProjectLinks(input);
+    assert.ok(engineProjects.has('project-race'));
+    await bridge.removeProjectLinks({ projectId: 'project-race', onRemoved: async () => { registered = false; } });
+    assert.deepEqual([...engineProjects], []);
+    console.log('module-wiring-unbind-race-test PASS');
+  } finally { releaseRegister(); server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/native-context-integrations-test.js

@@ -1,86 +1,86 @@
-'use strict';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { IntegrationManager } = require('../lib/integration-installer');
-const { run } = require('../../plugins/project-knowledge/scripts/context-hook.cjs');
-
-async function main() {
-  const plugin = path.resolve(__dirname, '../../plugins/project-knowledge');
-  assert.equal(JSON.parse(fs.readFileSync(path.join(plugin, '.codex-plugin/plugin.json'))).hooks, './hooks/codex.json');
-  const hook = JSON.parse(fs.readFileSync(path.join(plugin, 'hooks/codex.json'))).hooks.UserPromptSubmit[0].hooks[0];
-  assert.equal(hook.additionalContextLimit, 0); assert.equal(hook.async, undefined); assert.match(hook.command, /--client codex$/);
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'native-context-integration-'));
-  try {
-    const configFile = path.join(root, '.zcode/cli/config.json'); fs.mkdirSync(path.dirname(configFile), { recursive: true });
-    const thirdParty = { type: 'process', command: 'node', args: ['third-party-hook.js'], timeoutMs: 4000 };
-    const before = { model: 'user-model', env: { USER_VALUE: 'keep' }, hooks: { enabled: true, events: { UserPromptSubmit: [{ hooks: [thirdParty] }], Stop: [{ hooks: [thirdParty] }] } } };
-    fs.writeFileSync(configFile, JSON.stringify(before));
-    let version = '5.0.9', enabled = true, trusted = false, marketplaceMode = 'git';
-    const calls = [], cache = path.join(root, 'codex-cache');
-    const manager = new IntegrationManager({ homeDir: root, zcodeConfigFile: configFile, commandResolver: name => name,
-      codexHookProbe: async () => ({ data: [{ cwd: root, errors: [], warnings: [], hooks: [{ eventName: 'userPromptSubmit', pluginId: 'project-knowledge@project-knowledge', command: hook.command, sourcePath: path.join(cache, 'hooks/codex.json'), enabled: true, trustStatus: trusted ? 'trusted' : 'untrusted' }] }] }),
-      runner: (command, args) => {
-        calls.push(args.join(' '));
-        if (args.join(' ') === 'plugin marketplace list') return { status: 0, stdout: `project-knowledge ${path.resolve(plugin, '../..')}` };
-        if (args.join(' ') === 'plugin marketplace upgrade project-knowledge' && marketplaceMode !== 'git') return { status: 1, stderr: marketplaceMode === 'local' ? 'Error: marketplace `project-knowledge` is not configured as a Git marketplace' : 'Git authentication failed' };
-        if (args.join(' ') === 'plugin list --json') return { status: 0, stdout: JSON.stringify({ installed: [{ pluginId: 'project-knowledge@project-knowledge', version, enabled, source: { path: cache } }] }) };
-        if (args.slice(0, 2).join(' ') === 'plugin add') { version = manager.version; fs.mkdirSync(cache, { recursive: true }); fs.cpSync(plugin, cache, { recursive: true }); }
-        return { status: 0, stdout: '' };
-      }
-    });
-    assert.equal(manager.statusCodex().state, 'needs-update'); manager.installCodex();
-    assert.ok(calls.includes('plugin marketplace upgrade project-knowledge')); assert.equal(manager.statusCodex().state, 'installed');
-    let automatic = await manager.automaticCodexContextStatus(manager.statusCodex(), root);
-    assert.equal(automatic.state, 'waiting-trust'); assert.equal(automatic.configured, false);
-    trusted = true; automatic = await manager.automaticCodexContextStatus(manager.statusCodex(), root); assert.equal(automatic.configured, true);
-    const count = calls.filter(c => c.startsWith('plugin add')).length; manager.installCodex(); assert.equal(calls.filter(c => c.startsWith('plugin add')).length, count);
-    enabled = false; assert.throws(() => manager.installCodex(), /禁用/); assert.equal(manager.statusCodex().state, 'disabled'); enabled = true;
-    assert.ok(calls.every(c => !/trust|bypass/.test(c)), 'installer never writes native trust or bypasses review');
-    marketplaceMode = 'local'; version = '5.0.9';
-    assert.equal(manager.installCodex().state, 'updated', 'local catalogues reload owned files without a Git refresh');
-    assert.equal(manager.statusCodex().state, 'installed');
-    marketplaceMode = 'network-failed'; version = '5.0.9';
-    const removals = calls.filter(c => c.startsWith('plugin remove')).length;
-    assert.throws(() => manager.installCodex(), /Git authentication failed/);
-    assert.equal(calls.filter(c => c.startsWith('plugin remove')).length, removals, 'an actual Git failure must not remove the working plugin or be treated as a local catalogue');
-    marketplaceMode = 'git'; version = manager.version;
-    const installed = manager.installZCode(); assert.equal(installed.state, 'installed'); manager.installZCode();
-    const current = JSON.parse(fs.readFileSync(configFile));
-    assert.equal(current.model, before.model); assert.deepEqual(current.env, before.env); assert.deepEqual(current.hooks.events.Stop, before.hooks.events.Stop);
-    assert.equal(current.hooks.events.UserPromptSubmit.length, 2); assert.deepEqual(current.hooks.events.UserPromptSubmit[0].hooks[0], thirdParty);
-    assert.equal(manager.statusZCode().installed, true); assert.equal(manager.automaticContextStatus('zcode', manager.statusZCode()).configured, true);
-    current.hooks.enabled = false; fs.writeFileSync(configFile, JSON.stringify(current)); assert.equal(manager.statusZCode().state, 'disabled'); assert.throws(() => manager.installZCode(), /禁用/);
-    current.hooks.enabled = true; fs.writeFileSync(configFile, JSON.stringify(current)); manager.uninstallZCode();
-    assert.deepEqual(JSON.parse(fs.readFileSync(configFile)), before, 'remove only the owned context entry, not capture or user config');
-    const oldScript = path.join(root, 'old-prefix/node_modules/@sanqianx/project-knowledge/plugins/project-knowledge/scripts/context-hook.cjs');
-    const oldOwned = { type: 'process', command: 'node', args: [oldScript, '--client', 'zcode'], timeoutMs: 12000 };
-    const similarThirdParty = { type: 'process', command: 'node', args: [path.join(root, 'custom/project-knowledge/scripts/context-hook.cjs'), '--client', 'zcode'] };
-    fs.writeFileSync(configFile, JSON.stringify({ ...before, hooks: { ...before.hooks, events: { ...before.hooks.events, UserPromptSubmit: [{ note: 'preserve group metadata', hooks: [thirdParty, oldOwned, similarThirdParty] }, { hooks: [oldOwned] }] } } }));
-    assert.equal(manager.statusZCode().installed, false, 'an old prefix is not current readiness');
-    manager.installZCode(); manager.installZCode();
-    const rewired = JSON.parse(fs.readFileSync(configFile));
-    const entries = rewired.hooks.events.UserPromptSubmit.flatMap(g => g.hooks);
-    assert.ok(!entries.some(h => h.args?.[0] === oldScript), 'an old managed npm path must not survive a new-prefix install');
-    assert.equal(entries.filter(h => h.args?.[0] === path.join(manager.rootDir, 'plugins/project-knowledge/scripts/context-hook.cjs')).length, 1, 'old duplicate managed entries collapse to one');
-    assert.ok(entries.some(h => JSON.stringify(h) === JSON.stringify(similarThirdParty)), 'similar third-party scripts are not owned');
-    assert.equal(rewired.hooks.events.UserPromptSubmit[0].note, 'preserve group metadata');
-    assert.deepEqual(rewired.hooks.events.Stop, before.hooks.events.Stop);
-    assert.equal(rewired.model, before.model); assert.deepEqual(rewired.env, before.env);
-    manager.uninstallZCode();
-    assert.deepEqual(JSON.parse(fs.readFileSync(configFile)).hooks.events.UserPromptSubmit[0].hooks, [thirdParty, similarThirdParty]);
-    fs.writeFileSync(configFile, '{invalid'); assert.throws(() => manager.installZCode(), /JSON/); assert.equal(fs.readFileSync(configFile, 'utf8'), '{invalid');
-    const endpoint = { schema: 'project-knowledge/runtime-endpoint/v1', host: '127.0.0.1', pid: process.pid, port: 12345, startedAt: 'test' }; fs.writeFileSync(path.join(root, 'runtime-endpoint.json'), JSON.stringify(endpoint));
-    for (const client of ['codex', 'zcode']) {
-      let input;
-      const result = await run({ cwd: root, session_id: 'session-' + client, hook_event_name: 'UserPromptSubmit', prompt: '请开发导出功能' }, { argv: ['--client', client], env: { KB_DATA_DIR: root }, fetchImpl: async (url, opts) => {
-        if (String(url).endsWith('/identity')) return Response.json({ ...endpoint, schema: 'project-knowledge/runtime-control/v1', name: 'project-knowledge', dataDir: root });
-        input = JSON.parse(opts.body); return Response.json({ ok: true, requestId: input.requestId, projectId: 'project-test', status: 'ready', prompt: '<knowledge_context>facts and memories</knowledge_context>', references: [{}], facts: [{}], memories: [{}] });
-      } });
-      assert.equal(input.client, client); assert.equal(result.hookSpecificOutput.hookEventName, 'UserPromptSubmit'); assert.match(result.hookSpecificOutput.additionalContext, /facts and memories/);
-    }
-    console.log('Native Codex/ZCode context integration, trust honesty, compatibility and preservation passed.');
-  } finally { fs.rmSync(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }); }
-}
-main().catch(error => { console.error(error); process.exitCode = 1; });
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { IntegrationManager } = require('../lib/integration-installer');
+const { run } = require('../../plugins/project-knowledge/scripts/context-hook.cjs');
+
+async function main() {
+  const plugin = path.resolve(__dirname, '../../plugins/project-knowledge');
+  assert.equal(JSON.parse(fs.readFileSync(path.join(plugin, '.codex-plugin/plugin.json'))).hooks, './hooks/codex.json');
+  const hook = JSON.parse(fs.readFileSync(path.join(plugin, 'hooks/codex.json'))).hooks.UserPromptSubmit[0].hooks[0];
+  assert.equal(hook.additionalContextLimit, 0); assert.equal(hook.async, undefined); assert.match(hook.command, /--client codex$/);
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'native-context-integration-'));
+  try {
+    const configFile = path.join(root, '.zcode/cli/config.json'); fs.mkdirSync(path.dirname(configFile), { recursive: true });
+    const thirdParty = { type: 'process', command: 'node', args: ['third-party-hook.js'], timeoutMs: 4000 };
+    const before = { model: 'user-model', env: { USER_VALUE: 'keep' }, hooks: { enabled: true, events: { UserPromptSubmit: [{ hooks: [thirdParty] }], Stop: [{ hooks: [thirdParty] }] } } };
+    fs.writeFileSync(configFile, JSON.stringify(before));
+    let version = '5.0.9', enabled = true, trusted = false, marketplaceMode = 'git';
+    const calls = [], cache = path.join(root, 'codex-cache');
+    const manager = new IntegrationManager({ homeDir: root, zcodeConfigFile: configFile, commandResolver: name => name,
+      codexHookProbe: async () => ({ data: [{ cwd: root, errors: [], warnings: [], hooks: [{ eventName: 'userPromptSubmit', pluginId: 'project-knowledge@project-knowledge', command: hook.command, sourcePath: path.join(cache, 'hooks/codex.json'), enabled: true, trustStatus: trusted ? 'trusted' : 'untrusted' }] }] }),
+      runner: (command, args) => {
+        calls.push(args.join(' '));
+        if (args.join(' ') === 'plugin marketplace list') return { status: 0, stdout: `project-knowledge ${path.resolve(plugin, '../..')}` };
+        if (args.join(' ') === 'plugin marketplace upgrade project-knowledge' && marketplaceMode !== 'git') return { status: 1, stderr: marketplaceMode === 'local' ? 'Error: marketplace `project-knowledge` is not configured as a Git marketplace' : 'Git authentication failed' };
+        if (args.join(' ') === 'plugin list --json') return { status: 0, stdout: JSON.stringify({ installed: [{ pluginId: 'project-knowledge@project-knowledge', version, enabled, source: { path: cache } }] }) };
+        if (args.slice(0, 2).join(' ') === 'plugin add') { version = manager.version; fs.mkdirSync(cache, { recursive: true }); fs.cpSync(plugin, cache, { recursive: true }); }
+        return { status: 0, stdout: '' };
+      }
+    });
+    assert.equal(manager.statusCodex().state, 'needs-update'); manager.installCodex();
+    assert.ok(calls.includes('plugin marketplace upgrade project-knowledge')); assert.equal(manager.statusCodex().state, 'installed');
+    let automatic = await manager.automaticCodexContextStatus(manager.statusCodex(), root);
+    assert.equal(automatic.state, 'waiting-trust'); assert.equal(automatic.configured, false);
+    trusted = true; automatic = await manager.automaticCodexContextStatus(manager.statusCodex(), root); assert.equal(automatic.configured, true);
+    const count = calls.filter(c => c.startsWith('plugin add')).length; manager.installCodex(); assert.equal(calls.filter(c => c.startsWith('plugin add')).length, count);
+    enabled = false; assert.throws(() => manager.installCodex(), /禁用/); assert.equal(manager.statusCodex().state, 'disabled'); enabled = true;
+    assert.ok(calls.every(c => !/trust|bypass/.test(c)), 'installer never writes native trust or bypasses review');
+    marketplaceMode = 'local'; version = '5.0.9';
+    assert.equal(manager.installCodex().state, 'updated', 'local catalogues reload owned files without a Git refresh');
+    assert.equal(manager.statusCodex().state, 'installed');
+    marketplaceMode = 'network-failed'; version = '5.0.9';
+    const removals = calls.filter(c => c.startsWith('plugin remove')).length;
+    assert.throws(() => manager.installCodex(), /Git authentication failed/);
+    assert.equal(calls.filter(c => c.startsWith('plugin remove')).length, removals, 'an actual Git failure must not remove the working plugin or be treated as a local catalogue');
+    marketplaceMode = 'git'; version = manager.version;
+    const installed = manager.installZCode(); assert.equal(installed.state, 'installed'); manager.installZCode();
+    const current = JSON.parse(fs.readFileSync(configFile));
+    assert.equal(current.model, before.model); assert.deepEqual(current.env, before.env); assert.deepEqual(current.hooks.events.Stop, before.hooks.events.Stop);
+    assert.equal(current.hooks.events.UserPromptSubmit.length, 2); assert.deepEqual(current.hooks.events.UserPromptSubmit[0].hooks[0], thirdParty);
+    assert.equal(manager.statusZCode().installed, true); assert.equal(manager.automaticContextStatus('zcode', manager.statusZCode()).configured, true);
+    current.hooks.enabled = false; fs.writeFileSync(configFile, JSON.stringify(current)); assert.equal(manager.statusZCode().state, 'disabled'); assert.throws(() => manager.installZCode(), /禁用/);
+    current.hooks.enabled = true; fs.writeFileSync(configFile, JSON.stringify(current)); manager.uninstallZCode();
+    assert.deepEqual(JSON.parse(fs.readFileSync(configFile)), before, 'remove only the owned context entry, not capture or user config');
+    const oldScript = path.join(root, 'old-prefix/node_modules/@sanqianx/project-knowledge/plugins/project-knowledge/scripts/context-hook.cjs');
+    const oldOwned = { type: 'process', command: 'node', args: [oldScript, '--client', 'zcode'], timeoutMs: 12000 };
+    const similarThirdParty = { type: 'process', command: 'node', args: [path.join(root, 'custom/project-knowledge/scripts/context-hook.cjs'), '--client', 'zcode'] };
+    fs.writeFileSync(configFile, JSON.stringify({ ...before, hooks: { ...before.hooks, events: { ...before.hooks.events, UserPromptSubmit: [{ note: 'preserve group metadata', hooks: [thirdParty, oldOwned, similarThirdParty] }, { hooks: [oldOwned] }] } } }));
+    assert.equal(manager.statusZCode().installed, false, 'an old prefix is not current readiness');
+    manager.installZCode(); manager.installZCode();
+    const rewired = JSON.parse(fs.readFileSync(configFile));
+    const entries = rewired.hooks.events.UserPromptSubmit.flatMap(g => g.hooks);
+    assert.ok(!entries.some(h => h.args?.[0] === oldScript), 'an old managed npm path must not survive a new-prefix install');
+    assert.equal(entries.filter(h => h.args?.[0] === path.join(manager.rootDir, 'plugins/project-knowledge/scripts/context-hook.cjs')).length, 1, 'old duplicate managed entries collapse to one');
+    assert.ok(entries.some(h => JSON.stringify(h) === JSON.stringify(similarThirdParty)), 'similar third-party scripts are not owned');
+    assert.equal(rewired.hooks.events.UserPromptSubmit[0].note, 'preserve group metadata');
+    assert.deepEqual(rewired.hooks.events.Stop, before.hooks.events.Stop);
+    assert.equal(rewired.model, before.model); assert.deepEqual(rewired.env, before.env);
+    manager.uninstallZCode();
+    assert.deepEqual(JSON.parse(fs.readFileSync(configFile)).hooks.events.UserPromptSubmit[0].hooks, [thirdParty, similarThirdParty]);
+    fs.writeFileSync(configFile, '{invalid'); assert.throws(() => manager.installZCode(), /JSON/); assert.equal(fs.readFileSync(configFile, 'utf8'), '{invalid');
+    const endpoint = { schema: 'project-knowledge/runtime-endpoint/v1', host: '127.0.0.1', pid: process.pid, port: 12345, startedAt: 'test' }; fs.writeFileSync(path.join(root, 'runtime-endpoint.json'), JSON.stringify(endpoint));
+    for (const client of ['codex', 'zcode']) {
+      let input;
+      const result = await run({ cwd: root, session_id: 'session-' + client, hook_event_name: 'UserPromptSubmit', prompt: '请开发导出功能' }, { argv: ['--client', client], env: { KB_DATA_DIR: root }, fetchImpl: async (url, opts) => {
+        if (String(url).endsWith('/identity')) return Response.json({ ...endpoint, schema: 'project-knowledge/runtime-control/v1', name: 'project-knowledge', dataDir: root });
+        input = JSON.parse(opts.body); return Response.json({ ok: true, requestId: input.requestId, projectId: 'project-test', status: 'ready', prompt: '<knowledge_context>facts and memories</knowledge_context>', references: [{}], facts: [{}], memories: [{}] });
+      } });
+      assert.equal(input.client, client); assert.equal(result.hookSpecificOutput.hookEventName, 'UserPromptSubmit'); assert.match(result.hookSpecificOutput.additionalContext, /facts and memories/);
+    }
+    console.log('Native Codex/ZCode context integration, trust honesty, compatibility and preservation passed.');
+  } finally { fs.rmSync(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }); }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/non-release-ci-test.js

@@ -1,34 +1,34 @@
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const workflowPath = path.join(ROOT, '.github', 'workflows', 'ci.yml');
-const workflow = fs.readFileSync(workflowPath, 'utf8');
-
-assert.match(workflow, /^\s*push:/m, 'non-release CI must run for branch pushes');
-assert.match(workflow, /^\s*pull_request:/m, 'non-release CI must run for pull requests');
-assert.match(workflow, /node:\s*\['22\.x', '24\.x'\]/, 'Linux CI must cover the declared Node >=22 contract (oldest supported 22.x plus current 24.x)');
-assert.match(workflow, /runs-on:\s*windows-latest/, 'CI must include a Windows job');
-assert.match(workflow, /npm test -- --no-report/, 'CI must run the core regression suite');
-assert.match(workflow, /npm pack --dry-run --json/, 'CI must audit the npm package contents');
-
-// Desktop development is paused by product decision (2026-08-18): the
-// non-release CI validates the web runtime only. Desktop packaging validation
-// must be restored together with desktop development; until then it must not
-// run silently under this workflow.
-assert.doesNotMatch(workflow, /npm test --prefix desktop/, 'desktop validation is paused and must not run here');
-assert.doesNotMatch(workflow, /test:packaged/, 'packaged desktop smoke is paused and must not run here');
-assert.doesNotMatch(workflow, /electron-forge|npm run make/, 'desktop packaging is paused and must not run here');
-
-for (const forbidden of [
-  /workflow_dispatch:/,
-  /^\s*tags:/m,
-  /npm\s+publish/,
-  /gh\s+release/,
-  /git\s+tag/,
-]) {
-  assert(!forbidden.test(workflow), `non-release CI contains forbidden release behavior: ${forbidden}`);
-}
-
-console.log('non-release-ci-test PASS');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const workflowPath = path.join(ROOT, '.github', 'workflows', 'ci.yml');
+const workflow = fs.readFileSync(workflowPath, 'utf8');
+
+assert.match(workflow, /^\s*push:/m, 'non-release CI must run for branch pushes');
+assert.match(workflow, /^\s*pull_request:/m, 'non-release CI must run for pull requests');
+assert.match(workflow, /node:\s*\['22\.x', '24\.x'\]/, 'Linux CI must cover the declared Node >=22 contract (oldest supported 22.x plus current 24.x)');
+assert.match(workflow, /runs-on:\s*windows-latest/, 'CI must include a Windows job');
+assert.match(workflow, /npm test -- --no-report/, 'CI must run the core regression suite');
+assert.match(workflow, /npm pack --dry-run --json/, 'CI must audit the npm package contents');
+
+// Desktop development is paused by product decision (2026-08-18): the
+// non-release CI validates the web runtime only. Desktop packaging validation
+// must be restored together with desktop development; until then it must not
+// run silently under this workflow.
+assert.doesNotMatch(workflow, /npm test --prefix desktop/, 'desktop validation is paused and must not run here');
+assert.doesNotMatch(workflow, /test:packaged/, 'packaged desktop smoke is paused and must not run here');
+assert.doesNotMatch(workflow, /electron-forge|npm run make/, 'desktop packaging is paused and must not run here');
+
+for (const forbidden of [
+  /workflow_dispatch:/,
+  /^\s*tags:/m,
+  /npm\s+publish/,
+  /gh\s+release/,
+  /git\s+tag/,
+]) {
+  assert(!forbidden.test(workflow), `non-release CI contains forbidden release behavior: ${forbidden}`);
+}
+
+console.log('non-release-ci-test PASS');

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

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