@sanqianx/project-knowledge 5.0.20 → 5.0.22

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "project-knowledge",
-      "version": "5.0.20",
+      "version": "5.0.22",
       "source": "./plugins/project-knowledge",
       "description": "Search durable project decisions and implementation history through MCP."
     }

package/CHANGELOG.md

@@ -1,6 +1,17 @@
 # Changelog
 
-## [Unreleased]
+## [5.0.22] - 2026-10-20
+
+- 将启动时的 Agent 接入检查和自动修复放入独立进程，避免慢客户端命令阻塞后台就绪通知、网页和实例控制；超时会记录可重试状态，停止服务同时清理自有检查进程。
+- 仅检查用户已连接的客户端；未能核实的状态不再当成未安装并触发自动修复。保留并排工作区、已有接入选择及知识数据。
+- 补充真实后台 CLI 在原生命令阻塞时的就绪、HTTP、状态查询和停止回归，以及超时、崩溃、手动修复结果优先级验证。
+
+## [5.0.21] - 2026-10-20
+
+- 开始工作采用并排工作区：从加号新建子代理或按需添加知识引用，使用统一的对话、工具步骤、文件修改和输入框；移除面向客户的任务标识、派发阶段及诊断信息。
+- 子代理首次发送时继承当前项目、Agent、模型及主对话的冻结上下文，之后独立交流；原生任务可从主对话打开，并基于结果继续创建子对话。
+- 知识引用仅保留会话内单一标签，检索不自动展开、不抢焦点；修复刷新时内容提前投递的问题，并跟随产品深浅主题。
+- 主子草稿、标签和阅读位置可恢复；关闭标签不停止任务，窄窗口自动使用抽屉。精确锁定 Workbench 0.13.3。
 
 - 默认维护模型明确报告额度不足时，保留并展示可重试的失败原因；请求限流、认证失败分别展示。同项目后续提交等待前一条恢复，失败及排队记录跨重启保留。
 - 事件消费在分析任务建单前受阻时，活动页与系统状态展示故障，不再只显示空记录；故障及恢复通过现有实时连接更新，稳定状态不触发额外数据轮询。

package/_site/_test/agent-capture-mcp-ui-test.js

@@ -58,10 +58,11 @@ async function main() {
     assert.equal(browser.exceptions.length, 0, JSON.stringify(browser.exceptions));
     console.log('agent-capture-mcp-ui-test PASS (MCP line rendered separately; hostile detail escaped; no XSS execution)');
   } finally {
+    runtime.integrationStatusScan?.close();
     await browser?.close(); server.closeAllConnections(); await new Promise(resolve => server.close(resolve));
     offline.closeAllConnections(); await new Promise(resolve => offline.close(resolve)); await runtime.logger.close();
     assert.equal(path.dirname(temp), path.resolve(os.tmpdir())); assert.ok(path.basename(temp).startsWith('kb-agent-mcp-ui-'));
-    fs.rmSync(temp, { recursive: true, force: true, maxRetries: 12, retryDelay: 200 });
+    await fs.promises.rm(temp, { recursive: true, force: true, maxRetries: 12, retryDelay: 200 });
   }
 }
 main().catch(error => { console.error(error.stack); process.exitCode = 1; });

package/_site/_test/agent-capture-ui-test.js

@@ -91,10 +91,11 @@ async function main() {
     assert.equal(browser.exceptions.length, 0, JSON.stringify(browser.exceptions));
     console.log(`agent-capture-ui-test PASS (1920x1080; single-switch install/repair/Hook/journal/error logs/intent/removal/light+dark; core=${coreRoot})`);
   } finally {
+    runtime.integrationStatusScan?.close();
     await browser?.close(); server.closeAllConnections(); await new Promise(resolve => server.close(resolve));
     offline.closeAllConnections(); await new Promise(resolve => offline.close(resolve)); await runtime.logger.close();
     assert.equal(path.dirname(temp), path.resolve(os.tmpdir())); assert.ok(path.basename(temp).startsWith('kb-agent-capture-ui-'));
-    fs.rmSync(temp, { recursive: true, force: true, maxRetries: 12, retryDelay: 200 });
+    await fs.promises.rm(temp, { recursive: true, force: true, maxRetries: 12, retryDelay: 200 });
   }
 }
 main().catch(error => { console.error(error.stack); process.exitCode = 1; });

package/_site/_test/fixtures/slow-startup-integration.cjs

@@ -0,0 +1,12 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const root = process.env.KB_LAUNCHER_TEST_PACKAGE || path.resolve(__dirname, '../../..');
+const { IntegrationManager } = require(path.join(root, '_site/lib/integration-installer'));
+IntegrationManager.prototype.statusAll = async function () {
+  fs.writeFileSync(process.env.KB_STARTUP_INTEGRATION_MARKER, String(process.pid));
+  // Models a synchronous native CLI probe, without running or repairing any
+  // real client integration on the developer or CI machine.
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 8000);
+  return { clients: [{ client: 'codex', developmentCapture: { installed: true } }] };
+};

package/_site/_test/fixtures/startup-repair-worker.cjs

@@ -0,0 +1,13 @@
+'use strict';
+process.once('message', input => {
+  const mode = input.managerOptions.homeDir;
+  if (mode === 'crash') return process.exit(1);
+  if (mode === 'hang') return setInterval(() => {}, 1000);
+  setTimeout(() => {
+    process.send({ ok: true, results: {
+      claude: { state: 'failed', error: 'native repair failed' },
+      codex: { state: 'repaired', error: null },
+      zcode: { state: 'failed', error: 'unrequested result' },
+    } }, () => process.disconnect());
+  }, 80);
+});

package/_site/_test/integration-auto-repair-test.js

@@ -88,5 +88,26 @@ const makeManager = ({ statusClients, onInstall }) => {
     snapshot.claude = { state: 'tampered' };
     assert.equal(repair.status().claude.state, 'repaired', 'status() returns a copy');
   }
+  {
+    const dir = tmpDataDir();
+    markIntent(dir, 'codex', 'disconnected');
+    const manager = makeManager({ statusClients: [], onInstall: () => { throw new Error('must not repair'); } });
+    const repair = new IntegrationAutoRepair({ dataDir: dir, createManager: () => manager });
+    await repair.runOnce();
+    assert.equal(manager.calls.statusAll, 0, 'disconnected clients must not run native startup probes');
+    markIntent(dir, 'codex', 'connected');
+    manager.statusAll = async options => {
+      assert.deepEqual(options.clients, ['codex']);
+      return { clients: [{ client: 'codex', developmentCapture: { state: 'check-failed' } }] };
+    };
+    await repair.runOnce();
+    assert.equal(manager.calls.installAll.length, 0, 'an unknown status must not be treated as an absent integration');
+    manager.statusAll = async () => {
+      markIntent(dir, 'codex', 'disconnected');
+      return { clients: [{ client: 'codex', developmentCapture: { installed: false } }] };
+    };
+    await repair.runOnce();
+    assert.equal(manager.calls.installAll.length, 0, 'a user disconnect during status scanning must cancel the repair');
+  }
   console.log('integration auto repair test PASS');
 })().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/knowledge-panel-lifecycle-test.js

@@ -0,0 +1,154 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const source = fs.readFileSync(path.join(__dirname, '../../ui/product.js'), 'utf8');
+const lifecycle = source.slice(source.indexOf('  function knowledgePanelFailed('), source.indexOf('  function panelRequest('))
+  + source.slice(source.indexOf('  async function resetKnowledgePanel('), source.indexOf('  function setView('));
+const settle = async () => { for (let i = 0; i < 5; i++) await new Promise(resolve => setImmediate(resolve)); };
+function harness(options = {}) {
+  const calls = [], notices = [], timers = new Map();
+  const panel = { providerId: 'knowledge', registered: true, registering: false, failed: false, error: null, panelId: '', version: 0, pending: null, sending: null, queued: false, deliveredPanelId: '' };
+  const state = { projectId: 'project-a', epoch: 0 };
+  let serial = 0, context;
+  const deliver = (id, content = null, error = null) => context.handlePanelState({ panels: id ? [{ providerId: 'knowledge', panelId: id, content, error }] : [] });
+  context = vm.createContext({
+    knowledgePanel: panel, state, frames: { terminal: { ready: true } },
+    knowledgePayload: id => ({ projectId: id, references: [{ title: state.reference || id + '-fact' }] }),
+    toast: text => notices.push(text),
+    setTimeout(fn) { timers.set(++serial, fn); return serial; }, clearTimeout: id => timers.delete(id),
+    panelRequest: async (type, payload) => {
+      calls.push({ type, payload });
+      if (options.request) {
+        const response = options.request(type, payload, { deliver, panel, state });
+        if (response !== undefined) return response;
+      }
+      if (type === 'kb:panel/register') return { ok: true };
+      if (type === 'kb:panel/content') {
+        deliver(payload.panelId, { ack: { version: payload.version, ok: true } });
+        return { ok: true };
+      }
+      throw new Error('Knowledge delivery cannot open, activate or unregister a view: ' + type);
+    },
+  });
+  vm.runInContext(lifecycle, context);
+  const show = async id => { deliver(id); await settle(); };
+  return { context, panel, state, calls, notices, timers, deliver, show };
+}
+
+test('startup registration and cached updates never create a knowledge tab', async () => {
+  const h = harness();
+  await h.context.resetKnowledgePanel();
+  assert.equal(h.panel.registered, true);
+  assert.equal(h.panel.panelId, '');
+  await h.context.pushKnowledgeToPanel();
+  h.state.projectId = 'project-b'; h.state.epoch++;
+  await h.context.pushKnowledgeToPanel();
+  assert.deepEqual(h.calls.map(call => call.type), ['kb:panel/register']);
+  assert.equal(h.timers.size, 0);
+});
+
+test('user-added tabs receive content and fast acknowledgements without opening another view', async () => {
+  const h = harness();
+  await h.show('tab-1');
+  assert.equal(h.panel.pending, null);
+  assert.equal(h.panel.deliveredPanelId, 'tab-1');
+  assert.equal(h.timers.size, 0);
+  assert.deepEqual(h.calls.map(call => call.type), ['kb:panel/content']);
+});
+
+test('closing keeps cached updates invisible until the user adds the page again', async () => {
+  const h = harness();
+  await h.show('tab-1');
+  h.deliver(null);
+  h.state.reference = 'updated while closed';
+  await h.context.pushKnowledgeToPanel();
+  assert.equal(h.panel.panelId, '');
+  assert.equal(h.calls.length, 1, 'closing or receiving knowledge must not create another view');
+  await h.show('tab-2');
+  assert.equal(h.calls.length, 2);
+  assert.equal(h.calls[1].payload.panelId, 'tab-2');
+  assert.equal(h.calls[1].payload.content.references[0].title, 'updated while closed');
+  assert.equal(h.panel.deliveredPanelId, 'tab-2');
+  h.deliver('tab-2', { ack: { version: h.panel.version, ok: true } });
+  await settle();
+  assert.equal(h.calls.length, 2, 'focus and repeated receipts cannot create a delivery loop');
+});
+
+test('errors never create an outside fallback and a newly added page can retry', async () => {
+  let first = true;
+  const h = harness({ request(type) {
+    if (type === 'kb:panel/content' && first) { first = false; return { ok: false }; }
+  } });
+  await h.show('tab-1');
+  assert.equal(h.panel.failed, true);
+  assert.equal(h.panel.registered, true, 'the page remains available in the dock selector');
+  assert.match(h.notices.join(' '), /关闭引用标签/);
+  assert.deepEqual(h.calls.map(call => call.type), ['kb:panel/content']);
+  h.deliver(null);
+  await h.show('tab-2');
+  assert.equal(h.panel.failed, false);
+  assert.equal(h.panel.deliveredPanelId, 'tab-2');
+});
+
+test('closing during a content transfer makes late replies inert', async () => {
+  let reply;
+  const h = harness({ request(type) {
+    if (type === 'kb:panel/content') return new Promise(resolve => { reply = resolve; });
+  } });
+  await h.show('tab-1');
+  h.deliver(null);
+  reply({ ok: true });
+  await settle();
+  assert.equal(h.panel.panelId, '');
+  assert.equal(h.panel.pending, null);
+  assert.equal(h.timers.size, 0);
+  assert.equal(h.calls.length, 1);
+});
+
+test('an older failed acknowledgement cannot close the current reference view', async () => {
+  const h = harness({ request(type) { if (type === 'kb:panel/content') return { ok: true }; } });
+  await h.show('tab-1');
+  await h.context.pushKnowledgeToPanel();
+  const version = h.panel.pending.version;
+  h.deliver('tab-1', { ack: { version: version - 1, ok: false } }, 'CONTENT_ACK_ERROR');
+  await settle();
+  assert.equal(h.panel.pending.version, version);
+  assert.equal(h.panel.failed, false);
+  assert.equal(h.calls.length, 2);
+  h.deliver('tab-1', { ack: { version, ok: true } });
+  assert.equal(h.panel.deliveredPanelId, 'tab-1');
+});
+
+test('a queued project switch sends only the latest scope and rejects a stale acknowledgement', async () => {
+  let oldReply;
+  const h = harness({ request(type, payload) {
+    if (type === 'kb:panel/content' && payload.content.projectId === 'project-a') return new Promise(resolve => { oldReply = resolve; });
+  } });
+  await h.show('tab-1');
+  h.state.projectId = 'project-b'; h.state.epoch++;
+  await h.context.pushKnowledgeToPanel();
+  h.deliver('tab-1', { ack: { version: 1, ok: true } });
+  assert.equal(h.panel.deliveredPanelId, '');
+  oldReply({ ok: true });
+  await settle();
+  assert.deepEqual(h.calls.map(call => call.payload.content.projectId), ['project-a', 'project-b']);
+  assert.equal(h.panel.deliveredPanelId, 'tab-1');
+  assert.equal(h.panel.pending, null);
+});
+
+test('restored inactive reference tabs wait for their page to load before content delivery', async () => {
+  const h = harness();
+  await h.context.resetKnowledgePanel();
+  h.context.handlePanelState({ panels: [{ providerId: 'knowledge', panelId: 'restored', ready: false }] });
+  await h.context.pushKnowledgeToPanel(); await settle();
+  assert.deepEqual(h.calls.map(call => call.type), ['kb:panel/register']);
+  assert.equal(h.panel.failed, false);
+  assert.equal(h.timers.size, 0);
+  h.context.handlePanelState({ panels: [{ providerId: 'knowledge', panelId: 'restored', ready: true }] });
+  await settle();
+  assert.deepEqual(h.calls.map(call => call.type), ['kb:panel/register', 'kb:panel/content']);
+  assert.equal(h.panel.deliveredPanelId, 'restored');
+});

package/_site/_test/knowledge-panel-ui-contract-test.js

@@ -1,112 +1,110 @@
-'use strict';
-// K1 knowledge panel contract: the shell registers a same-origin provider with
-// the workbench, streams structured references, folds the fixed column only
-// after a version-matched panel ack, restores it on any failure, and the panel
-// page itself renders external strings through textContent only.
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const root = path.resolve(__dirname, '../..');
-const html = fs.readFileSync(path.join(root, 'ui/index.html'), 'utf8');
-const script = fs.readFileSync(path.join(root, 'ui/product.js'), 'utf8');
-const css = fs.readFileSync(path.join(root, 'ui/product.css'), 'utf8');
-const panelPath = path.join(root, 'ui/knowledge-panel.html');
-const panelHtml = fs.readFileSync(panelPath, 'utf8');
-
-/* ===================== panel page source contract ===================== */
-assert.ok(panelHtml.includes('KB-K1-KNOWLEDGE-PANEL-v1'), 'the panel page shows the stable marker');
-assert.ok(panelHtml.includes('event.source !== window.parent'), 'the panel only accepts its Workbench parent as the message source');
-assert.ok(panelHtml.includes("data.type !== 'kb:panel/content'"), 'kb:panel/content is the only inbound verb');
-assert.ok(panelHtml.includes("'kb:panel/content-ack'"), 'the panel answers with a content ack');
-assert.ok(!panelHtml.includes('innerHTML') && !panelHtml.includes('insertAdjacentHTML') && !panelHtml.includes('document.write'), 'no string becomes markup');
-assert.ok(!/<(?:script|link|img)[^>]+(?:src|href)=/.test(panelHtml.replace(/<script>[\s\S]*?<\/script>/, '')), 'the panel page loads no external resources');
-assert.ok(!panelHtml.includes('fetch(') && !panelHtml.includes('XMLHttpRequest'), 'the sandboxed panel never talks to APIs directly');
-const panelScriptMatch = panelHtml.match(/<script>([\s\S]*?)<\/script>/);
-assert.ok(panelScriptMatch, 'the panel page carries an inline script');
-assert.doesNotThrow(() => new Function(panelScriptMatch[1]));
-
-/* ===================== panel page behavior (minimal DOM) ===================== */
-function runPanelPage() {
-  const acks = [];
-  const node = () => ({ children: [], textContent: '', append(...items) { this.children.push(...items); }, replaceChildren() { this.children.length = 0; } });
-  const elements = { panelTitle: node(), panelProject: node(), panelStatus: node(), panelReferences: node(), panelMarker: node() };
-  let listener = null;
-  const parent = { postMessage(message) { acks.push(message); } };
-  const fakeWindow = { parent, addEventListener(type, fn) { if (type === 'message') listener = fn; } };
-  const fakeDocument = {
-    getElementById: id => elements[id] || null,
-    createElement: () => node(),
-  };
-  new Function('window', 'document', panelScriptMatch[1])(fakeWindow, fakeDocument);
-  assert.equal(typeof listener, 'function', 'the panel registers a message listener');
-  const deliver = (data, source = parent) => listener({ source, data });
-  return { acks, elements, deliver };
-}
-
-{
-  const page = runPanelPage();
-  page.deliver({ type: 'kb:panel/content', panelId: 'tab-1', version: 3, content: {
-    title: '本次知识引用', projectId: 'proj-a', status: 'ready',
-    references: [{ entryId: 'docs/a.md', title: 'T', text: '<img src=x onerror=alert(1)>', source: 'proj / docs/a.md' }],
-  } });
-  const ack = page.acks[page.acks.length - 1];
-  assert.equal(ack.type, 'kb:panel/content-ack');
-  assert.equal(ack.panelId, 'tab-1');
-  assert.equal(ack.version, 3);
-  assert.equal(ack.ok, true);
-  assert.equal(page.elements.panelTitle.textContent, '本次知识引用');
-  assert.equal(page.elements.panelProject.textContent, 'proj-a');
-  const reference = page.elements.panelReferences.children[0];
-  assert.ok(reference, 'one reference card rendered');
-  const text = reference.children.find(child => child.textContent.includes('<img'));
-  assert.ok(text, 'the reference body exists');
-  assert.equal(text.textContent, '<img src=x onerror=alert(1)>', 'markup-looking strings stay inert text');
-}
-{
-  const page = runPanelPage();
-  const stranger = { postMessage() {} };
-  page.deliver({ type: 'kb:panel/content', panelId: 'tab-1', version: 1, content: { title: 'x' } }, stranger);
-  assert.equal(page.acks.length, 0, 'a non-parent source is ignored without any ack');
-  page.deliver({ type: 'kb:panel/command', panelId: 'tab-1' });
-  assert.equal(page.acks.length, 0, 'non-content verbs are ignored');
-  page.deliver({ type: 'kb:panel/content', panelId: 'tab-1', version: 2, content: ['not', 'an', 'object'] });
-  const failure = page.acks[page.acks.length - 1];
-  assert.equal(failure.ok, false, 'illegal content is refused with an explicit receipt');
-  assert.ok(failure.error, 'the refusal carries an error message');
-}
-
-/* ===================== shell (product.js) contract ===================== */
-assert.ok(script.includes('kb.knowledge.references'), 'the provider id is stable');
-assert.match(script, /url: '\/knowledge-panel\.html'/, 'the provider URL is the KB-owned panel page');
-assert.match(script, /panelType: 'knowledge', title: '本次知识引用'/, 'panel type and title match the product');
-assert.match(script, /capabilities: \['read-only'\]/, 'the panel declares itself read-only');
-assert.match(script, /multiInstance: 'single'/, 'the provider is single-instance');
-assert.match(script, /if \(message\.type === 'kb:ready'\)[\s\S]*?if \(key === 'terminal'\) void resetKnowledgePanel\(\)/, 'registration starts from the terminal kb:ready');
-assert.ok(script.includes("'kb:panel/register'") && script.includes("'kb:panel/open'") && script.includes("'kb:panel/content'"), 'the shell uses the W3 verbs');
-assert.match(script, /if \(message\.type === 'kb:knowledge' && key === 'terminal'\)[\s\S]*?renderContext\(\); void pushKnowledgeToPanel/, 'kb:knowledge still refreshes the fixed column first, then streams the panel');
-assert.match(script, /const ack = panel\.content\?\.ack;[\s\S]*?if \(ack && String\(ack\.version\) === String\(pending\.version\)\)/, 'collapse waits for the version-matched ack');
-assert.match(script, /if \(ack\.ok && !panel\.error\) \{ setKnowledgeCollapsed\(true\)/, 'folding requires an error-free ack');
-assert.match(script, /if \(!panel\) \{[\s\S]*?if \(knowledgePanel\.collapsed\) setKnowledgeCollapsed\(false\);[\s\S]*?return;/, 'closing the dock panel unfolds the fixed column again');
-assert.match(script, /function knowledgePanelFailed\(reason\)[\s\S]*?setKnowledgeCollapsed\(false\);[\s\S]*?panelNotice\(/, 'every failure path restores the full column with a non-blocking notice');
-assert.match(script, /function selectProject\(id\)[\s\S]*?setKnowledgeCollapsed\(false\);[\s\S]*?pushKnowledgeToPanel\(id\)/, 'a project switch re-scopes the panel to the new project before folding again');
-assert.match(script, /renderProjectOptions\(\); setKnowledgeCollapsed\(false\); render\(\)/, 'unbinding a project also restores the fixed column');
-assert.match(script, /\.slice\(0, 50\)\.map\(r => \(\{/, 'the payload bounds the reference count');
-assert.match(script, /text: String\(r\.text \|\| ''\)\.slice\(0, 800\)/, 'the payload bounds reference text');
-assert.match(script, /knowledgePayload\(projectId\)[\s\S]*?entryId: String\(/, 'payload fields are coerced to plain strings');
-assert.equal((script.match(/classList\.toggle\('kb-panel-collapsed'/g) || []).length, 1, 'collapse is driven only through the work-layout class');
-assert.ok(!/data-action="collapse|toggle-context|折叠知识栏/.test(script + html), 'no duplicate column control button is introduced');
-assert.match(script, /panelRequest\('kb:panel\/content', \{ panelId: knowledgePanel\.panelId, providerId: knowledgePanel\.providerId, version, content: knowledgePayload\(projectId\) \}\)/, 'content carries panelId, providerId and version');
-assert.match(script, /message\.type\.startsWith\('kb:panel\/'\)/, 'panel replies are routed before the frame-context staleness drop');
-assert.match(script, /if \(message\.requestId && message\.requestId !== frames\[key\]\.requestId\) return;/, 'the legacy staleness drop stays intact for module traffic');
-assert.doesNotThrow(() => new Function(script));
-
-/* ===================== markup and css contract ===================== */
-assert.equal((html.match(/id="panelNotice"/g) || []).length, 1, 'exactly one non-blocking panel notice exists');
-assert.ok(html.includes('knowledge-context') && html.includes('id="contextContent"'), 'the fixed knowledge column markup is untouched');
-assert.ok(css.includes('.work-layout.kb-panel-collapsed{grid-template-columns:minmax(0,1fr) 0px}'), 'the fold animates the grid track instead of removing the column');
-assert.match(css, /\.work-layout\{[^}]*transition:grid-template-columns/, 'the fold is a smooth transition');
-assert.match(css, /@media \(prefers-reduced-motion: reduce\)\{\.work-layout,\.knowledge-context\{transition:none\}\}/, 'reduced-motion users get no animation');
-assert.ok(css.includes('.panel-notice'), 'the notice has styling');
-assert.match(css, /\.work-layout\{display:grid;grid-template-columns:minmax\(0,1fr\) 288px/, 'the default full-width column is unchanged');
-
-console.log('knowledge panel UI contract test PASS (source contract + sandboxed render behavior; not browser acceptance)');
+'use strict';
+// K1 knowledge panel contract: the shell registers a same-origin provider with
+// the workbench, streams structured references only to user-added tabs,
+// validates matching receipts, never renders an outside column, and the panel
+// page itself renders external strings through textContent only.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const root = path.resolve(__dirname, '../..');
+const html = fs.readFileSync(path.join(root, 'ui/index.html'), 'utf8');
+const script = fs.readFileSync(path.join(root, 'ui/product.js'), 'utf8');
+const css = fs.readFileSync(path.join(root, 'ui/product.css'), 'utf8');
+const panelPath = path.join(root, 'ui/knowledge-panel.html');
+const panelHtml = fs.readFileSync(panelPath, 'utf8');
+
+/* ===================== panel page source contract ===================== */
+assert.ok(!panelHtml.includes('KB-K1-KNOWLEDGE-PANEL-v1'), 'test contract markers never enter customer markup');
+assert.ok(panelHtml.includes('event.source !== window.parent'), 'the panel only accepts its Workbench parent as the message source');
+assert.ok(panelHtml.includes("data.type !== 'kb:panel/content'"), 'kb:panel/content is the only inbound verb');
+assert.ok(panelHtml.includes("'kb:panel/content-ack'"), 'the panel answers with a content ack');
+assert.ok(!panelHtml.includes('innerHTML') && !panelHtml.includes('insertAdjacentHTML') && !panelHtml.includes('document.write'), 'no string becomes markup');
+assert.ok(!/<(?:script|link|img)[^>]+(?:src|href)=/.test(panelHtml.replace(/<script>[\s\S]*?<\/script>/, '')), 'the panel page loads no external resources');
+assert.ok(!panelHtml.includes('fetch(') && !panelHtml.includes('XMLHttpRequest'), 'the sandboxed panel never talks to APIs directly');
+const panelScriptMatch = panelHtml.match(/<script>([\s\S]*?)<\/script>/);
+assert.ok(panelScriptMatch, 'the panel page carries an inline script');
+assert.doesNotThrow(() => new Function(panelScriptMatch[1]));
+
+/* ===================== panel page behavior (minimal DOM) ===================== */
+function runPanelPage() {
+  const acks = [];
+  const node = () => ({ children: [], textContent: '', append(...items) { this.children.push(...items); }, replaceChildren() { this.children.length = 0; } });
+  const elements = { panelTitle: node(), panelProject: node(), panelStatus: node(), panelReferences: node(), panelMarker: node() };
+  let listener = null;
+  const parent = { postMessage(message) { acks.push(message); } };
+  const fakeWindow = { parent, addEventListener(type, fn) { if (type === 'message') listener = fn; } };
+  const fakeDocument = {
+    documentElement: { dataset: {} },
+    getElementById: id => elements[id] || null,
+    createElement: () => node(),
+  };
+  new Function('window', 'document', panelScriptMatch[1])(fakeWindow, fakeDocument);
+  assert.equal(typeof listener, 'function', 'the panel registers a message listener');
+  const deliver = (data, source = parent) => listener({ source, data });
+  return { acks, elements, deliver, document: fakeDocument };
+}
+
+{
+  const page = runPanelPage();
+  page.deliver({ type: 'kb:panel/content', panelId: 'tab-1', version: 3, content: {
+    title: '本次知识引用', projectId: 'proj-a', projectName: '项目 A', status: 'ready', theme: 'dark',
+    references: [{ entryId: 'docs/a.md', title: 'T', text: '<img src=x onerror=alert(1)>', source: 'proj / docs/a.md' }],
+  } });
+  const ack = page.acks[page.acks.length - 1];
+  assert.equal(ack.type, 'kb:panel/content-ack');
+  assert.equal(ack.panelId, 'tab-1');
+  assert.equal(ack.version, 3);
+  assert.equal(ack.ok, true);
+  assert.equal(page.elements.panelTitle.textContent, '本次知识引用');
+  assert.equal(page.elements.panelProject.textContent, '项目 A');
+  assert.equal(page.document.documentElement.dataset.theme, 'dark', 'the reference page follows the host theme');
+  const reference = page.elements.panelReferences.children[0];
+  assert.ok(reference, 'one reference card rendered');
+  assert.equal(reference.children.length, 3, 'reference cards show title, source and excerpt without a repeated internal entry identifier');
+  const text = reference.children.find(child => child.textContent.includes('<img'));
+  assert.ok(text, 'the reference body exists');
+  assert.equal(text.textContent, '<img src=x onerror=alert(1)>', 'markup-looking strings stay inert text');
+}
+{
+  const page = runPanelPage();
+  const stranger = { postMessage() {} };
+  page.deliver({ type: 'kb:panel/content', panelId: 'tab-1', version: 1, content: { title: 'x' } }, stranger);
+  assert.equal(page.acks.length, 0, 'a non-parent source is ignored without any ack');
+  page.deliver({ type: 'kb:panel/command', panelId: 'tab-1' });
+  assert.equal(page.acks.length, 0, 'non-content verbs are ignored');
+  page.deliver({ type: 'kb:panel/content', panelId: 'tab-1', version: 2, content: ['not', 'an', 'object'] });
+  const failure = page.acks[page.acks.length - 1];
+  assert.equal(failure.ok, false, 'illegal content is refused with an explicit receipt');
+  assert.ok(failure.error, 'the refusal carries an error message');
+}
+
+/* ===================== shell (product.js) contract ===================== */
+assert.ok(script.includes('kb.knowledge.references'), 'the provider id is stable');
+assert.match(script, /url: '\/knowledge-panel\.html'/, 'the provider URL is the KB-owned panel page');
+assert.match(script, /panelType: 'knowledge', title: '本次知识引用'/, 'panel type and title match the product');
+assert.match(script, /capabilities: \['read-only'\]/, 'the panel declares itself read-only');
+assert.match(script, /multiInstance: 'single'/, 'the provider is single-instance');
+assert.match(script, /if \(message\.type === 'kb:ready'\)[\s\S]*?if \(key === 'terminal'\) void resetKnowledgePanel\(\)/, 'registration starts from the terminal kb:ready');
+assert.ok(script.includes("'kb:panel/register'") && script.includes("'kb:panel/content'"), 'the host registers the page and supplies its content');
+assert.ok(!script.includes("'kb:panel/open'"), 'registration and retrieval cannot open a page');
+assert.match(script, /if \(message\.type === 'kb:knowledge' && key === 'terminal'\)[\s\S]*?state\.contexts\.set[\s\S]*?void pushKnowledgeToPanel/, 'retrieved knowledge stays cached and updates existing pages only');
+assert.match(script, /const ack = panel\.content\?\.ack;[\s\S]*?if \(ack && String\(ack\.version\) === String\(pending\.version\)\)/, 'receipts match the currently pending content');
+assert.match(script, /if \(ack\.ok && !panel\.error\) \{ knowledgePanel\.deliveredPanelId = panel\.panelId;/, 'delivery is confirmed only by an error-free acknowledgement');
+assert.match(script, /if \(!panel\) \{[\s\S]*?knowledgePanel\.panelId = '';[\s\S]*?return;/, 'closing a page cancels its delivery');
+assert.match(script, /if \(!knowledgePanel\.registered \|\| knowledgePanel\.failed \|\| !projectId \|\| !panelId\) return;/, 'closed pages cannot be opened by background updates');
+assert.ok(!/setKnowledgeCollapsed|panelNotice|contextContent|knowledge-context/.test(script), 'the old outside-column paths are removed');
+assert.match(script, /\.slice\(0, 50\)\.map\(r => \(\{/, 'the payload bounds the reference count');
+assert.match(script, /text: String\(r\.text \|\| ''\)\.slice\(0, 800\)/, 'the payload bounds reference text');
+assert.match(script, /knowledgePayload\(projectId\)[\s\S]*?entryId: String\(/, 'payload fields are coerced to plain strings');
+assert.ok(!/data-action="collapse|toggle-context|折叠知识栏/.test(script + html), 'no duplicate column control button is introduced');
+assert.match(script, /panelRequest\('kb:panel\/content', \{ panelId: knowledgePanel\.panelId, providerId: knowledgePanel\.providerId, version, content: knowledgePayload\(projectId\) \}\)/, 'content carries panelId, providerId and version');
+assert.match(script, /message\.type\.startsWith\('kb:panel\/'\)/, 'panel replies are routed before the frame-context staleness drop');
+assert.match(script, /if \(message\.requestId && message\.requestId !== frames\[key\]\.requestId\) return;/, 'the legacy staleness drop stays intact for module traffic');
+assert.doesNotThrow(() => new Function(script));
+
+/* ===================== markup and css contract ===================== */
+assert.ok(!/knowledge-context|contextContent|contextScope|panelNotice/.test(html), 'there is no outside knowledge column, including hidden markup');
+assert.ok(!/knowledge-context|kb-panel-collapsed|panel-notice/.test(css), 'no space or fallback layout is reserved for a second column');
+assert.match(css, /\.work-layout\{display:grid;grid-template-columns:minmax\(0,1fr\);/, 'the host gives the whole workspace to the conversation and its dock');
+
+console.log('knowledge panel UI contract test PASS (source contract + sandboxed render behavior; not browser acceptance)');

package/_site/_test/startup-integration-isolation-test.js

@@ -0,0 +1,59 @@
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const net = require('node:net');
+const { spawn } = require('node:child_process');
+const control = require('../lib/runtime-control');
+const { markIntent } = require('../lib/integration-intent');
+const root = process.env.KB_LAUNCHER_TEST_PACKAGE || path.resolve(__dirname, '../..');
+const data = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-startup-integration-'));
+const marker = path.join(data, 'slow-native-check.pid');
+const preload = path.join(__dirname, 'fixtures/slow-startup-integration.cjs').replace(/\\/g, '/');
+let instance;
+async function freePort() {
+  const server = net.createServer();
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+  await new Promise(resolve => server.close(resolve)); return port;
+}
+async function main() {
+  markIntent(data, 'codex', 'connected');
+  const port = await freePort();
+  const started = Date.now();
+  const launched = await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(root, 'bin/project-knowledge.js'), '--no-open', '--port', String(port)], {
+      windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, KB_DATA_DIR: data, KB_MODULES_AUTOSTART: '0',
+        KB_LAUNCHER_TEST_PACKAGE: root, KB_STARTUP_INTEGRATION_MARKER: marker,
+        AI_CODING_EVENT_BRIDGE_HOME: path.join(data, 'events'), NODE_OPTIONS: `--require="${preload}"` },
+    });
+    let stdout = '', stderr = '';
+    const timer = setTimeout(() => { child.kill(); reject(new Error('Background launch timed out')); }, 20000);
+    child.stdout.on('data', value => { stdout += value; }); child.stderr.on('data', value => { stderr += value; });
+    child.once('error', reject); child.once('exit', code => { clearTimeout(timer); resolve({ code, stdout, stderr }); });
+  });
+  assert.equal(launched.code, 0, launched.stderr);
+  instance = (await control.request(data, { action: 'status' }, 1000)).instance;
+  assert(Date.now() - started < 5000, 'native integration checks must not delay the launcher ready acknowledgement');
+  for (let i = 0; i < 60 && !fs.existsSync(marker); i++) await new Promise(resolve => setTimeout(resolve, 50));
+  assert(fs.existsSync(marker), 'startup auto repair must still run');
+  assert.notEqual(Number(fs.readFileSync(marker, 'utf8')), instance.pid, 'native checks must run outside the HTTP process');
+  for (let i = 0; i < 3; i++) {
+    const response = await fetch(`http://127.0.0.1:${port}/api/health`, { signal: AbortSignal.timeout(1000) });
+    assert.equal(response.status, 200, 'HTTP must remain usable while a native check is blocked');
+    assert.equal((await control.request(data, { action: 'status' }, 1000)).instance.pid, instance.pid);
+  }
+  const stopAt = Date.now();
+  await control.request(data, { action: 'stop', pid: instance.pid, port, startedAt: instance.startedAt }, 4000);
+  assert(Date.now() - stopAt < 4000, 'shutdown must cancel the blocked repair worker');
+  instance = null;
+  console.log('Startup integration isolation PASS: background ready, HTTP/control usable during a blocked native probe, owned worker stopped');
+}
+main().catch(error => { console.error(error); process.exitCode = 1; }).finally(async () => {
+  try {
+    const info = instance || (await control.request(data, { action: 'status' }, 1000)).instance;
+    await control.request(data, { action: 'stop', pid: info.pid, port: info.port, startedAt: info.startedAt });
+  } catch {}
+});