pi-background-tasks 0.7.6 → 0.7.7

package/src/core/fusion/context.ts

@@ -1,18 +1,23 @@
 import { createHash } from 'node:crypto';
+import { canonicalJson } from '../attested-pi-run.js';
+import {
+  projectVisibleConversationV2,
+  type OmittedRunCounts,
+  type ProjectedConversationV2,
+  type ProjectionEntry,
+} from '../context/visible-conversation-v2.js';
 import {
-  buildSessionContext,
-  convertToLlm,
-  type SessionEntry,
-} from '@earendil-works/pi-coding-agent';
+  snapshotParentConversation,
+  type ParentContextSource,
+  type ParentSnapshotOptions,
+  type ReadonlyParentSessionManager,
+} from '../context/parent-snapshot.js';
 import type { Message } from '@earendil-works/pi-ai';
-import { canonicalJson } from '../attested-pi-run.js';
-import { isJsonObject, type JsonObject } from '../common.js';
 import {
   FUSION_BRANCH_FILTER_ID,
   FUSION_COMMAND_CONTEXT_POLICY_ID,
   FUSION_CONTEXT_LEDGER_SCHEMA_VERSION,
   FUSION_CONTEXT_TRANSFORM_ID,
-  FUSION_IMAGE_OMISSION_PREFIX,
   FUSION_INPUT_SCHEMA_VERSION,
   FUSION_TOOL_CONTEXT_POLICY_ID,
   FusionError,
@@ -21,33 +26,18 @@ import {
   type FusionCanonicalRequestV3,
   type FusionContextOmissionLedgerV2,
   type FusionContextPolicyDescriptor,
-  type FusionContextProjectionMapEntry,
   type FusionConversationProjectionV3,
-  type FusionOmittedEventKind,
-  type FusionOmittedEventRecord,
-  type FusionOmittedRunCounts,
-  type FusionProjectionAccounting,
   type FusionProjectionEntry,
-  type FusionProjectionOmissionEntry,
-  type FusionProjectionTextEntry,
+  type FusionProjectionOmissionCounts,
   type FusionRequestAuthority,
   type FusionSource,
-  type FusionToolCallNameCount,
 } from './types.js';
 
 export const FUSION_BRAINSTORM_TOOL_NAME = 'fusion_brainstorm';
 
-export interface FusionReadonlySessionManager {
-  getLeafId(): string | null;
-  getLeafEntry(): SessionEntry | undefined;
-  getEntries(): SessionEntry[];
-}
-
-export interface FusionContextSource {
-  cwd: string;
-  sessionManager: FusionReadonlySessionManager;
-  getSystemPrompt(): string;
-}
+/** Retained for source compatibility; Fusion's session access is the shared adapter. */
+export type FusionReadonlySessionManager = ReadonlyParentSessionManager;
+export type FusionContextSource = ParentContextSource;
 
 export interface BuildFusionCanonicalInputOptions {
   source: FusionSource;
@@ -67,129 +57,8 @@ export function normalizeFusionCommandRequest(args: string): string {
   return args.trim();
 }
 
-function entriesById(entries: readonly SessionEntry[]): Map<string, SessionEntry> {
-  const byId = new Map<string, SessionEntry>();
-  for (const entry of entries) byId.set(entry.id, entry);
-  return byId;
-}
-
-function readArray(record: JsonObject, key: string): readonly unknown[] | undefined {
-  const value = record[key];
-  return Array.isArray(value) ? value : undefined;
-}
-
-function recordOf(value: unknown): JsonObject | undefined {
-  if (!isJsonObject(value) || Array.isArray(value)) return undefined;
-  return value;
-}
-
-function entryMessage(entry: SessionEntry): JsonObject | undefined {
-  if (entry.type !== 'message') return undefined;
-  return recordOf(entry.message);
-}
-
-function toolCallPartMatches(
-  part: unknown,
-  toolCallId: string | undefined,
-  toolName: string,
-): boolean {
-  const record = recordOf(part);
-  if (record === undefined || record['type'] !== 'toolCall') return false;
-  if (toolCallId !== undefined) return record['id'] === toolCallId;
-  return record['name'] === toolName;
-}
-
-function messageContainsToolCall(
-  message: JsonObject,
-  toolCallId: string | undefined,
-  toolName: string,
-): boolean {
-  if (message['role'] !== 'assistant') return false;
-  const content = readArray(message, 'content');
-  if (content === undefined) return false;
-  for (const part of content) {
-    if (toolCallPartMatches(part, toolCallId, toolName)) return true;
-  }
-  return false;
-}
-
-interface EffectiveLeaf {
-  leafId: string | null;
-  activeToolCallLeafExcluded: boolean;
-}
-
-function effectiveLeafForTool(
-  sessionManager: FusionReadonlySessionManager,
-  toolCallId: string | undefined,
-  toolName: string,
-): EffectiveLeaf {
-  const leaf = sessionManager.getLeafEntry();
-  if (leaf === undefined)
-    return { leafId: sessionManager.getLeafId(), activeToolCallLeafExcluded: false };
-  const message = entryMessage(leaf);
-  if (message !== undefined && messageContainsToolCall(message, toolCallId, toolName)) {
-    return { leafId: leaf.parentId, activeToolCallLeafExcluded: true };
-  }
-  return { leafId: sessionManager.getLeafId(), activeToolCallLeafExcluded: false };
-}
-
-function effectiveLeaf(
-  sessionManager: FusionReadonlySessionManager,
-  options: BuildFusionCanonicalInputOptions,
-): EffectiveLeaf {
-  if (options.source !== 'tool')
-    return { leafId: sessionManager.getLeafId(), activeToolCallLeafExcluded: false };
-  return effectiveLeafForTool(
-    sessionManager,
-    options.toolCallId,
-    options.toolName ?? FUSION_BRAINSTORM_TOOL_NAME,
-  );
-}
-
-function utf8Bytes(value: string): number {
-  return Buffer.byteLength(value, 'utf8');
-}
-
-function sha256Hex(bytes: Buffer): string {
-  return createHash('sha256').update(bytes).digest('hex');
-}
-
 function sha256Text(value: string): string {
-  return sha256Hex(Buffer.from(value, 'utf8'));
-}
-
-function uint64be(value: number): Buffer {
-  const out = Buffer.alloc(8);
-  out.writeBigUInt64BE(BigInt(value));
-  return out;
-}
-
-/** Length-prefixed framing so concatenated fields cannot collide across boundaries. */
-function lengthPrefixed(bytes: Buffer): Buffer {
-  return Buffer.concat([uint64be(bytes.length), bytes]);
-}
-
-function ledgerLeafHash(index: number, record: FusionOmittedEventRecord): Buffer {
-  return createHash('sha256')
-    .update(Buffer.from('pi-fusion-ledger-leaf-v1\0', 'utf8'))
-    .update(uint64be(index))
-    .update(lengthPrefixed(Buffer.from(canonicalJson(record), 'utf8')))
-    .digest();
-}
-
-function ledgerRootHash(leaves: readonly Buffer[]): string {
-  const hash = createHash('sha256')
-    .update(Buffer.from('pi-fusion-ledger-root-v1\0', 'utf8'))
-    .update(uint64be(leaves.length));
-  for (const leaf of leaves) hash.update(leaf);
-  return hash.digest('hex');
-}
-
-function unsupportedBlock(label: string): FusionError {
-  return new FusionError(
-    `fusion context projection encountered an unsupported conversation block: ${label}`,
-    { code: 'context_policy_unsupported_block', childCreated: false },
-  );
+  return createHash('sha256').update(Buffer.from(value, 'utf8')).digest('hex');
 }
 
 function contextPolicyId(source: FusionSource): string {
@@ -217,382 +86,110 @@ function policyDescriptor(source: FusionSource): FusionContextPolicyDescriptor {
   };
 }
 
-/**
- * Accumulates omitted-event ledger rows and turns maximal contiguous non-image
- * omission runs into compact, source-ordered receipts inside the canonical input.
- */
-class ProjectionBuilder {
-  private readonly entries: FusionProjectionEntry[] = [];
-  private readonly ledger: FusionOmittedEventRecord[] = [];
-  private readonly leaves: Buffer[] = [];
-  private readonly projectionMap: FusionContextProjectionMapEntry[] = [];
-  private readonly toolCallNames = new Map<string, number>();
-  private pendingCounts: Required<FusionOmittedRunCounts> | undefined;
-  private pendingBytes = 0;
-  private pendingLedgerFirst = 0;
-  private pendingLedgerLast = 0;
-  private pendingSourceFirst = 0;
-  private pendingSourceLast = 0;
-
-  includedUserTextBytes = 0;
-  includedAssistantTextBytes = 0;
-  includedImageMarkers = 0;
-  emptyTextBlocks = 0;
-
-  addText(entry: FusionProjectionTextEntry): void {
-    this.flush();
-    this.entries.push(entry);
-    if (entry.role === 'user') this.includedUserTextBytes += utf8Bytes(entry.text);
-    else this.includedAssistantTextBytes += utf8Bytes(entry.text);
-  }
-
-  addOmission(
-    sourceOrdinal: number,
-    blockOrdinal: number,
-    kind: FusionOmittedEventKind,
-    payload: Buffer,
-    extra: { toolName?: string; toolCallId?: string; mimeType?: string } = {},
-  ): void {
-    const index = this.ledger.length;
-    const record: FusionOmittedEventRecord = {
-      index,
-      source_ordinal: sourceOrdinal,
-      block_ordinal: blockOrdinal,
-      kind,
-      payload_bytes: payload.length,
-      payload_sha256: sha256Hex(payload),
-    };
-    if (extra.toolName !== undefined) record.tool_name = extra.toolName;
-    if (extra.toolCallId !== undefined) record.tool_call_id = extra.toolCallId;
-    if (extra.mimeType !== undefined) record.mime_type = extra.mimeType;
-    this.ledger.push(record);
-    this.leaves.push(ledgerLeafHash(index, record));
-
-    if (extra.toolName !== undefined && kind === 'tool_call') {
-      this.toolCallNames.set(extra.toolName, (this.toolCallNames.get(extra.toolName) ?? 0) + 1);
-    }
-
-    if (kind === 'tool_result_image') {
-      this.flush();
-      this.addLedgerOnlyImageMap(index);
-      return;
-    }
-
-    if (this.pendingCounts === undefined) {
-      this.pendingCounts = {
-        assistant_thinking: 0,
-        tool_calls: 0,
-        tool_result_texts: 0,
-      };
-      this.pendingBytes = 0;
-      this.pendingLedgerFirst = index;
-      this.pendingSourceFirst = sourceOrdinal;
-    }
-    this.pendingLedgerLast = index;
-    this.pendingSourceLast = sourceOrdinal;
-    this.pendingBytes += payload.length;
-    if (kind === 'assistant_thinking') this.pendingCounts.assistant_thinking += 1;
-    else if (kind === 'tool_call') this.pendingCounts.tool_calls += 1;
-    else this.pendingCounts.tool_result_texts += 1;
-  }
-
-  private addLedgerOnlyImageMap(index: number): void {
-    const previous = this.projectionMap[this.projectionMap.length - 1];
-    if (
-      previous !== undefined &&
-      previous.entry_kind === 'ledger_only_tool_result_image' &&
-      previous.ledger_index_last + 1 === index
-    ) {
-      previous.ledger_index_last = index;
-      return;
-    }
-    this.projectionMap.push({
-      entry_kind: 'ledger_only_tool_result_image',
-      ledger_index_first: index,
-      ledger_index_last: index,
-    });
-  }
-
-  private flush(): void {
-    const counts = this.pendingCounts;
-    if (counts === undefined) return;
-    const canonicalEntryIndex = this.entries.length;
-    const entry: FusionProjectionOmissionEntry = {
-      at: [this.pendingSourceFirst, this.pendingSourceLast],
-      bytes: this.pendingBytes,
-      counts: compactCounts(counts),
-      kind: 'omitted_activity',
-    };
-    this.entries.push(entry);
-    this.projectionMap.push({
-      canonical_entry_index: canonicalEntryIndex,
-      entry_kind: 'omitted_activity',
-      ledger_index_first: this.pendingLedgerFirst,
-      ledger_index_last: this.pendingLedgerLast,
-    });
-    this.pendingCounts = undefined;
-    this.pendingBytes = 0;
-  }
-
-  finish(
-    source: FusionSource,
-    branchFilter: FusionBranchFilterDescriptor,
-    messageCount: number,
-  ): { projection: FusionConversationProjectionV3; ledger: FusionContextOmissionLedgerV2 } {
-    this.flush();
-    const rootSha256 = ledgerRootHash(this.leaves);
-    let omittedRunCount = 0;
-    let includedTextEntries = 0;
-    let receiptBytes = 0;
-    for (const entry of this.entries) {
-      if (entry.kind === 'text') includedTextEntries += 1;
-      else {
-        omittedRunCount += 1;
-        receiptBytes += utf8Bytes(canonicalJson(entry));
-      }
-    }
-    let thinkingBytes = 0;
-    let toolCallCount = 0;
-    let toolArgumentBytes = 0;
-    let toolResultTextCount = 0;
-    let toolResultTextBytes = 0;
-    let toolResultImageCount = 0;
-    let toolResultImageBytes = 0;
-    for (const row of this.ledger) {
-      if (row.kind === 'assistant_thinking') thinkingBytes += row.payload_bytes;
-      else if (row.kind === 'tool_call') {
-        toolCallCount += 1;
-        toolArgumentBytes += row.payload_bytes;
-      } else if (row.kind === 'tool_result_text') {
-        toolResultTextCount += 1;
-        toolResultTextBytes += row.payload_bytes;
-      } else {
-        toolResultImageCount += 1;
-        toolResultImageBytes += row.payload_bytes;
-      }
-    }
-    const toolCallNames: FusionToolCallNameCount[] = [...this.toolCallNames.entries()]
-      .map(([name, calls]) => ({ name, calls }))
-      .sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
-    const accounting: FusionProjectionAccounting = {
-      message_count: messageCount,
-      included_text_entry_count: includedTextEntries,
-      included_user_text_bytes: this.includedUserTextBytes,
-      included_assistant_text_bytes: this.includedAssistantTextBytes,
-      included_image_marker_count: this.includedImageMarkers,
-      empty_text_block_count: this.emptyTextBlocks,
-      omitted_run_count: omittedRunCount,
-      omitted_event_count: this.ledger.length,
-      omitted_thinking_bytes: thinkingBytes,
-      omitted_tool_call_count: toolCallCount,
-      omitted_tool_call_argument_bytes: toolArgumentBytes,
-      omitted_tool_result_text_count: toolResultTextCount,
-      omitted_tool_result_text_bytes: toolResultTextBytes,
-      omitted_tool_result_image_count: toolResultImageCount,
-      omitted_tool_result_image_bytes: toolResultImageBytes,
-      tool_call_names: toolCallNames,
-      ledger_entry_count: this.ledger.length,
-      ledger_root_sha256: rootSha256,
-      omission_receipt_utf8_bytes: receiptBytes,
-    };
-    return {
-      projection: {
-        policy: policyDescriptor(source),
-        branch_filter: branchFilter,
-        entries: this.entries,
-        accounting,
-      },
-      ledger: {
-        schema_version: FUSION_CONTEXT_LEDGER_SCHEMA_VERSION,
-        policy_id: contextPolicyId(source),
-        transform: FUSION_CONTEXT_TRANSFORM_ID,
-        entries: this.ledger,
-        projection_map: this.projectionMap,
-        root_sha256: rootSha256,
-      },
-    };
-  }
+function compactOmissionCounts(counts: OmittedRunCounts): FusionProjectionOmissionCounts {
+  return [
+    counts.assistant_thinking ?? 0,
+    counts.tool_calls ?? 0,
+    counts.tool_result_texts ?? 0,
+  ];
 }
 
-function imageMarker(mimeType: string): string {
-  return `${FUSION_IMAGE_OMISSION_PREFIX}${mimeType}]`;
+function expandOmissionCounts(counts: FusionProjectionOmissionCounts): OmittedRunCounts {
+  const out: OmittedRunCounts = {};
+  const [assistantThinking, toolCalls, toolResults] = counts;
+  if (assistantThinking > 0) out.assistant_thinking = assistantThinking;
+  if (toolCalls > 0) out.tool_calls = toolCalls;
+  if (toolResults > 0) out.tool_result_texts = toolResults;
+  return out;
 }
 
-/**
- * Fixed policy rule: a zero-valued kind is absent from the receipt rather than
- * serialized as `0`. This keeps receipts compact without losing information —
- * absent is defined by the policy version to mean exactly zero — and it is
- * applied unconditionally, never adaptively because an input happens to be large.
- */
-function compactCounts(counts: Required<FusionOmittedRunCounts>): FusionOmittedRunCounts {
-  const out: FusionOmittedRunCounts = {};
-  if (counts.assistant_thinking > 0) out.assistant_thinking = counts.assistant_thinking;
-  if (counts.tool_calls > 0) out.tool_calls = counts.tool_calls;
-  if (counts.tool_result_texts > 0) out.tool_result_texts = counts.tool_result_texts;
-  return out;
+export function compactFusionProjectionEntry(entry: ProjectionEntry): FusionProjectionEntry {
+  if (entry.kind === 'text') {
+    return [
+      't',
+      entry.role === 'user' ? 'u' : 'a',
+      entry.source_ordinal,
+      entry.block_ordinal,
+      entry.text,
+    ];
+  }
+  return ['o', [entry.at[0], entry.at[1]], entry.bytes, compactOmissionCounts(entry.counts)];
 }
 
-/**
- * Projects one user-role message. User text is retained verbatim; images stay
- * marker-only so the child never receives raw bytes.
- */
-function projectUserMessage(
-  builder: ProjectionBuilder,
-  content: Message['content'],
-  sourceOrdinal: number,
-): void {
-  if (typeof content === 'string') {
-    if (content.length === 0) {
-      builder.emptyTextBlocks += 1;
-      return;
-    }
-    builder.addText({
+export function expandFusionProjectionEntry(entry: FusionProjectionEntry): ProjectionEntry {
+  if (entry[0] === 't') {
+    return {
       kind: 'text',
-      source_ordinal: sourceOrdinal,
-      block_ordinal: 0,
-      role: 'user',
-      text: content,
-    });
-    return;
-  }
-  for (const [blockOrdinal, block] of content.entries()) {
-    if (block.type === 'text') {
-      if (block.text.length === 0) {
-        builder.emptyTextBlocks += 1;
-        continue;
-      }
-      builder.addText({
-        kind: 'text',
-        source_ordinal: sourceOrdinal,
-        block_ordinal: blockOrdinal,
-        role: 'user',
-        text: block.text,
-      });
-      continue;
-    }
-    if (block.type === 'image') {
-      builder.includedImageMarkers += 1;
-      builder.addText({
-        kind: 'text',
-        source_ordinal: sourceOrdinal,
-        block_ordinal: blockOrdinal,
-        role: 'user',
-        text: imageMarker(block.mimeType),
-      });
-      continue;
-    }
-    throw unsupportedBlock(`user block ${String(Reflect.get(block, 'type'))}`);
+      source_ordinal: entry[2],
+      block_ordinal: entry[3],
+      role: entry[1] === 'u' ? 'user' : 'assistant',
+      text: entry[4],
+    };
   }
+  return {
+    kind: 'omitted_activity',
+    at: [entry[1][0], entry[1][1]],
+    bytes: entry[2],
+    counts: expandOmissionCounts(entry[3]),
+  };
 }
 
-function projectAssistantMessage(
-  builder: ProjectionBuilder,
-  content: Extract<Message, { role: 'assistant' }>['content'],
-  sourceOrdinal: number,
-): void {
-  for (const [blockOrdinal, block] of content.entries()) {
-    if (block.type === 'text') {
-      if (block.text.length === 0) {
-        builder.emptyTextBlocks += 1;
-        continue;
-      }
-      builder.addText({
-        kind: 'text',
-        source_ordinal: sourceOrdinal,
-        block_ordinal: blockOrdinal,
-        role: 'assistant',
-        text: block.text,
-      });
-      continue;
-    }
-    if (block.type === 'thinking') {
-      builder.addOmission(
-        sourceOrdinal,
-        blockOrdinal,
-        'assistant_thinking',
-        Buffer.from(block.thinking, 'utf8'),
-      );
-      continue;
-    }
-    if (block.type === 'toolCall') {
-      builder.addOmission(
-        sourceOrdinal,
-        blockOrdinal,
-        'tool_call',
-        Buffer.from(canonicalJson(block.arguments), 'utf8'),
-        { toolName: block.name, toolCallId: block.id },
-      );
-      continue;
-    }
-    throw unsupportedBlock(`assistant block ${String(Reflect.get(block, 'type'))}`);
-  }
+function compactFusionProjectionEntries(
+  entries: readonly ProjectionEntry[],
+): readonly FusionProjectionEntry[] {
+  return entries.map(compactFusionProjectionEntry);
 }
 
-function projectToolResultMessage(
-  builder: ProjectionBuilder,
-  message: Extract<Message, { role: 'toolResult' }>,
-  sourceOrdinal: number,
-): void {
-  const content = message.content;
-  if (typeof content === 'string') {
-    builder.addOmission(
-      sourceOrdinal,
-      0,
-      'tool_result_text',
-      Buffer.from(content, 'utf8'),
-      { toolName: message.toolName, toolCallId: message.toolCallId },
-    );
-    return;
-  }
-  for (const [blockOrdinal, block] of content.entries()) {
-    if (block.type === 'text') {
-      builder.addOmission(
-        sourceOrdinal,
-        blockOrdinal,
-        'tool_result_text',
-        Buffer.from(block.text, 'utf8'),
-        { toolName: message.toolName, toolCallId: message.toolCallId },
-      );
-      continue;
-    }
-    if (block.type === 'image') {
-      builder.addOmission(
-        sourceOrdinal,
-        blockOrdinal,
-        'tool_result_image',
-        Buffer.from(block.data, 'utf8'),
-        {
-          toolName: message.toolName,
-          toolCallId: message.toolCallId,
-          mimeType: block.mimeType,
-        },
-      );
-      continue;
-    }
-    throw unsupportedBlock(`tool result block ${String(Reflect.get(block, 'type'))}`);
+function compactOmissionReceiptBytes(entries: readonly FusionProjectionEntry[]): number {
+  let total = 0;
+  for (const entry of entries) {
+    if (entry[0] === 'o') total += Buffer.byteLength(canonicalJson(entry), 'utf8');
   }
+  return total;
 }
 
 /**
- * Deterministic conversation projection. Every retained source block receives
- * exactly one disposition: included verbatim, or represented as an omission
- * ledger row. Unknown block types fail loudly instead of disappearing.
+ * Seal the shared transform output into Fusion's versioned envelopes.
+ *
+ * Fusion v4 compacts only the child-facing projection entries. Ledger rows are
+ * carried through unchanged, so the ledger root commits to exactly the same
+ * omitted payload records before and after tuple encoding. Golden tests pin the
+ * new canonical-input bytes and the unchanged ledger bytes.
  */
+function sealFusionProjection(
+  projected: ProjectedConversationV2,
+  source: FusionSource,
+  branchFilter: FusionBranchFilterDescriptor,
+): { projection: FusionConversationProjectionV3; ledger: FusionContextOmissionLedgerV2 } {
+  const entries = compactFusionProjectionEntries(projected.entries);
+  return {
+    projection: {
+      policy: policyDescriptor(source),
+      branch_filter: branchFilter,
+      entries,
+      accounting: {
+        ...projected.accounting,
+        omission_receipt_utf8_bytes: compactOmissionReceiptBytes(entries),
+      },
+    },
+    ledger: {
+      schema_version: FUSION_CONTEXT_LEDGER_SCHEMA_VERSION,
+      policy_id: contextPolicyId(source),
+      transform: FUSION_CONTEXT_TRANSFORM_ID,
+      entries: projected.ledger.entries,
+      projection_map: projected.ledger.projection_map,
+      root_sha256: projected.ledger.root_sha256,
+    },
+  };
+}
+
+/** Preserved public entry point; delegates to the shared frozen transform. */
 export function projectFusionConversation(
   messages: readonly Message[],
   source: FusionSource,
   branchFilter: FusionBranchFilterDescriptor,
 ): { projection: FusionConversationProjectionV3; ledger: FusionContextOmissionLedgerV2 } {
-  const builder = new ProjectionBuilder();
-  for (const [sourceOrdinal, message] of messages.entries()) {
-    if (message.role === 'user') projectUserMessage(builder, message.content, sourceOrdinal);
-    else if (message.role === 'assistant')
-      projectAssistantMessage(builder, message.content, sourceOrdinal);
-    else if (message.role === 'toolResult')
-      projectToolResultMessage(builder, message, sourceOrdinal);
-    else throw unsupportedBlock(`message role ${String(Reflect.get(message, 'role'))}`);
-  }
-  return builder.finish(source, branchFilter, messages.length);
+  return sealFusionProjection(projectVisibleConversationV2(messages), source, branchFilter);
 }
 
 export function buildFusionCanonicalInput(
@@ -605,18 +202,20 @@ export function buildFusionCanonicalInput(
       childCreated: false,
     });
   }
-  const entries = ctx.sessionManager.getEntries();
-  const leaf = effectiveLeaf(ctx.sessionManager, options);
-  const sessionContext = buildSessionContext(entries, leaf.leafId, entriesById(entries));
-  const llmMessages = convertToLlm(sessionContext.messages);
   const toolName = options.toolName ?? FUSION_BRAINSTORM_TOOL_NAME;
+  const snapshotOptions: ParentSnapshotOptions = {
+    toolName,
+    excludeActiveToolCallLeaf: options.source === 'tool',
+  };
+  if (options.toolCallId !== undefined) snapshotOptions.toolCallId = options.toolCallId;
+  const snapshot = snapshotParentConversation(ctx, snapshotOptions);
   const branchFilter: FusionBranchFilterDescriptor = {
     id: FUSION_BRANCH_FILTER_ID,
     tool_name: toolName,
     tool_call_id: options.source === 'tool' ? (options.toolCallId ?? null) : null,
-    active_tool_call_leaf_excluded: leaf.activeToolCallLeafExcluded,
+    active_tool_call_leaf_excluded: snapshot.activeToolCallLeafExcluded,
   };
-  const projected = projectFusionConversation(llmMessages, options.source, branchFilter);
+  const projected = projectFusionConversation(snapshot.messages, options.source, branchFilter);
   const request: FusionCanonicalRequestV3 = {
     source: options.source,
     authority: requestAuthority(options.source),
@@ -634,6 +233,6 @@ export function buildFusionCanonicalInput(
     input,
     serialized: canonicalJson(input),
     ledger: projected.ledger,
-    transcriptLeafId: leaf.leafId,
+    transcriptLeafId: snapshot.leafId,
   };
 }