Compaction và tóm tắt nhánh

export interface CompactionSettings {	enabled: boolean;	reserveTokens: number;	keepRecentTokens: number;}export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {	enabled: true,	reserveTokens: 16384,	keepRecentTokens: 20000,};

export interface CompactionEntry<T = unknown> extends SessionEntryBase {	type: "compaction";	summary: string;	firstKeptEntryId: string;	tokensBefore: number;	/** Extension-specific data (e.g., ArtifactIndex, version markers for structured compaction) */	details?: T;	/** Usage from the LLM call(s) that generated this summary, if available */	usage?: Usage;	/** True if generated by an extension, undefined/false if pi-generated (backward compatible) */	fromHook?: boolean;	/** Complete prompt and tool state at this compaction boundary. */	systemMessage?: SystemMessage;}

export interface CompactionPreparation {	/** UUID of first entry to keep */	firstKeptEntryId: string;	/** Messages that will be summarized and discarded */	messagesToSummarize: AgentMessage[];	/** Messages that will be turned into turn prefix summary (if splitting) */	turnPrefixMessages: AgentMessage[];	/** Whether this is a split turn (cut point in middle of turn) */	isSplitTurn: boolean;	tokensBefore: number;	/** Summary from previous compaction, for iterative update */	previousSummary?: string;	/** File operations extracted from messagesToSummarize */	fileOps: FileOperations;	/** Compaction settions from settings.jsonl	*/	settings: CompactionSettings;}

/** Result from compact() - SessionManager adds uuid/parentUuid when saving */export interface CompactionResult<T = unknown> {	summary: string;	firstKeptEntryId: string;	tokensBefore: number;	estimatedTokensAfter?: number;	/** Usage from the LLM call(s) that generated this summary, if available */	usage?: Usage;	/** Extension-specific data (e.g., ArtifactIndex, version markers for structured compaction) */	details?: T;}

/** * Check if compaction should trigger based on context usage. */export function shouldCompact(contextTokens: number, contextWindow: number, settings: CompactionSettings): boolean {	if (!settings.enabled) return false;	return contextTokens > contextWindow - settings.reserveTokens;}

private async _compactBeforeNextAssistantResponse(context: AgentContext): Promise<AgentContext> {	const projection = this.sessionManager.buildSessionProjection();	// A virtual selection is checked in prepareRequest, against the model the request is routed to.	const model = this.model;	if (!model || isVirtualModel(model) || !this._exceedsCompactionThreshold(model, projection)) {		return { ...context, messages: projection.messages };	}	await this._runAutoCompaction("threshold", false);	return { ...context, messages: this.sessionManager.buildSessionProjection().messages };}

private async _checkCompaction(assistantMessage: AssistantMessage, skipAbortedCheck = true): Promise<boolean> {	const settings = this.settingsManager.getCompactionSettings(this.model);	if (!settings.enabled) return false;	// Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false	if (skipAbortedCheck && assistantMessage.stopReason === "aborted") return false;⋯ lược bớt dòng 3017–3026	// Skip compaction checks if this assistant message is older than the latest	// compaction boundary. This prevents a stale pre-compaction usage/error	// from retriggering compaction on the first prompt after compaction.	const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());	const assistantIsFromBeforeCompaction =		compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();	if (assistantIsFromBeforeCompaction) {		return false;	}⋯ lược bớt dòng 3036–3062	const explicitOverflow = assistantMessage.stopReason === "error" && isContextOverflow(assistantMessage);	const contextOverflow =		sameModel &&		((explicitOverflow && assistantRetainedForExplicitRecovery) ||			(assistantUsageMatchesProjection && isContextOverflow(assistantMessage, contextWindow)));	const recoverableLength =		sameModel && assistantIsProjected && isRecoverableLength(assistantMessage, messageModel.maxTokens);	if (contextOverflow || recoverableLength) {		const willRetry = assistantMessage.stopReason !== "stop";		// Case 2: the response completed successfully. Compact, but do not retry because		// agent.continue() cannot continue from a completed assistant response.		if (!willRetry) {			return await this._runAutoCompaction("overflow", false);⋯ lược bớt dòng 3077–3100		// Persistently omit the selected final attempt before post-run recovery compaction.		this._overflowRecoveryAttempted = true;		this._omitRecoveryAttempt(assistantMessage);		const retry = await this._runAutoCompaction("overflow", willRetry);		if (retry) this._failedResponse = assistantMessage;		return retry;

let contextTokens: number;const projection = currentProjection;const hasContextEdits = projection.entries.some((entry) => entry.sourceEntry.type === "context_edit");const directContextTokens = assistantMessage.usage ? calculateContextTokens(assistantMessage.usage) : 0;if (hasContextEdits) {	contextTokens = estimateProjectedContextTokens(projection, branch).tokens;} else if (assistantMessage.stopReason === "error" || directContextTokens === 0) {	const messages = this.agent.state.messages;	const estimate = estimateContextTokens(messages);⋯ lược bớt dòng 3122–3136	contextTokens = estimate.tokens;} else {	contextTokens = directContextTokens;}if (shouldCompact(contextTokens, contextWindow, settings)) {	return await this._runAutoCompaction("threshold", false);}return false;

async compact(customInstructions?: string): Promise<CompactionResult> {	await this.abort();	this._compactionAbortController = new AbortController();	this._emit({ type: "compaction_start", reason: "manual" });	let fromExtension = false;	let cancelledByExtension = false;	try {		const model = this.model;		if (!model) {			throw new Error(formatNoModelSelectedMessage());		}		const settings = this.settingsManager.getCompactionSettings(model);		const pathEntries = this.sessionManager.getBranch();		const preparation = prepareCompaction(pathEntries, settings);		if (!preparation) {			// Check why we can't compact			const lastEntry = pathEntries[pathEntries.length - 1];			if (lastEntry?.type === "compaction") {				throw new Error("Already compacted");			}			throw new Error("Nothing to compact (session too small)");		}

const ESTIMATED_IMAGE_CHARS = 4800;⋯ lược bớt dòng 277–297export function estimateTokens(message: AgentMessage): number {	let chars = 0;	switch (message.role) {		case "system": {			const system = message as SystemMessage;			chars = estimateTextAndImageContentChars(system.content);			if (system.sections) {				for (const section of Object.values(system.sections)) {					if (section) chars += section.length;				}			}			if (system.toolsAdded) chars += JSON.stringify(system.toolsAdded).length;			return Math.ceil(chars / 4);		}		case "user": {			chars = estimateTextAndImageContentChars(				(message as { content: string | Array<{ type: string; text?: string }> }).content,			);			return Math.ceil(chars / 4);		}		case "assistant": {			const assistant = message as AssistantMessage;			for (const block of assistant.content) {				if (block.type === "text") {					chars += block.text.length;				} else if (block.type === "thinking") {					chars += block.thinking.length;				} else if (block.type === "toolCall") {					chars += block.name.length + JSON.stringify(block.arguments).length;				}			}			return Math.ceil(chars / 4);		}		case "custom":		case "toolResult": {			chars = estimateTextAndImageContentChars(message.content);			return Math.ceil(chars / 4);		}

export function estimateContextTokens(messages: AgentMessage[]): ContextUsageEstimate {	const usageInfo = getLastAssistantUsageInfo(messages);	if (!usageInfo) {		let estimated = 0;		for (const message of messages) {			estimated += estimateTokens(message);		}		return {			tokens: estimated,			usageTokens: 0,			trailingTokens: estimated,			lastUsageIndex: null,		};	}	const usageTokens = calculateContextTokens(usageInfo.usage);	let trailingTokens = 0;	for (let i = usageInfo.index + 1; i < messages.length; i++) {		trailingTokens += estimateTokens(messages[i]);	}	return {		tokens: usageTokens + trailingTokens,		usageTokens,		trailingTokens,		lastUsageIndex: usageInfo.index,	};}

function isCutPointMessage(message: AgentMessage): boolean {	switch (message.role) {		case "user":		case "assistant":		case "bashExecution":		case "custom":		case "branchSummary":		case "compactionSummary":			return true;		case "toolResult":			return false;	}	return false;}

const cutPoints: number[] = [];for (let i = startIndex; i < endIndex; i++) {	const entry = entries[i];	if (entry.sourceEntry.type !== "compaction" && entry.messages.some(isCutPointMessage)) cutPoints.push(i);}if (cutPoints.length === 0) {	return { firstKeptEntryIndex: startIndex, turnStartIndex: -1, isSplitTurn: false };}let accumulatedTokens = 0;let exceededBudget = false;let cutIndex = cutPoints[0];for (let i = endIndex - 1; i >= startIndex; i--) {	const messageTokens = entries[i].messages.reduce((sum, message) => sum + estimateTokens(message), 0);	if (messageTokens === 0) continue;	accumulatedTokens += messageTokens;	if (accumulatedTokens >= keepRecentTokens) {		exceededBudget = true;		cutIndex = cutPoints.find((candidate) => candidate >= i) ?? cutPoints[cutPoints.length - 1];		break;	}}⋯ lược bớt dòng 817–844while (cutIndex > startIndex) {	const previous = entries[cutIndex - 1];	if (previous.sourceEntry.type === "compaction" || previous.messages.length > 0) break;	cutIndex--;}const startsTurn = isProjectedTurnStart(entries[cutIndex]);const turnStartIndex = startsTurn ? -1 : findProjectedTurnStartIndex(entries, cutIndex, startIndex);return {	firstKeptEntryIndex: cutIndex,	turnStartIndex,	isSplitTurn: !startsTurn && turnStartIndex !== -1,};

if (pathEntries.length > 0 && pathEntries[pathEntries.length - 1].type === "compaction") {	return undefined;}⋯ lược bớt dòng 866–871const prevCompactionIndex = projectedEntries.findIndex(	(entry) => entry.sourceEntry.type === "compaction" && entry.messages.length > 0,);let previousSummary: string | undefined;let boundaryStart = 0;if (prevCompactionIndex >= 0) {	previousSummary = (projectedEntries[prevCompactionIndex].sourceEntry as CompactionEntry).summary;	// The canonical projection has already selected the previous compaction's retained tail.	boundaryStart = prevCompactionIndex + 1;}const boundaryEnd = projectedEntries.length;const tokensBefore = estimateProjectedContextTokens(projection, pathEntries).tokens;const cutPoint = findProjectedCutPoint(projectedEntries, boundaryStart, boundaryEnd, settings.keepRecentTokens);const firstKeptEntry = projectedEntries[cutPoint.firstKeptEntryIndex]?.sourceEntry;if (!firstKeptEntry?.id) return undefined;const firstKeptEntryId = firstKeptEntry.id;const historyEnd = cutPoint.isSplitTurn ? cutPoint.turnStartIndex : cutPoint.firstKeptEntryIndex;const messagesToSummarize = projectedEntries	.slice(boundaryStart, historyEnd)	.flatMap(getMessagesFromProjectedEntryForCompaction);const turnPrefixMessages = cutPoint.isSplitTurn	? projectedEntries			.slice(cutPoint.turnStartIndex, cutPoint.firstKeptEntryIndex)			.flatMap(getMessagesFromProjectedEntryForCompaction)	: [];if (messagesToSummarize.length === 0 && turnPrefixMessages.length === 0) return undefined;

export const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI assistant, then produce a structured summary following the exact format specified.Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.`;

export function serializeConversation(messages: Message[]): string {	const parts: string[] = [];	for (const msg of messages) {		if (msg.role === "user") {			const content = contentText(msg.content, "");			if (content) parts.push(`[User]: ${content}`);		} else if (msg.role === "assistant") {			const toolCalls: string[] = [];			for (const block of msg.content) {				if (block.type === "toolCall") {					const args = block.arguments as Record<string, unknown>;					const argsStr = Object.entries(args)						.map(([k, v]) => `${k}=${JSON.stringify(v)}`)						.join(", ");					toolCalls.push(`${block.name}(${argsStr})`);				}			}			if (msg.content.some((block) => block.type === "text")) {				parts.push(`[Assistant]: ${contentText(msg.content)}`);			}			if (toolCalls.length > 0) {				parts.push(`[Assistant tool calls]: ${toolCalls.join("; ")}`);			}		} else if (msg.role === "toolResult") {			const content = contentText(msg.content, "");			if (content) {				parts.push(`[Tool result]: ${truncateForSummary(content, TOOL_RESULT_MAX_CHARS)}`);			}		}	}	return parts.join("\n\n");}

const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.Use this EXACT format:## Goal[What is the user trying to accomplish? Can be multiple items if the session covers different tasks.]## Constraints & Preferences- [Any constraints, preferences, or requirements mentioned by user]- [Or "(none)" if none were mentioned]## Progress### Done- [x] [Completed tasks/changes]### In Progress- [ ] [Current work]### Blocked- [Issues preventing progress, if any]## Key Decisions- **[Decision]**: [Brief rationale]## Next Steps1. [Ordered list of what should happen next]## Critical Context- [Any data, examples, or references needed to continue]- [Or "(none)" if not applicable]Keep each section concise. Preserve exact file paths, function names, and error messages.`;

const UPDATE_SUMMARIZATION_INSTRUCTIONS = `Update the existing structured summary with new information. RULES:- PRESERVE all existing information from the previous summary- ADD new progress, decisions, and context from the new messages- UPDATE the Progress section: move items from "In Progress" to "Done" when completed- UPDATE "Next Steps" based on what was accomplished- PRESERVE exact file paths, function names, and error messages- If something is no longer relevant, you may remove it⋯ lược bớt dòng 547–576const UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.${UPDATE_SUMMARIZATION_INSTRUCTIONS}`;

// Use update prompt if we have a previous summary, otherwise initial promptlet basePrompt = previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT;if (customInstructions) {	basePrompt = `${basePrompt}\n\nAdditional focus: ${customInstructions}`;}// Serialize conversation to text so model doesn't try to continue it// Convert to LLM messages first (handles custom types like bashExecution, custom, etc.)const llmMessages = convertToLlm(currentMessages);const conversationText = serializeConversation(llmMessages);// Build the prompt with conversation wrapped in tagslet promptText = `<conversation>\n${conversationText}\n</conversation>\n\n`;if (previousSummary) {	promptText += `<previous-summary>\n${previousSummary}\n</previous-summary>\n\n`;}promptText += basePrompt;⋯ lược bớt dòng 730–741const failure = getSummarizationFailure(response, "Summarization");if (failure) {	throw new Error(failure);}if (response.content.some((block) => block.type === "toolCall")) {	throw new Error("Summarization attempted to call a tool");}const textContent = contentText(response.content);return { text: textContent, usage: response.usage };

// Avoid cache writes for one-off summaries. Reuse caller-supplied routing when available;// callers without a session ID, including branch summaries, receive a fresh routing ID.const requestOptions: SimpleStreamOptions = {	...options,	cacheRetention: "none",	sessionId: options.sessionId ?? uuidv7(),};const produce = async (): Promise<AssistantMessage> =>	streamFn		? (await streamFn(model, context, requestOptions)).result()		: completeSimple(model, context, requestOptions);return retryAssistantCall(produce, retry, requestOptions.signal, callbacks);

const TURN_PREFIX_SUMMARIZATION_PROMPT = `The messages above are earlier context from an ongoing conversation. Later messages are stored separately and do not need to be reconstructed.Create a concise checkpoint of the user's request and the progress shown above. This checkpoint will be placed before the later messages so the conversation can continue with the necessary context.## Original Request[What did the user ask for?]## Progress So Far- [Key decisions and work completed in these messages]## Context Needed to Continue- [Information from these messages needed to understand the later work]Only summarize information explicitly present above. Do not infer or recreate later messages.`;

	// Merge into single summary	summary = `${historyText}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixResult.text}`;	summaryUsage = historyUsage ? combineUsage(historyUsage, turnPrefixResult.usage) : turnPrefixResult.usage;⋯ lược bớt dòng 1020–1041// Compute file lists and append to summaryconst { readFiles, modifiedFiles } = computeFileLists(fileOps);summary += formatFileOperations(readFiles, modifiedFiles);if (!firstKeptEntryId) {	throw new Error("First kept entry has no UUID - session may need migration");}return {	summary,	firstKeptEntryId,	tokensBefore,	usage: summaryUsage,	details: { readFiles, modifiedFiles } as CompactionDetails,};

export function extractFileOpsFromMessage(message: AgentMessage, fileOps: FileOperations): void {	if (message.role === "toolResult") {		// Calls made from codemode scripts are recorded on the script's result.		for (const call of message.nestedCalls?.calls ?? []) addFileOp(call.name, call.arguments, fileOps);		return;	}	if (message.role !== "assistant") return;	if (!("content" in message) || !Array.isArray(message.content)) return;	for (const block of message.content) {		if (typeof block !== "object" || block === null) continue;		if (!("type" in block) || block.type !== "toolCall") continue;		if (!("arguments" in block) || !("name" in block)) continue;		addFileOp(block.name, block.arguments as Record<string, unknown> | undefined, fileOps);	}}function addFileOp(toolName: string, args: Record<string, unknown> | undefined, fileOps: FileOperations): void {	const path = typeof args?.path === "string" ? args.path : undefined;	if (!path) return;	switch (toolName) {		case "read":			fileOps.read.add(path);			break;		case "write":			fileOps.written.add(path);			break;		case "edit":			fileOps.edited.add(path);			break;	}}

export function computeFileLists(fileOps: FileOperations): { readFiles: string[]; modifiedFiles: string[] } {	const modified = new Set([...fileOps.edited, ...fileOps.written]);	const readOnly = [...fileOps.read].filter((f) => !modified.has(f)).sort();	const modifiedFiles = [...modified].sort();	return { readFiles: readOnly, modifiedFiles };}/** * Format file operations as XML tags for summary. */export function formatFileOperations(readFiles: string[], modifiedFiles: string[]): string {	const sections: string[] = [];	if (readFiles.length > 0) {		sections.push(`<read-files>\n${readFiles.join("\n")}\n</read-files>`);	}	if (modifiedFiles.length > 0) {		sections.push(`<modified-files>\n${modifiedFiles.join("\n")}\n</modified-files>`);	}	if (sections.length === 0) return "";	return `\n\n${sections.join("\n\n")}`;}

/** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */appendCompaction<T = unknown>(	summary: string,	firstKeptEntryId: string | null,	tokensBefore: number,	details?: T,	fromHook?: boolean,	usage?: Usage,): string {	const timestamp = new Date().toISOString();	const systemMessage = getCurrentSystemMessage(this.buildSessionProjection().messages);	const id = generateId(this.byId);	const entry: CompactionEntry<T> = {		type: "compaction",		id,		parentId: this.leafId,		timestamp,		summary,		firstKeptEntryId: firstKeptEntryId ?? id,		tokensBefore,		details,		usage,		fromHook,		...(systemMessage ? { systemMessage: { ...systemMessage, timestamp: new Date(timestamp).getTime() } } : {}),	};	this._appendEntry(entry);	return entry.id;}

export function buildContextEntries(	entries: SessionEntry[],	leafId?: string | null,	byId?: Map<string, SessionEntry>,): SessionEntry[] {	const path = buildSessionPath(entries, leafId, byId);	let compaction: CompactionEntry | null = null;	for (const entry of path) {		if (entry.type === "compaction") {			compaction = entry;		}	}	if (!compaction) {		return path;	}	const compactionIdx = path.findIndex((entry) => entry.id === compaction.id);	if (compactionIdx < 0) {		return path;	}	const contextEntries: SessionEntry[] = [compaction];	let foundFirstKept = false;	for (let i = 0; i < compactionIdx; i++) {		const entry = path[i];		if (entry.id === compaction.firstKeptEntryId) {			foundFirstKept = true;		}		if (foundFirstKept && !(entry.type === "message" && entry.message.role === "system")) {			contextEntries.push(entry);		}	}	contextEntries.push(...path.slice(compactionIdx + 1));	return contextEntries;}

export const COMPACTION_SUMMARY_PREFIX = `The conversation history before this point was compacted into the following summary:<summary>`;export const COMPACTION_SUMMARY_SUFFIX = `</summary>`;export const BRANCH_SUMMARY_PREFIX = `The following is a summary of a branch that this conversation came back from:<summary>`;export const BRANCH_SUMMARY_SUFFIX = `</summary>`;

/** Fired before context compaction (can be cancelled or customized) */export interface SessionBeforeCompactEvent {	type: "session_before_compact";	preparation: CompactionPreparation;	branchEntries: SessionEntry[];	customInstructions?: string;	/** What triggered the compaction: manual /compact, the context threshold, or context overflow recovery */	reason: "manual" | "threshold" | "overflow";	/** True when the aborted turn is retried after this compaction (overflow recovery) */	willRetry: boolean;	signal: AbortSignal;}

pi.on("session_before_compact", async (event, ctx) => {	ctx.ui.notify("Custom compaction extension triggered", "info");	const { preparation, branchEntries: _, signal } = event;	const { messagesToSummarize, turnPrefixMessages, tokensBefore, firstKeptEntryId, previousSummary } = preparation;	// Use Gemini Flash for summarization (cheaper/faster than most conversation models)	const model = ctx.modelRegistry.find("google", "gemini-2.5-flash");	if (!model) {		ctx.ui.notify(`Could not find Gemini Flash model, using default compaction`, "warning");		return;	}	// Combine all messages for full summary	const allMessages = [...messagesToSummarize, ...turnPrefixMessages];⋯ lược bớt dòng 36–99		// Return compaction content - SessionManager adds id/parentId		// Use firstKeptEntryId from preparation to keep recent messages		return {			compaction: {				summary,				firstKeptEntryId,				tokensBefore,				usage: response.usage,			},		};

// Find common ancestor (deepest node that's on both paths)const oldPath = new Set(session.getBranch(oldLeafId).map((e) => e.id));const targetPath = session.getBranch(targetId);// targetPath is root-first, so iterate backwards to find deepest common ancestorlet commonAncestorId: string | null = null;for (let i = targetPath.length - 1; i >= 0; i--) {	if (oldPath.has(targetPath[i].id)) {		commonAncestorId = targetPath[i].id;		break;	}}// Collect entries from old leaf back to common ancestorconst entries: SessionEntry[] = [];let current: string | null = oldLeafId;while (current && current !== commonAncestorId) {	const entry = session.getEntry(current);	if (!entry) break;	entries.push(entry);	current = entry.parentId;}// Reverse to get chronological orderentries.reverse();return { entries, commonAncestorId };

// Second pass: walk from newest to oldest, adding messages until token budgetfor (let i = entries.length - 1; i >= 0; i--) {	const entry = entries[i];	const message = getMessageFromEntry(entry);	if (!message) continue;	// Extract file ops from assistant messages (tool calls)	extractFileOpsFromMessage(message, fileOps);	const tokens = estimateTokens(message);	// Check budget before adding	if (tokenBudget > 0 && totalTokens + tokens > tokenBudget) {		// If this is a summary entry, try to fit it anyway as it's important context		if (entry.type === "compaction" || entry.type === "branch_summary") {			if (totalTokens < tokenBudget * 0.9) {				messages.unshift(message);				totalTokens += tokens;			}		}		// Stop - we've hit the budget		break;	}	messages.unshift(message);	totalTokens += tokens;}

const BRANCH_SUMMARY_PREAMBLE = `The user explored a different conversation branch before returning here.Summary of that exploration:`;const BRANCH_SUMMARY_PROMPT = `Create a structured summary of this conversation branch for context when returning later.Use this EXACT format:## Goal[What was the user trying to accomplish in this branch?]## Constraints & Preferences- [Any constraints, preferences, or requirements mentioned]- [Or "(none)" if none were mentioned]## Progress### Done- [x] [Completed tasks/changes]### In Progress- [ ] [Work that was started but not finished]### Blocked- [Issues preventing progress, if any]## Key Decisions- **[Decision]**: [Brief rationale]## Next Steps1. [What should happen next to continue this work]Keep each section concise. Preserve exact file paths, function names, and error messages.`;

if (targetEntry.type === "message" && targetEntry.message.role === "user") {	// User message: leaf = parent (null if root), text goes to editor	newLeafId = targetEntry.parentId;	editorText = contentText(targetEntry.message.content, "");} else if (targetEntry.type === "custom_message") {	// Custom message: leaf = parent (null if root), text goes to editor	newLeafId = targetEntry.parentId;	editorText = contentText(targetEntry.content, "");} else {	// Non-user message: leaf = selected node	newLeafId = targetId;}⋯ lược bớt dòng 4164–4167if (summaryText) {	// Create summary at target position (can be null for root)	const summaryId = this.sessionManager.branchWithSummary(		newLeafId,		summaryText,		summaryDetails,		fromExtension,		summaryUsage,	);	summaryEntry = this.sessionManager.getEntry(summaryId) as BranchSummaryEntry;

/** * Start a new branch with a summary of the abandoned path. * Same as branch(), but also appends a branch_summary entry that captures * context from the abandoned conversation path. */branchWithSummary(	branchFromId: string | null,	summary: string,	details?: unknown,	fromHook?: boolean,	usage?: Usage,): string {	if (branchFromId !== null && !this.byId.has(branchFromId)) {		throw new Error(`Entry ${branchFromId} not found`);	}	const fromId = this.leafId ?? "root";	this.leafId = branchFromId;	const entry: BranchSummaryEntry = {		type: "branch_summary",		id: generateId(this.byId),		parentId: branchFromId,		timestamp: new Date().toISOString(),		fromId,		summary,		details,		usage,		fromHook,	};	this._appendEntry(entry);	return entry.id;}