@sanqianx/project-knowledge 5.0.23 → 5.0.25

package/_site/_test/claude-workbench-test.js

@@ -1,174 +1,174 @@
-// Claude workbench regression test.
-//
-// Verifies session metadata and the SDK-only session lifecycle. The legacy
-// `claude -p` subprocess path was removed in the CC-Switch migration, so
-// the pre-turn `requirePermission` flow no longer exists — the SDK path
-// shows permission prompts via canUseTool only when an individual tool
-// is actually invoked. Tool-level prompts are exercised by the chat
-// panel integration tests.
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const TEST_DATA = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-workbench-unit-'));
-process.env.KB_DATA_DIR = TEST_DATA;
-process.on('exit', () => fs.rmSync(TEST_DATA, { recursive: true, force: true }));
-const runner = require('../lib/claude-cli-runner');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const TEMP_KB = path.join(ROOT, 'projects', 'claude-workbench-test-temp');
-const TEMP_AI = path.join(ROOT, '_site', '_ai', 'claude-workbench-test-temp');
-
-function assert(cond, msg) {
-  if (!cond) throw new Error(msg);
-}
-
-(async () => {
-  fs.rmSync(TEMP_KB, { recursive: true, force: true });
-  fs.rmSync(TEMP_AI, { recursive: true, force: true });
-  fs.mkdirSync(TEMP_KB, { recursive: true });
-
-  // 1. Default initial-analysis turn: SDK is the only mode. The session
-  //    should be created without any pre-turn permission prompt (the
-  //    SDK surfaces tool approvals lazily through canUseTool).
-  const started = runner.startSession({
-    slug: 'claude-workbench-test-temp',
-    projectPath: ROOT,
-    kbPath: TEMP_KB,
-    promptKey: 'initial-analysis',
-    aiProfile: {
-      id: 'test-profile',
-      implementation: 'claude-code-agent',
-      mainModel: 'test-model',
-    },
-    vars: {
-      SLUG: 'claude-workbench-test-temp',
-      PROJECT_PATH: ROOT,
-      PRIMARY_LANGUAGE: 'JavaScript',
-      KNOWLEDGE_LANGUAGE: 'zh-CN',
-    },
-  });
-
-  assert(started.sessionId, 'startSession should return sessionId');
-  assert(!started.pendingPermission,
-    'SDK mode should not show a pre-turn UI permission prompt');
-  assert(started.runner === 'sdk',
-    `startSession should default to runner: 'sdk', got ${started.runner}`);
-
-  const state = runner.getState(started.sessionId);
-  assert(state.runner === 'sdk',
-    `session state should record runner: 'sdk', got ${state.runner}`);
-
-  runner.deleteSession(started.sessionId);
-
-  // 1b. The embedded terminal should be able to create an idle chat
-  //     session without reading claude-prompts.json or running an
-  //     initial-analysis prompt. The user's first typed message starts
-  //     the actual SDK turn via sendInput.
-  const chat = runner.startChatSession({
-    slug: 'claude-workbench-test-temp',
-    projectPath: ROOT,
-    kbPath: TEMP_KB,
-    aiProfile: {
-      id: 'test-profile',
-      implementation: 'claude-code-agent',
-      mainModel: 'test-model',
-    },
-    permissionMode: 'default',
-  });
-  assert(chat.sessionId, 'startChatSession should return sessionId');
-  const chatState = runner.getState(chat.sessionId);
-  assert(chatState.promptKey === 'terminal-chat',
-    `chat session should use terminal-chat promptKey, got ${chatState.promptKey}`);
-  assert(chatState.state === 'idle',
-    `chat session should stay idle until user input, got ${chatState.state}`);
-  assert(chatState.turns === 0, `chat session should not start a turn, got turns=${chatState.turns}`);
-
-  // 1c. Switching AI profiles mid-session must not resume the old upstream
-  //     Claude conversation with the new provider. That used to send the
-  //     previous model (for example MiniMax-M3) to the new base URL (for
-  //     example GLM), producing "model not found" API errors.
-  const chatSession = runner.getSession(chat.sessionId);
-  chatSession.aiProfileId = 'minimax-m3';
-  chatSession.model = 'MiniMax-M3';
-  chatSession.claudeSessionId = 'old-claude-session-id';
-  const switched = runner.applyAiProfileToSession(chatSession, {
-    id: 'glm',
-    implementation: 'claude-code-agent',
-    mainModel: 'glm-5.2',
-  });
-  const switchedState = runner.getState(chat.sessionId);
-  assert(switched.resetConversation === true, 'profile switch should reset the upstream conversation');
-  assert(switchedState.claudeSessionId === null, 'profile switch should clear stale claudeSessionId');
-  assert(switchedState.aiProfileId === 'glm', `profile switch should update aiProfileId, got ${switchedState.aiProfileId}`);
-  assert(switchedState.model === 'glm-5.2', `profile switch should update model, got ${switchedState.model}`);
-  runner.deleteSession(chat.sessionId);
-
-  // Session metadata uses durable atomic replacement, but a disk fault must
-  // remain fail-open for the live Workbench session and become observable.
-  const AtomicFile = require('../lib/atomic-file');
-  const originalAtomicWrite = AtomicFile.writeJsonAtomic;
-  const persistenceLogs = [];
-  runner.setLogger({ error: async (event, message, payload) => { persistenceLogs.push({ event, message, payload }); } });
-  AtomicFile.writeJsonAtomic = () => { throw Object.assign(new Error('simulated disk full'), { code: 'ENOSPC' }); };
-  let persistenceFaultSession;
-  try {
-    persistenceFaultSession = runner.createSession({
-      projectSlug: 'claude-workbench-test-temp', projectPath: ROOT, kbPath: TEMP_KB, promptKey: 'terminal-chat',
-    });
-    assert(persistenceFaultSession.sessionId, 'persistence failure must not interrupt the live session');
-    assert(persistenceLogs.some(entry => entry.event === 'claude.session_persist_failed' && entry.payload.error.code === 'ENOSPC'), 'persistence failure must be structured and correlated');
-  } finally {
-    AtomicFile.writeJsonAtomic = originalAtomicWrite;
-    runner.setLogger(null);
-    if (persistenceFaultSession) runner.deleteSession(persistenceFaultSession.sessionId);
-  }
-
-  const executable = await runner.findClaudeExecutableForSdk();
-  if (process.platform === 'win32' && executable.cmd) {
-    assert(!/\.(cmd|bat|ps1)$/i.test(executable.cmd),
-      `SDK executable must not be a Windows shell shim: ${executable.cmd}`);
-  }
-
-  // 2. Automation raw prompt sessions must preserve the selected permission
-  //    mode. This guards against regressing back to bypassPermissions -> default.
-  process.env.KB_AUTOMATION_FAKE_CLAUDE = '1';
-  const auto = runner.startAutomationSession({
-    slug: 'claude-workbench-test-temp',
-    projectPath: ROOT,
-    kbPath: TEMP_KB,
-    userPrompt: 'automation test prompt',
-    systemPrompt: 'automation system prompt',
-    aiProfile: {
-      id: 'test-profile',
-      implementation: 'claude-code-agent',
-      mainModel: 'test-model',
-    },
-    permissionMode: 'bypassPermissions',
-    allowedTools: ['Read'],
-    safetyPolicy: {
-      kind: 'kb-automation',
-      kbPath: TEMP_KB,
-      knowledgeMode: 'requestApproval',
-      allowReadOnlyBash: false,
-      allowedTools: ['Read'],
-      canWriteKb: false,
-    },
-    metadata: { automation: true, automationRunId: 'auto-test', source: 'test' },
-  });
-  const autoState = runner.getState(auto.sessionId);
-  assert(autoState.permissionMode === 'bypassPermissions',
-    `automation session should preserve bypassPermissions, got ${autoState.permissionMode}`);
-  assert(autoState.automation === true, 'automation session should be marked automation=true');
-  runner.deleteSession(auto.sessionId);
-  delete process.env.KB_AUTOMATION_FAKE_CLAUDE;
-
-  fs.rmSync(TEMP_KB, { recursive: true, force: true });
-  fs.rmSync(TEMP_AI, { recursive: true, force: true });
-  console.log('Claude workbench test passed');
-})().catch(err => {
-  try { fs.rmSync(TEMP_KB, { recursive: true, force: true }); } catch {}
-  try { fs.rmSync(TEMP_AI, { recursive: true, force: true }); } catch {}
-  console.error(err);
-  process.exit(1);
-});
+// Claude workbench regression test.
+//
+// Verifies session metadata and the SDK-only session lifecycle. The legacy
+// `claude -p` subprocess path was removed in the CC-Switch migration, so
+// the pre-turn `requirePermission` flow no longer exists — the SDK path
+// shows permission prompts via canUseTool only when an individual tool
+// is actually invoked. Tool-level prompts are exercised by the chat
+// panel integration tests.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const TEST_DATA = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-workbench-unit-'));
+process.env.KB_DATA_DIR = TEST_DATA;
+process.on('exit', () => fs.rmSync(TEST_DATA, { recursive: true, force: true }));
+const runner = require('../lib/claude-cli-runner');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const TEMP_KB = path.join(ROOT, 'projects', 'claude-workbench-test-temp');
+const TEMP_AI = path.join(ROOT, '_site', '_ai', 'claude-workbench-test-temp');
+
+function assert(cond, msg) {
+  if (!cond) throw new Error(msg);
+}
+
+(async () => {
+  fs.rmSync(TEMP_KB, { recursive: true, force: true });
+  fs.rmSync(TEMP_AI, { recursive: true, force: true });
+  fs.mkdirSync(TEMP_KB, { recursive: true });
+
+  // 1. Default initial-analysis turn: SDK is the only mode. The session
+  //    should be created without any pre-turn permission prompt (the
+  //    SDK surfaces tool approvals lazily through canUseTool).
+  const started = runner.startSession({
+    slug: 'claude-workbench-test-temp',
+    projectPath: ROOT,
+    kbPath: TEMP_KB,
+    promptKey: 'initial-analysis',
+    aiProfile: {
+      id: 'test-profile',
+      implementation: 'claude-code-agent',
+      mainModel: 'test-model',
+    },
+    vars: {
+      SLUG: 'claude-workbench-test-temp',
+      PROJECT_PATH: ROOT,
+      PRIMARY_LANGUAGE: 'JavaScript',
+      KNOWLEDGE_LANGUAGE: 'zh-CN',
+    },
+  });
+
+  assert(started.sessionId, 'startSession should return sessionId');
+  assert(!started.pendingPermission,
+    'SDK mode should not show a pre-turn UI permission prompt');
+  assert(started.runner === 'sdk',
+    `startSession should default to runner: 'sdk', got ${started.runner}`);
+
+  const state = runner.getState(started.sessionId);
+  assert(state.runner === 'sdk',
+    `session state should record runner: 'sdk', got ${state.runner}`);
+
+  runner.deleteSession(started.sessionId);
+
+  // 1b. The embedded terminal should be able to create an idle chat
+  //     session without reading claude-prompts.json or running an
+  //     initial-analysis prompt. The user's first typed message starts
+  //     the actual SDK turn via sendInput.
+  const chat = runner.startChatSession({
+    slug: 'claude-workbench-test-temp',
+    projectPath: ROOT,
+    kbPath: TEMP_KB,
+    aiProfile: {
+      id: 'test-profile',
+      implementation: 'claude-code-agent',
+      mainModel: 'test-model',
+    },
+    permissionMode: 'default',
+  });
+  assert(chat.sessionId, 'startChatSession should return sessionId');
+  const chatState = runner.getState(chat.sessionId);
+  assert(chatState.promptKey === 'terminal-chat',
+    `chat session should use terminal-chat promptKey, got ${chatState.promptKey}`);
+  assert(chatState.state === 'idle',
+    `chat session should stay idle until user input, got ${chatState.state}`);
+  assert(chatState.turns === 0, `chat session should not start a turn, got turns=${chatState.turns}`);
+
+  // 1c. Switching AI profiles mid-session must not resume the old upstream
+  //     Claude conversation with the new provider. That used to send the
+  //     previous model (for example MiniMax-M3) to the new base URL (for
+  //     example GLM), producing "model not found" API errors.
+  const chatSession = runner.getSession(chat.sessionId);
+  chatSession.aiProfileId = 'minimax-m3';
+  chatSession.model = 'MiniMax-M3';
+  chatSession.claudeSessionId = 'old-claude-session-id';
+  const switched = runner.applyAiProfileToSession(chatSession, {
+    id: 'glm',
+    implementation: 'claude-code-agent',
+    mainModel: 'glm-5.2',
+  });
+  const switchedState = runner.getState(chat.sessionId);
+  assert(switched.resetConversation === true, 'profile switch should reset the upstream conversation');
+  assert(switchedState.claudeSessionId === null, 'profile switch should clear stale claudeSessionId');
+  assert(switchedState.aiProfileId === 'glm', `profile switch should update aiProfileId, got ${switchedState.aiProfileId}`);
+  assert(switchedState.model === 'glm-5.2', `profile switch should update model, got ${switchedState.model}`);
+  runner.deleteSession(chat.sessionId);
+
+  // Session metadata uses durable atomic replacement, but a disk fault must
+  // remain fail-open for the live Workbench session and become observable.
+  const AtomicFile = require('../lib/atomic-file');
+  const originalAtomicWrite = AtomicFile.writeJsonAtomic;
+  const persistenceLogs = [];
+  runner.setLogger({ error: async (event, message, payload) => { persistenceLogs.push({ event, message, payload }); } });
+  AtomicFile.writeJsonAtomic = () => { throw Object.assign(new Error('simulated disk full'), { code: 'ENOSPC' }); };
+  let persistenceFaultSession;
+  try {
+    persistenceFaultSession = runner.createSession({
+      projectSlug: 'claude-workbench-test-temp', projectPath: ROOT, kbPath: TEMP_KB, promptKey: 'terminal-chat',
+    });
+    assert(persistenceFaultSession.sessionId, 'persistence failure must not interrupt the live session');
+    assert(persistenceLogs.some(entry => entry.event === 'claude.session_persist_failed' && entry.payload.error.code === 'ENOSPC'), 'persistence failure must be structured and correlated');
+  } finally {
+    AtomicFile.writeJsonAtomic = originalAtomicWrite;
+    runner.setLogger(null);
+    if (persistenceFaultSession) runner.deleteSession(persistenceFaultSession.sessionId);
+  }
+
+  const executable = await runner.findClaudeExecutableForSdk();
+  if (process.platform === 'win32' && executable.cmd) {
+    assert(!/\.(cmd|bat|ps1)$/i.test(executable.cmd),
+      `SDK executable must not be a Windows shell shim: ${executable.cmd}`);
+  }
+
+  // 2. Automation raw prompt sessions must preserve the selected permission
+  //    mode. This guards against regressing back to bypassPermissions -> default.
+  process.env.KB_AUTOMATION_FAKE_CLAUDE = '1';
+  const auto = runner.startAutomationSession({
+    slug: 'claude-workbench-test-temp',
+    projectPath: ROOT,
+    kbPath: TEMP_KB,
+    userPrompt: 'automation test prompt',
+    systemPrompt: 'automation system prompt',
+    aiProfile: {
+      id: 'test-profile',
+      implementation: 'claude-code-agent',
+      mainModel: 'test-model',
+    },
+    permissionMode: 'bypassPermissions',
+    allowedTools: ['Read'],
+    safetyPolicy: {
+      kind: 'kb-automation',
+      kbPath: TEMP_KB,
+      knowledgeMode: 'requestApproval',
+      allowReadOnlyBash: false,
+      allowedTools: ['Read'],
+      canWriteKb: false,
+    },
+    metadata: { automation: true, automationRunId: 'auto-test', source: 'test' },
+  });
+  const autoState = runner.getState(auto.sessionId);
+  assert(autoState.permissionMode === 'bypassPermissions',
+    `automation session should preserve bypassPermissions, got ${autoState.permissionMode}`);
+  assert(autoState.automation === true, 'automation session should be marked automation=true');
+  runner.deleteSession(auto.sessionId);
+  delete process.env.KB_AUTOMATION_FAKE_CLAUDE;
+
+  fs.rmSync(TEMP_KB, { recursive: true, force: true });
+  fs.rmSync(TEMP_AI, { recursive: true, force: true });
+  console.log('Claude workbench test passed');
+})().catch(err => {
+  try { fs.rmSync(TEMP_KB, { recursive: true, force: true }); } catch {}
+  try { fs.rmSync(TEMP_AI, { recursive: true, force: true }); } catch {}
+  console.error(err);
+  process.exit(1);
+});

package/_site/_test/cli-instance-management-test.js

@@ -1,62 +1,62 @@
-'use strict';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const http = require('node:http');
-const { spawn } = require('node:child_process');
-const endpoint = require('../lib/runtime-endpoint');
-const control = require('../lib/runtime-control');
-const packageRoot = process.env.KB_CLI_TEST_PACKAGE || path.resolve(__dirname, '../..');
-const bin = path.join(packageRoot, 'bin/project-knowledge.js');
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-instance-management-'));
-const a = path.join(root, '知识库 A'), b = path.join(root, '知识库 B');
-const temp = path.join(root, 'isolated-temp'); fs.mkdirSync(temp);
-const env = { ...process.env, KB_DATA_DIR: a, TEMP: temp, TMP: temp, KB_MODULES_AUTOSTART: '0', AI_CODING_EVENT_BRIDGE_HOME: path.join(root, 'bridge') };
-const pids = [];
-function run(args) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [bin, ...args], { cwd: root, env, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
-    let stdout = '', stderr = '';
-    const timer = setTimeout(() => { child.kill(); reject(new Error(`CLI timeout: ${stdout} ${stderr}`)); }, 25000);
-    child.stdout.on('data', c => { stdout += c; }); child.stderr.on('data', c => { stderr += c; });
-    child.once('error', reject); child.once('exit', code => { clearTimeout(timer); resolve({ code, stdout, stderr }); });
-  });
-}
-async function usable(port) { try { return (await fetch(`http://127.0.0.1:${port}/api/health`, { signal: AbortSignal.timeout(700) })).ok; } catch { return false; } }
-let foreign;
-(async () => {
-  foreign = http.createServer((req, res) => { res.writeHead(404); res.end('not knowledge'); });
-  await new Promise(resolve => foreign.listen(0, '127.0.0.1', resolve));
-  const foreignPort = foreign.address().port;
-  fs.writeFileSync(path.join(temp, '.project-knowledge.pid'), `${process.pid}\n${foreignPort}`);
-  for (const args of [['stoop'], ['STOP', 'unexpected'], ['stop', '--port', '12junk'], ['stop', '--port', '65536'], ['stop', '--port'], ['stop', '--all']]) {
-    const result = await run(args); assert.equal(result.code, 1, JSON.stringify(result));
-    assert(!/Already running|starting in background/.test(result.stdout));
-  }
-  assert.equal(fs.existsSync(a), false, 'invalid commands must not create data or services');
-  const noInstance = await run(['STOP']); assert.equal(noInstance.code, 0); assert.match(noInstance.stdout, /No background/);
-  assert.equal(await usable(foreignPort), false); assert(foreign.listening, 'shared legacy PID must not kill an unrelated process');
-  const launchedA = await run(['START', '--no-open']); assert.equal(launchedA.code, 0, launchedA.stderr);
-  const infoA = endpoint.readEndpoint(a); pids.push(infoA.pid); assert(await usable(infoA.port));
-  const launchedB = await run(['start', '--data', b, '--no-open']); assert.equal(launchedB.code, 0, launchedB.stderr);
-  const infoB = endpoint.readEndpoint(b); pids.push(infoB.pid); assert(await usable(infoB.port)); assert.notEqual(infoA.port, infoB.port);
-  const status = await run(['STATUS']); assert.equal(status.code, 0); assert.match(status.stdout, new RegExp(`PID ${infoA.pid}`));
-  const inventory = await run(['STATUS', '--all']); assert.equal(inventory.code, 0, inventory.stderr);
-  assert.match(inventory.stdout, new RegExp(`PID ${infoA.pid}`)); assert.match(inventory.stdout, new RegExp(`PID ${infoB.pid}`));
-  const wrongPort = await run(['STOP', '--port', String(foreignPort)]); assert.equal(wrongPort.code, 1); assert(foreign.listening);
-  const conflict = await run(['stop', '--data', a, '--port', String(infoB.port)]); assert.equal(conflict.code, 1); assert(await usable(infoB.port));
-  await assert.rejects(() => control.request(a, { action: 'stop', pid: infoA.pid + 1, port: infoA.port, startedAt: infoA.startedAt }), /身份/);
-  assert(await usable(infoA.port));
-  const stoppedA = await run(['STOP']); assert.equal(stoppedA.code, 0, stoppedA.stderr); assert.match(stoppedA.stdout, new RegExp(`:${infoA.port}`));
-  assert.equal(await usable(infoA.port), false); assert(await usable(infoB.port), 'default stop must preserve a different data directory');
-  const stoppedB = await run(['stop', '--port', String(infoB.port)]); assert.equal(stoppedB.code, 0, stoppedB.stderr); assert.equal(await usable(infoB.port), false);
-  assert.equal((await run(['stop'])).code, 0, 'repeated stop is harmless');
-  fs.writeFileSync(path.join(a, 'runtime-endpoint.json'), JSON.stringify({ schema: endpoint.SCHEMA, pid: process.pid, host: '127.0.0.1', port: foreignPort }));
-  const stale = await run(['STOP']); assert.equal(stale.code, 1); assert.match(stale.stderr, /控制通道不可用/); assert(foreign.listening, 'a live but unrelated recorded PID is never signaled');
-  const refused = await run(['start', '--no-open']); assert.equal(refused.code, 1); assert(foreign.listening);
-  console.log('CLI instance management PASS: case, strict arguments, inventory, two directories, targeted stop, spoof protection, stale/shared PID safety');
-})().catch(error => { console.error(error); process.exitCode = 1; }).finally(async () => {
-  foreign?.closeAllConnections(); if (foreign?.listening) await new Promise(resolve => foreign.close(resolve));
-  for (const data of [a, b]) try { const info = await control.request(data, { action: 'status' }, 500); await control.request(data, { action: 'stop', pid: info.instance.pid, port: info.instance.port, startedAt: info.instance.startedAt }); } catch {}
-});
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const http = require('node:http');
+const { spawn } = require('node:child_process');
+const endpoint = require('../lib/runtime-endpoint');
+const control = require('../lib/runtime-control');
+const packageRoot = process.env.KB_CLI_TEST_PACKAGE || path.resolve(__dirname, '../..');
+const bin = path.join(packageRoot, 'bin/project-knowledge.js');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-instance-management-'));
+const a = path.join(root, '知识库 A'), b = path.join(root, '知识库 B');
+const temp = path.join(root, 'isolated-temp'); fs.mkdirSync(temp);
+const env = { ...process.env, KB_DATA_DIR: a, TEMP: temp, TMP: temp, KB_MODULES_AUTOSTART: '0', AI_CODING_EVENT_BRIDGE_HOME: path.join(root, 'bridge') };
+const pids = [];
+function run(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [bin, ...args], { cwd: root, env, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    let stdout = '', stderr = '';
+    const timer = setTimeout(() => { child.kill(); reject(new Error(`CLI timeout: ${stdout} ${stderr}`)); }, 25000);
+    child.stdout.on('data', c => { stdout += c; }); child.stderr.on('data', c => { stderr += c; });
+    child.once('error', reject); child.once('exit', code => { clearTimeout(timer); resolve({ code, stdout, stderr }); });
+  });
+}
+async function usable(port) { try { return (await fetch(`http://127.0.0.1:${port}/api/health`, { signal: AbortSignal.timeout(700) })).ok; } catch { return false; } }
+let foreign;
+(async () => {
+  foreign = http.createServer((req, res) => { res.writeHead(404); res.end('not knowledge'); });
+  await new Promise(resolve => foreign.listen(0, '127.0.0.1', resolve));
+  const foreignPort = foreign.address().port;
+  fs.writeFileSync(path.join(temp, '.project-knowledge.pid'), `${process.pid}\n${foreignPort}`);
+  for (const args of [['stoop'], ['STOP', 'unexpected'], ['stop', '--port', '12junk'], ['stop', '--port', '65536'], ['stop', '--port'], ['stop', '--all']]) {
+    const result = await run(args); assert.equal(result.code, 1, JSON.stringify(result));
+    assert(!/Already running|starting in background/.test(result.stdout));
+  }
+  assert.equal(fs.existsSync(a), false, 'invalid commands must not create data or services');
+  const noInstance = await run(['STOP']); assert.equal(noInstance.code, 0); assert.match(noInstance.stdout, /No background/);
+  assert.equal(await usable(foreignPort), false); assert(foreign.listening, 'shared legacy PID must not kill an unrelated process');
+  const launchedA = await run(['START', '--no-open']); assert.equal(launchedA.code, 0, launchedA.stderr);
+  const infoA = endpoint.readEndpoint(a); pids.push(infoA.pid); assert(await usable(infoA.port));
+  const launchedB = await run(['start', '--data', b, '--no-open']); assert.equal(launchedB.code, 0, launchedB.stderr);
+  const infoB = endpoint.readEndpoint(b); pids.push(infoB.pid); assert(await usable(infoB.port)); assert.notEqual(infoA.port, infoB.port);
+  const status = await run(['STATUS']); assert.equal(status.code, 0); assert.match(status.stdout, new RegExp(`PID ${infoA.pid}`));
+  const inventory = await run(['STATUS', '--all']); assert.equal(inventory.code, 0, inventory.stderr);
+  assert.match(inventory.stdout, new RegExp(`PID ${infoA.pid}`)); assert.match(inventory.stdout, new RegExp(`PID ${infoB.pid}`));
+  const wrongPort = await run(['STOP', '--port', String(foreignPort)]); assert.equal(wrongPort.code, 1); assert(foreign.listening);
+  const conflict = await run(['stop', '--data', a, '--port', String(infoB.port)]); assert.equal(conflict.code, 1); assert(await usable(infoB.port));
+  await assert.rejects(() => control.request(a, { action: 'stop', pid: infoA.pid + 1, port: infoA.port, startedAt: infoA.startedAt }), /身份/);
+  assert(await usable(infoA.port));
+  const stoppedA = await run(['STOP']); assert.equal(stoppedA.code, 0, stoppedA.stderr); assert.match(stoppedA.stdout, new RegExp(`:${infoA.port}`));
+  assert.equal(await usable(infoA.port), false); assert(await usable(infoB.port), 'default stop must preserve a different data directory');
+  const stoppedB = await run(['stop', '--port', String(infoB.port)]); assert.equal(stoppedB.code, 0, stoppedB.stderr); assert.equal(await usable(infoB.port), false);
+  assert.equal((await run(['stop'])).code, 0, 'repeated stop is harmless');
+  fs.writeFileSync(path.join(a, 'runtime-endpoint.json'), JSON.stringify({ schema: endpoint.SCHEMA, pid: process.pid, host: '127.0.0.1', port: foreignPort }));
+  const stale = await run(['STOP']); assert.equal(stale.code, 1); assert.match(stale.stderr, /控制通道不可用/); assert(foreign.listening, 'a live but unrelated recorded PID is never signaled');
+  const refused = await run(['start', '--no-open']); assert.equal(refused.code, 1); assert(foreign.listening);
+  console.log('CLI instance management PASS: case, strict arguments, inventory, two directories, targeted stop, spoof protection, stale/shared PID safety');
+})().catch(error => { console.error(error); process.exitCode = 1; }).finally(async () => {
+  foreign?.closeAllConnections(); if (foreign?.listening) await new Promise(resolve => foreign.close(resolve));
+  for (const data of [a, b]) try { const info = await control.request(data, { action: 'status' }, 500); await control.request(data, { action: 'stop', pid: info.instance.pid, port: info.instance.port, startedAt: info.instance.startedAt }); } catch {}
+});