So sánh và lộ trình học

export interface SessionEntryBase {	type: string;	id: string;	parentId: string | null;	timestamp: string;}⋯ lược bớt dòng 63–181/** Session entry - has id/parentId for tree structure (returned by "read" methods in SessionManager) */export type SessionEntry =	| SessionMessageEntry	| ThinkingLevelChangeEntry	| ModelChangeEntry	| UsageEntry	| CompactionEntry	| BranchSummaryEntry	| CustomEntry	| CustomMessageEntry	| ContextEditEntry	| LabelEntry	| SessionInfoEntry;

/** Immutable identity, history ancestry, and task ownership of a transcript scope. */export type ConversationRecord = {	readonly id: ConversationId;	/** Fork source and inclusive parent entry through which history is inherited. */	readonly parent?: {		readonly conversationId: ConversationId;		readonly at: EntryId;	};	/** Creator edge used for attribution, subtree abort, and subtree idle waits. */	readonly owner?: {		readonly conversationId: ConversationId;		readonly taskId: TaskId;	};};⋯ lược bớt dòng 410–426/** Immutable transcript event with separate model-facing and application-facing payloads. */export type EntryRecord = {	readonly id: EntryId;	readonly conversationId: ConversationId;	/** Application-defined entry discriminator. */	readonly kind: string;	/** Messages contributed to model context; absent for display or bookkeeping entries. */	readonly model?: readonly Message[];	/** JSON payload consumed by views, extensions, or bookkeeping logic. */	readonly data?: JsonValue;	/** First entry in the active context selected by this entry. */	readonly head?: EntryId;	/** Context-only overrides of earlier visible entries. */	readonly edits?: readonly ContextEdit[];	/** Task that appended this entry, when it was produced by durable work. */	readonly byTaskId?: TaskId;};

_persist(entry: SessionEntry): void {	if (!this.persist || !this.sessionFile) return;	if (!this.flushed) {		if (!this._hasConversation()) return;		const fd = openSync(this.sessionFile, "wx");		try {			for (const e of this.fileEntries) {				writeFileSync(fd, `${JSON.stringify(e)}\n`);			}		} finally {			closeSync(fd);		}		this.flushed = true;	} else {		appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);	}}private _appendEntry(entry: SessionEntry): void {	this.fileEntries.push(entry);	this.byId.set(entry.id, entry);	this.leafId = entry.id;	this._persist(entry);}

/** * Start a new branch from an earlier entry. * Moves the leaf pointer to the specified entry. The next appendXXX() call * will create a child of that entry, forming a new branch. Existing entries * are not modified or deleted. */branch(branchFromId: string): void {	if (!this.byId.has(branchFromId)) {		throw new Error(`Entry ${branchFromId} not found`);	}	this.leafId = branchFromId;}

private _buildIndex(): void {	this.byId.clear();	this.labelsById.clear();	this.labelTimestampsById.clear();	this.leafId = null;	for (const entry of this.fileEntries) {		if (entry.type === "session") continue;		this.byId.set(entry.id, entry);		this.leafId = entry.id;

/** * Derive the active transcript and model context of one conversation within captured bounds. * * H = newest visible head marker; the range runs from `H.head` (or transcript start) through the tail. Per target, * the newest edit in the range wins. Context entries are H followed by the range's non-head entries. */export async function deriveContext(	storage: Storage,	conversationId: ConversationId,	bounds: ContextBounds | undefined,	context: Context,): Promise<ContextView> {	if (bounds === undefined) return emptyView();	return deriveRange(bounds, await scanRange(storage, conversationId, rangeQuery(bounds), context)).view;}function emptyView(): ContextView {	return { head: undefined, entries: [], contributions: [], messages: [] };}/** Derive the context view from the entries scanned within `bounds`. */function deriveRange(bounds: ContextBounds, entries: readonly EntryRecord[]): ContextRange {	const edits = new Map<EntryId, ContextEdit>();	// Edits of every entry in the range count, including older head markers that `selectActive()` drops.	for (const entry of entries) for (const edit of entry.edits ?? []) edits.set(edit.target, edit);	const active = selectActive(bounds.head, entries);	const contributions = active.map((entry) => contribute(entry, edits.get(entry.id)));	const { settled, open } = settle([], contributions.flat());	const baseline = findBaseline(bounds.head, active);	const messages = leadWithSystem([...settled, ...orderToolResults(open)], baseline);	const view = { head: bounds.head, entries: active, contributions, messages };	return { bounds, entries, view, edited: new Set(edits.keys()), settled, open, baseline };}

// Second pass: insert synthetic empty tool results for orphaned tool calls// This preserves thinking signatures and satisfies API requirementsconst result: Message[] = [];let pendingToolCalls: ToolCall[] = [];let existingToolResultIds = new Set<string>();// System messages are transparent to tool-call accounting: one that lands between a tool// call and its results is held back and emitted after the results (synthetic ones// included), so it never causes a duplicate result for a call that is answered later.const heldSystemMessages: Message[] = [];const closePendingToolCalls = () => {	if (pendingToolCalls.length > 0) {		for (const tc of pendingToolCalls) {			if (!existingToolResultIds.has(tc.id)) {				result.push({					role: "toolResult",					toolCallId: tc.id,					toolName: tc.name,					content: [{ type: "text", text: "No result provided" }],					isError: true,					timestamp: Date.now(),				} as ToolResultMessage);			}		}		pendingToolCalls = [];		existingToolResultIds = new Set();	}	result.push(...heldSystemMessages);	heldSystemMessages.length = 0;};⋯ lược bớt dòng 208–215		// Skip errored/aborted assistant messages entirely.		// These are incomplete turns that shouldn't be replayed:		// - May have partial content (reasoning without message, incomplete tool calls)		// - Replaying them can cause API errors (e.g., OpenAI "reasoning without following item")		// - The model should retry from the last valid state		const assistantMsg = msg as AssistantMessage;		if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {			continue;		}

const EXCLUDED_STOP_REASONS: ReadonlySet<AssistantMessage["stopReason"]> = new Set(["aborted", "error", "deferred"]);const MISSING_RESULT_TEXT = "Tool result unavailable: history ends before this call completed.";