@sanqianx/project-knowledge 4.7.0 → 4.8.0

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

@@ -1,170 +1,170 @@
-// 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 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 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/codex-conversation-projection-test.js

@@ -52,7 +52,8 @@ assert.strictEqual(projected.find(item => item.eventId === 'next-user').developm
 assert.strictEqual(projected.find(item => item.eventId === 'orphan').turnId, null, 'never pair across Codex sessions');
 assert.strictEqual(JSON.stringify(raw), before, 'projection must not rewrite durable source events');
 
-const uiSource = fs.readFileSync(path.resolve(__dirname, '..', '..', 'ui', 'app.js'), 'utf8');
+const uiSource = fs.readFileSync(path.resolve(__dirname, '..', '..', 'ui', 'product.js'), 'utf8');
+assert(uiSource.includes('/modules/eventbridge/'), 'conversation rendering must remain in the native event-bridge UI');
 assert(!uiSource.includes('（无用户文本）'), 'UI must not invent a user message for an assistant-only record');
 assert(!uiSource.includes('（尚无回复）'), 'UI must not invent an assistant reply for an incomplete turn');
 

package/_site/_test/commit-conversation-binding-test.js

@@ -1,99 +1,99 @@
-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-conversation-binding-'));
-  const layout = new StorageLayout({ dataDir: path.join(root, 'data') });
-  const projectStore = new ProjectStore({ layout });
-  const projectId = 'project-binding';
-  const repoIdentity = { commonDir: path.join(root, 'repo', '.git') };
-  await projectStore.create(projectId, {
-    displayName: 'Binding',
-    storageName: 'binding',
-    repoPath: path.join(root, 'repo'),
-    knowledgePath: path.join(root, 'knowledge'),
-    repoIdentity,
-  }, { conversationBaselineCursor: 0, conversation: { lastConsumedCursor: 0, captureStatus: 'captured' } });
-  const store = new ConversationStore({ layout, projectStore });
-  const binder = new CommitConversationBinder({ layout, projectStore, conversationStore: store });
-  const c1 = '1'.repeat(40);
-  const c2 = '2'.repeat(40);
-  const c3 = '3'.repeat(40);
-  const cMerge = '4'.repeat(40);
-  const cAmbiguous = '5'.repeat(40);
-
-  const append = input => store.appendEvent(projectId, {
-    source: 'codex',
-    sessionId: 'session-1',
-    projectPath: path.join(root, 'repo'),
-    repoIdentity,
-    branch: 'main',
-    headAtCapture: '0'.repeat(40),
-    capturedAt: `2026-08-18T02:${String(input.sequence || 0).padStart(2, '0')}:00.000Z`,
-    rawEventType: input.eventType,
-    identityConfidence: 'high',
-    captureStatus: 'captured',
-    ...input,
-  });
-  await append({ eventId: 'r1', sequence: 1, eventType: 'user_prompt', role: 'user', content: 'Requirement before C1.', turnId: 'turn-1' });
-  const boundaryC1 = { commitSha: c1, repoIdentity, parentShas: [], branch: 'main', committedAt: '2026-08-18T02:02:00.000Z', bridgeCursorAtCommit: 2, journalSequence: 2, openTurnIdsAtCommit: ['turn-1'], operationId: 'op-c1' };
-  store.writeBoundary(projectId, boundaryC1);
-  assert.strictEqual(store.writeBoundary(projectId, boundaryC1).commitSha, c1, 'identical bridge/hook boundary is idempotent');
-  assert.throws(() => store.writeBoundary(projectId, { ...boundaryC1, branch: 'other' }), error => error.code === 'DATA_CORRUPT');
-  await append({ eventId: 'a1', sequence: 3, eventType: 'assistant_response', role: 'assistant', content: 'Late assistant before claim.', turnId: 'turn-1' });
-  await append({ eventId: 'r2', sequence: 4, eventType: 'user_prompt', role: 'user', content: 'Requirement after C1.', turnId: 'turn-2', headAtCapture: c1 });
-
-  const frozenC1 = await binder.bind({ projectId, commitSha: c1 });
-  assert.strictEqual(frozenC1.status, 'available');
-  assert.deepStrictEqual(frozenC1.turns.map(turn => turn.turnId), ['turn-1'], 'future R2 must never bind back to C1');
-  assert.deepStrictEqual(frozenC1.turns[0].assistantEvents.map(event => event.eventId), [], 'assistant beyond boundaryEndCursor must never enter the frozen snapshot (I-13)');
-  assert.strictEqual(frozenC1.excludedFuturePromptCount, 1);
-  const frozenHash = frozenC1.snapshotHash;
-  await append({ eventId: 'a1-after-claim', sequence: 6, eventType: 'assistant_response', role: 'assistant', content: 'Assistant arrived after Claim.', turnId: 'turn-1' });
-  const retriedC1 = await binder.bind({ projectId, commitSha: c1 });
-  assert.strictEqual(retriedC1.snapshotHash, frozenHash, 'retry must reuse the exact Claim-time conversation freeze');
-  assert.deepStrictEqual(retriedC1.turns[0].assistantEvents.map(event => event.eventId), [], 'delayed binder execution must not pull post-commit replies into the old snapshot');
-
-  store.writeBoundary(projectId, { commitSha: c2, repoIdentity, parentShas: [c1], branch: 'main', committedAt: '2026-08-18T02:05:00.000Z', bridgeCursorAtCommit: 5, journalSequence: 5, openTurnIdsAtCommit: ['turn-1'], operationId: 'op-c2' });
-  const frozenC2 = await binder.bind({ projectId, commitSha: c2 });
-  assert.deepStrictEqual(frozenC2.turns.map(turn => [turn.turnId, turn.bindingKind]), [['turn-1', 'shared-spanning'], ['turn-2', 'direct']]);
-  assert.deepStrictEqual(frozenC2.turns[0].assistantEvents.map(event => event.eventId), ['a1'], 'the assistant reply inside the C2 window belongs to the spanning turn');
-  assert.strictEqual(frozenC2.turns[0].turnId, frozenC1.turns[0].turnId, 'spanning turns must retain one stable identity across commits');
-
+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-conversation-binding-'));
+  const layout = new StorageLayout({ dataDir: path.join(root, 'data') });
+  const projectStore = new ProjectStore({ layout });
+  const projectId = 'project-binding';
+  const repoIdentity = { commonDir: path.join(root, 'repo', '.git') };
+  await projectStore.create(projectId, {
+    displayName: 'Binding',
+    storageName: 'binding',
+    repoPath: path.join(root, 'repo'),
+    knowledgePath: path.join(root, 'knowledge'),
+    repoIdentity,
+  }, { conversationBaselineCursor: 0, conversation: { lastConsumedCursor: 0, captureStatus: 'captured' } });
+  const store = new ConversationStore({ layout, projectStore });
+  const binder = new CommitConversationBinder({ layout, projectStore, conversationStore: store });
+  const c1 = '1'.repeat(40);
+  const c2 = '2'.repeat(40);
+  const c3 = '3'.repeat(40);
+  const cMerge = '4'.repeat(40);
+  const cAmbiguous = '5'.repeat(40);
+
+  const append = input => store.appendEvent(projectId, {
+    source: 'codex',
+    sessionId: 'session-1',
+    projectPath: path.join(root, 'repo'),
+    repoIdentity,
+    branch: 'main',
+    headAtCapture: '0'.repeat(40),
+    capturedAt: `2026-08-18T02:${String(input.sequence || 0).padStart(2, '0')}:00.000Z`,
+    rawEventType: input.eventType,
+    identityConfidence: 'high',
+    captureStatus: 'captured',
+    ...input,
+  });
+  await append({ eventId: 'r1', sequence: 1, eventType: 'user_prompt', role: 'user', content: 'Requirement before C1.', turnId: 'turn-1' });
+  const boundaryC1 = { commitSha: c1, repoIdentity, parentShas: [], branch: 'main', committedAt: '2026-08-18T02:02:00.000Z', bridgeCursorAtCommit: 2, journalSequence: 2, openTurnIdsAtCommit: ['turn-1'], operationId: 'op-c1' };
+  store.writeBoundary(projectId, boundaryC1);
+  assert.strictEqual(store.writeBoundary(projectId, boundaryC1).commitSha, c1, 'identical bridge/hook boundary is idempotent');
+  assert.throws(() => store.writeBoundary(projectId, { ...boundaryC1, branch: 'other' }), error => error.code === 'DATA_CORRUPT');
+  await append({ eventId: 'a1', sequence: 3, eventType: 'assistant_response', role: 'assistant', content: 'Late assistant before claim.', turnId: 'turn-1' });
+  await append({ eventId: 'r2', sequence: 4, eventType: 'user_prompt', role: 'user', content: 'Requirement after C1.', turnId: 'turn-2', headAtCapture: c1 });
+
+  const frozenC1 = await binder.bind({ projectId, commitSha: c1 });
+  assert.strictEqual(frozenC1.status, 'available');
+  assert.deepStrictEqual(frozenC1.turns.map(turn => turn.turnId), ['turn-1'], 'future R2 must never bind back to C1');
+  assert.deepStrictEqual(frozenC1.turns[0].assistantEvents.map(event => event.eventId), [], 'assistant beyond boundaryEndCursor must never enter the frozen snapshot (I-13)');
+  assert.strictEqual(frozenC1.excludedFuturePromptCount, 1);
+  const frozenHash = frozenC1.snapshotHash;
+  await append({ eventId: 'a1-after-claim', sequence: 6, eventType: 'assistant_response', role: 'assistant', content: 'Assistant arrived after Claim.', turnId: 'turn-1' });
+  const retriedC1 = await binder.bind({ projectId, commitSha: c1 });
+  assert.strictEqual(retriedC1.snapshotHash, frozenHash, 'retry must reuse the exact Claim-time conversation freeze');
+  assert.deepStrictEqual(retriedC1.turns[0].assistantEvents.map(event => event.eventId), [], 'delayed binder execution must not pull post-commit replies into the old snapshot');
+
+  store.writeBoundary(projectId, { commitSha: c2, repoIdentity, parentShas: [c1], branch: 'main', committedAt: '2026-08-18T02:05:00.000Z', bridgeCursorAtCommit: 5, journalSequence: 5, openTurnIdsAtCommit: ['turn-1'], operationId: 'op-c2' });
+  const frozenC2 = await binder.bind({ projectId, commitSha: c2 });
+  assert.deepStrictEqual(frozenC2.turns.map(turn => [turn.turnId, turn.bindingKind]), [['turn-1', 'shared-spanning'], ['turn-2', 'direct']]);
+  assert.deepStrictEqual(frozenC2.turns[0].assistantEvents.map(event => event.eventId), ['a1'], 'the assistant reply inside the C2 window belongs to the spanning turn');
+  assert.strictEqual(frozenC2.turns[0].turnId, frozenC1.turns[0].turnId, 'spanning turns must retain one stable identity across commits');
+
   store.writeBoundary(projectId, { commitSha: c3, repoIdentity, parentShas: [c2], branch: 'main', committedAt: '2026-08-18T02:07:00.000Z', bridgeCursorAtCommit: 7, journalSequence: 7, openTurnIdsAtCommit: ['turn-1'], operationId: 'op-c3' });
   const frozenC3 = await binder.bind({ projectId, commitSha: c3 });
   assert.strictEqual(frozenC3.status, 'no-new-user-prompt');
   assert.deepStrictEqual(frozenC3.turns, [], 'a stale Bridge open-turn id must not copy a closed requirement into a later commit');
-
-  await append({ eventId: 'r-merge', sequence: 8, eventType: 'user_prompt', role: 'user', content: 'Merge-window requirement.', turnId: 'turn-merge' });
-  store.writeBoundary(projectId, { commitSha: cMerge, repoIdentity, parentShas: [c1, c2], branch: 'main', committedAt: '2026-08-18T02:10:00.000Z', bridgeCursorAtCommit: 10, journalSequence: 10, openTurnIdsAtCommit: [], operationId: 'op-merge' });
-  const mergeSnapshot = await binder.bind({ projectId, commitSha: cMerge });
-  assert.strictEqual(mergeSnapshot.boundaryStartCursor, 7, 'merge window must use previous durable repo boundary, not an arbitrary Git parent');
-  assert.deepStrictEqual(mergeSnapshot.turns.map(turn => turn.turnId), ['turn-merge']);
-
-  await append({ eventId: 'r-ambiguous', sequence: 11, eventType: 'user_prompt', role: 'user', content: 'Identity unavailable.', turnId: null, repoIdentity: null, identityConfidence: 'unknown' });
-  store.writeBoundary(projectId, { commitSha: cAmbiguous, repoIdentity, parentShas: [cMerge], branch: 'main', committedAt: '2026-08-18T02:12:00.000Z', bridgeCursorAtCommit: 12, journalSequence: 12, openTurnIdsAtCommit: [], operationId: 'op-ambiguous' });
-  const ambiguous = await binder.bind({ projectId, commitSha: cAmbiguous });
-  assert.strictEqual(ambiguous.status, 'ambiguous');
-  assert.deepStrictEqual(ambiguous.turns, []);
-
-  const missingBoundary = await binder.bind({ projectId, commitSha: '6'.repeat(40) });
-  assert.strictEqual(missingBoundary.status, 'unavailable', 'missing boundary/capture gap must never fall back to timestamp or ancestry guessing');
-
-  const explicitSha = '7'.repeat(40);
-  await append({ eventId: 'explicit-r', sequence: null, eventType: 'user_prompt', role: 'user', content: 'Explicit requirement.', turnId: 'turn-explicit', explicitCommitSha: explicitSha, identityConfidence: 'explicit' });
-  const explicit = await binder.bind({ projectId, commitSha: explicitSha });
-  assert.strictEqual(explicit.status, 'available');
-  assert.strictEqual(explicit.turns[0].bindingKind, 'explicit');
-
-  console.log('commit-conversation-binding-test PASS');
-})().catch(error => {
-  console.error(error.stack || error.message);
-  process.exitCode = 1;
-});
+
+  await append({ eventId: 'r-merge', sequence: 8, eventType: 'user_prompt', role: 'user', content: 'Merge-window requirement.', turnId: 'turn-merge' });
+  store.writeBoundary(projectId, { commitSha: cMerge, repoIdentity, parentShas: [c1, c2], branch: 'main', committedAt: '2026-08-18T02:10:00.000Z', bridgeCursorAtCommit: 10, journalSequence: 10, openTurnIdsAtCommit: [], operationId: 'op-merge' });
+  const mergeSnapshot = await binder.bind({ projectId, commitSha: cMerge });
+  assert.strictEqual(mergeSnapshot.boundaryStartCursor, 7, 'merge window must use previous durable repo boundary, not an arbitrary Git parent');
+  assert.deepStrictEqual(mergeSnapshot.turns.map(turn => turn.turnId), ['turn-merge']);
+
+  await append({ eventId: 'r-ambiguous', sequence: 11, eventType: 'user_prompt', role: 'user', content: 'Identity unavailable.', turnId: null, repoIdentity: null, identityConfidence: 'unknown' });
+  store.writeBoundary(projectId, { commitSha: cAmbiguous, repoIdentity, parentShas: [cMerge], branch: 'main', committedAt: '2026-08-18T02:12:00.000Z', bridgeCursorAtCommit: 12, journalSequence: 12, openTurnIdsAtCommit: [], operationId: 'op-ambiguous' });
+  const ambiguous = await binder.bind({ projectId, commitSha: cAmbiguous });
+  assert.strictEqual(ambiguous.status, 'ambiguous');
+  assert.deepStrictEqual(ambiguous.turns, []);
+
+  const missingBoundary = await binder.bind({ projectId, commitSha: '6'.repeat(40) });
+  assert.strictEqual(missingBoundary.status, 'unavailable', 'missing boundary/capture gap must never fall back to timestamp or ancestry guessing');
+
+  const explicitSha = '7'.repeat(40);
+  await append({ eventId: 'explicit-r', sequence: null, eventType: 'user_prompt', role: 'user', content: 'Explicit requirement.', turnId: 'turn-explicit', explicitCommitSha: explicitSha, identityConfidence: 'explicit' });
+  const explicit = await binder.bind({ projectId, commitSha: explicitSha });
+  assert.strictEqual(explicit.status, 'available');
+  assert.strictEqual(explicit.turns[0].bindingKind, 'explicit');
+
+  console.log('commit-conversation-binding-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});