@oh-my-pi/pi-coding-agent 8.2.2 → 8.4.0

package/src/patch/fuzzy.ts

@@ -5,7 +5,7 @@
  * fallback strategies for finding text in files.
  */
 import { countLeadingWhitespace, normalizeForFuzzy, normalizeUnicode } from "./normalize";
-import type { ContextLineResult, FuzzyMatch, MatchOutcome, SequenceSearchResult } from "./types";
+import type { ContextLineResult, FuzzyMatch, MatchOutcome, SequenceMatchStrategy, SequenceSearchResult } from "./types";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Constants
@@ -29,6 +29,12 @@ const PARTIAL_MATCH_MIN_LENGTH = 6;
 /** Minimum ratio of pattern to line length for substring match */
 const PARTIAL_MATCH_MIN_RATIO = 0.3;
 
+/** Context lines to show before/after an ambiguous match preview */
+const OCCURRENCE_PREVIEW_CONTEXT = 5;
+
+/** Maximum line length for ambiguous match previews */
+const OCCURRENCE_PREVIEW_MAX_LEN = 80;
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Core Algorithms
 // ═══════════════════════════════════════════════════════════════════════════
@@ -129,6 +135,7 @@ function computeLineOffsets(lines: string[]): number[] {
 interface BestFuzzyMatchResult {
 	best?: FuzzyMatch;
 	aboveThresholdCount: number;
+	secondBestScore: number;
 }
 
 function findBestFuzzyMatchCore(
@@ -142,6 +149,7 @@ function findBestFuzzyMatchCore(
 
 	let best: FuzzyMatch | undefined;
 	let bestScore = -1;
+	let secondBestScore = -1;
 	let aboveThresholdCount = 0;
 
 	for (let start = 0; start <= contentLines.length - targetLines.length; start++) {
@@ -158,6 +166,7 @@ function findBestFuzzyMatchCore(
 		}
 
 		if (score > bestScore) {
+			secondBestScore = bestScore;
 			bestScore = score;
 			best = {
 				actualText: windowLines.join("\n"),
@@ -165,10 +174,12 @@ function findBestFuzzyMatchCore(
 				startLine: start + 1,
 				confidence: score,
 			};
+		} else if (score > secondBestScore) {
+			secondBestScore = score;
 		}
 	}
 
-	return { best, aboveThresholdCount };
+	return { best, aboveThresholdCount, secondBestScore };
 }
 
 function findBestFuzzyMatch(content: string, target: string, threshold: number): BestFuzzyMatchResult {
@@ -176,10 +187,10 @@ function findBestFuzzyMatch(content: string, target: string, threshold: number):
 	const targetLines = target.split("\n");
 
 	if (targetLines.length === 0 || target.length === 0) {
-		return { aboveThresholdCount: 0 };
+		return { aboveThresholdCount: 0, secondBestScore: 0 };
 	}
 	if (targetLines.length > contentLines.length) {
-		return { aboveThresholdCount: 0 };
+		return { aboveThresholdCount: 0, secondBestScore: 0 };
 	}
 
 	const offsets = computeLineOffsets(contentLines);
@@ -224,10 +235,14 @@ export function findMatch(
 				if (idx === -1) break;
 				const lineNumber = content.slice(0, idx).split("\n").length;
 				occurrenceLines.push(lineNumber);
-				// Extract 3 lines starting from match (0-indexed)
-				const previewLines = contentLines.slice(lineNumber - 1, lineNumber + 2);
+				const start = Math.max(0, lineNumber - 1 - OCCURRENCE_PREVIEW_CONTEXT);
+				const end = Math.min(contentLines.length, lineNumber + OCCURRENCE_PREVIEW_CONTEXT + 1);
+				const previewLines = contentLines.slice(start, end);
 				const preview = previewLines
-					.map((line, i) => `  ${lineNumber + i} | ${line.length > 60 ? `${line.slice(0, 57)}...` : line}`)
+					.map((line, idx) => {
+						const num = start + idx + 1;
+						return `  ${num} | ${line.length > OCCURRENCE_PREVIEW_MAX_LEN ? `${line.slice(0, OCCURRENCE_PREVIEW_MAX_LEN - 3)}...` : line}`;
+					})
 					.join("\n");
 				occurrencePreviews.push(preview);
 				searchStart = idx + 1;
@@ -247,14 +262,25 @@ export function findMatch(
 
 	// Try fuzzy match
 	const threshold = options.threshold ?? DEFAULT_FUZZY_THRESHOLD;
-	const { best, aboveThresholdCount } = findBestFuzzyMatch(content, target, threshold);
+	const { best, aboveThresholdCount, secondBestScore } = findBestFuzzyMatch(content, target, threshold);
 
 	if (!best) {
 		return {};
 	}
 
-	if (options.allowFuzzy && best.confidence >= threshold && aboveThresholdCount === 1) {
-		return { match: best, closest: best };
+	if (options.allowFuzzy && best.confidence >= threshold) {
+		if (aboveThresholdCount === 1) {
+			return { match: best, closest: best };
+		}
+		const dominantDelta = 0.08;
+		const dominantMin = 0.97;
+		if (
+			aboveThresholdCount > 1 &&
+			best.confidence >= dominantMin &&
+			best.confidence - secondBestScore >= dominantDelta
+		) {
+			return { match: best, closest: best, fuzzyMatches: aboveThresholdCount, dominantFuzzy: true };
+		}
 	}
 
 	return { closest: best, fuzzyMatches: aboveThresholdCount };
@@ -350,7 +376,7 @@ export function seekSequence(
 	const allowFuzzy = options?.allowFuzzy ?? true;
 	// Empty pattern matches immediately
 	if (pattern.length === 0) {
-		return { index: start, confidence: 1.0 };
+		return { index: start, confidence: 1.0, strategy: "exact" };
 	}
 
 	// Pattern longer than available content cannot match
@@ -366,35 +392,35 @@ export function seekSequence(
 		// Pass 1: Exact match
 		for (let i = from; i <= to; i++) {
 			if (matchesAt(lines, pattern, i, (a, b) => a === b)) {
-				return { index: i, confidence: 1.0 };
+				return { index: i, confidence: 1.0, strategy: "exact" };
 			}
 		}
 
 		// Pass 2: Trailing whitespace stripped
 		for (let i = from; i <= to; i++) {
 			if (matchesAt(lines, pattern, i, (a, b) => a.trimEnd() === b.trimEnd())) {
-				return { index: i, confidence: 0.99 };
+				return { index: i, confidence: 0.99, strategy: "trim-trailing" };
 			}
 		}
 
 		// Pass 3: Both leading and trailing whitespace stripped
 		for (let i = from; i <= to; i++) {
 			if (matchesAt(lines, pattern, i, (a, b) => a.trim() === b.trim())) {
-				return { index: i, confidence: 0.98 };
+				return { index: i, confidence: 0.98, strategy: "trim" };
 			}
 		}
 
 		// Pass 3b: Comment-prefix normalized match
 		for (let i = from; i <= to; i++) {
 			if (matchesAt(lines, pattern, i, (a, b) => stripCommentPrefix(a) === stripCommentPrefix(b))) {
-				return { index: i, confidence: 0.975 };
+				return { index: i, confidence: 0.975, strategy: "comment-prefix" };
 			}
 		}
 
 		// Pass 4: Normalize unicode punctuation
 		for (let i = from; i <= to; i++) {
 			if (matchesAt(lines, pattern, i, (a, b) => normalizeUnicode(a) === normalizeUnicode(b))) {
-				return { index: i, confidence: 0.97 };
+				return { index: i, confidence: 0.97, strategy: "unicode" };
 			}
 		}
 
@@ -406,14 +432,16 @@ export function seekSequence(
 		{
 			let firstMatch: number | undefined;
 			let matchCount = 0;
+			const matchIndices: number[] = [];
 			for (let i = from; i <= to; i++) {
 				if (matchesAt(lines, pattern, i, lineStartsWithPattern)) {
 					if (firstMatch === undefined) firstMatch = i;
 					matchCount++;
+					if (matchIndices.length < 5) matchIndices.push(i);
 				}
 			}
 			if (matchCount > 0) {
-				return { index: firstMatch, confidence: 0.965, matchCount };
+				return { index: firstMatch, confidence: 0.965, matchCount, matchIndices, strategy: "prefix" };
 			}
 		}
 
@@ -421,14 +449,16 @@ export function seekSequence(
 		{
 			let firstMatch: number | undefined;
 			let matchCount = 0;
+			const matchIndices: number[] = [];
 			for (let i = from; i <= to; i++) {
 				if (matchesAt(lines, pattern, i, lineIncludesPattern)) {
 					if (firstMatch === undefined) firstMatch = i;
 					matchCount++;
+					if (matchIndices.length < 5) matchIndices.push(i);
 				}
 			}
 			if (matchCount > 0) {
-				return { index: firstMatch, confidence: 0.94, matchCount };
+				return { index: firstMatch, confidence: 0.94, matchCount, matchIndices, strategy: "substring" };
 			}
 		}
 
@@ -454,16 +484,22 @@ export function seekSequence(
 	// Pass 7: Fuzzy matching - find best match above threshold
 	let bestIndex: number | undefined;
 	let bestScore = 0;
+	let secondBestScore = 0;
 	let matchCount = 0;
+	const matchIndices: number[] = [];
 
 	for (let i = searchStart; i <= maxStart; i++) {
 		const score = fuzzyScoreAt(lines, pattern, i);
 		if (score >= SEQUENCE_FUZZY_THRESHOLD) {
 			matchCount++;
+			if (matchIndices.length < 5) matchIndices.push(i);
 		}
 		if (score > bestScore) {
+			secondBestScore = bestScore;
 			bestScore = score;
 			bestIndex = i;
+		} else if (score > secondBestScore) {
+			secondBestScore = score;
 		}
 	}
 
@@ -473,16 +509,31 @@ export function seekSequence(
 			const score = fuzzyScoreAt(lines, pattern, i);
 			if (score >= SEQUENCE_FUZZY_THRESHOLD) {
 				matchCount++;
+				if (matchIndices.length < 5) matchIndices.push(i);
 			}
 			if (score > bestScore) {
+				secondBestScore = bestScore;
 				bestScore = score;
 				bestIndex = i;
+			} else if (score > secondBestScore) {
+				secondBestScore = score;
 			}
 		}
 	}
 
 	if (bestIndex !== undefined && bestScore >= SEQUENCE_FUZZY_THRESHOLD) {
-		return { index: bestIndex, confidence: bestScore, matchCount };
+		const dominantDelta = 0.08;
+		const dominantMin = 0.97;
+		if (matchCount > 1 && bestScore >= dominantMin && bestScore - secondBestScore >= dominantDelta) {
+			return {
+				index: bestIndex,
+				confidence: bestScore,
+				matchCount: 1,
+				matchIndices,
+				strategy: "fuzzy-dominant",
+			};
+		}
+		return { index: bestIndex, confidence: bestScore, matchCount, matchIndices, strategy: "fuzzy" };
 	}
 
 	// Pass 8: Character-based fuzzy matching via findMatch
@@ -500,13 +551,59 @@ export function seekSequence(
 		const matchedContent = contentText.substring(0, matchOutcome.match.startIndex);
 		const lineIndex = start + matchedContent.split("\n").length - 1;
 		const fallbackMatchCount = matchOutcome.occurrences ?? matchOutcome.fuzzyMatches ?? 1;
-		return { index: lineIndex, confidence: matchOutcome.match.confidence, matchCount: fallbackMatchCount };
+		return {
+			index: lineIndex,
+			confidence: matchOutcome.match.confidence,
+			matchCount: fallbackMatchCount,
+			strategy: "character",
+		};
 	}
 
 	const fallbackMatchCount = matchOutcome.occurrences ?? matchOutcome.fuzzyMatches;
 	return { index: undefined, confidence: bestScore, matchCount: fallbackMatchCount };
 }
 
+export function findClosestSequenceMatch(
+	lines: string[],
+	pattern: string[],
+	options?: { start?: number; eof?: boolean },
+): { index: number | undefined; confidence: number; strategy: SequenceMatchStrategy } {
+	if (pattern.length === 0) {
+		return { index: options?.start ?? 0, confidence: 1, strategy: "exact" };
+	}
+	if (pattern.length > lines.length) {
+		return { index: undefined, confidence: 0, strategy: "fuzzy" };
+	}
+
+	const start = options?.start ?? 0;
+	const eof = options?.eof ?? false;
+	const maxStart = lines.length - pattern.length;
+	const searchStart = eof && lines.length >= pattern.length ? maxStart : start;
+
+	let bestIndex: number | undefined;
+	let bestScore = 0;
+
+	for (let i = searchStart; i <= maxStart; i++) {
+		const score = fuzzyScoreAt(lines, pattern, i);
+		if (score > bestScore) {
+			bestScore = score;
+			bestIndex = i;
+		}
+	}
+
+	if (eof && searchStart > start) {
+		for (let i = start; i < searchStart; i++) {
+			const score = fuzzyScoreAt(lines, pattern, i);
+			if (score > bestScore) {
+				bestScore = score;
+				bestIndex = i;
+			}
+		}
+	}
+
+	return { index: bestIndex, confidence: bestScore, strategy: "fuzzy" };
+}
+
 /**
  * Find a context line in the file using progressive matching strategies.
  *
@@ -527,14 +624,16 @@ export function findContextLine(
 	{
 		let firstMatch: number | undefined;
 		let matchCount = 0;
+		const matchIndices: number[] = [];
 		for (let i = startFrom; i < lines.length; i++) {
 			if (lines[i] === context) {
 				if (firstMatch === undefined) firstMatch = i;
 				matchCount++;
+				if (matchIndices.length < 5) matchIndices.push(i);
 			}
 		}
 		if (matchCount > 0) {
-			return { index: firstMatch, confidence: 1.0, matchCount };
+			return { index: firstMatch, confidence: 1.0, matchCount, matchIndices, strategy: "exact" };
 		}
 	}
 
@@ -542,14 +641,16 @@ export function findContextLine(
 	{
 		let firstMatch: number | undefined;
 		let matchCount = 0;
+		const matchIndices: number[] = [];
 		for (let i = startFrom; i < lines.length; i++) {
 			if (lines[i].trim() === trimmedContext) {
 				if (firstMatch === undefined) firstMatch = i;
 				matchCount++;
+				if (matchIndices.length < 5) matchIndices.push(i);
 			}
 		}
 		if (matchCount > 0) {
-			return { index: firstMatch, confidence: 0.99, matchCount };
+			return { index: firstMatch, confidence: 0.99, matchCount, matchIndices, strategy: "trim" };
 		}
 	}
 
@@ -558,14 +659,16 @@ export function findContextLine(
 	{
 		let firstMatch: number | undefined;
 		let matchCount = 0;
+		const matchIndices: number[] = [];
 		for (let i = startFrom; i < lines.length; i++) {
 			if (normalizeUnicode(lines[i]) === normalizedContext) {
 				if (firstMatch === undefined) firstMatch = i;
 				matchCount++;
+				if (matchIndices.length < 5) matchIndices.push(i);
 			}
 		}
 		if (matchCount > 0) {
-			return { index: firstMatch, confidence: 0.98, matchCount };
+			return { index: firstMatch, confidence: 0.98, matchCount, matchIndices, strategy: "unicode" };
 		}
 	}
 
@@ -578,15 +681,17 @@ export function findContextLine(
 	if (contextNorm.length > 0) {
 		let firstMatch: number | undefined;
 		let matchCount = 0;
+		const matchIndices: number[] = [];
 		for (let i = startFrom; i < lines.length; i++) {
 			const lineNorm = normalizeForFuzzy(lines[i]);
 			if (lineNorm.startsWith(contextNorm)) {
 				if (firstMatch === undefined) firstMatch = i;
 				matchCount++;
+				if (matchIndices.length < 5) matchIndices.push(i);
 			}
 		}
 		if (matchCount > 0) {
-			return { index: firstMatch, confidence: 0.96, matchCount };
+			return { index: firstMatch, confidence: 0.96, matchCount, matchIndices, strategy: "prefix" };
 		}
 	}
 
@@ -603,10 +708,17 @@ export function findContextLine(
 				allSubstringMatches.push({ index: i, ratio });
 			}
 		}
+		const matchIndices = allSubstringMatches.slice(0, 5).map(match => match.index);
 
 		// If exactly one substring match, accept it regardless of ratio
 		if (allSubstringMatches.length === 1) {
-			return { index: allSubstringMatches[0].index, confidence: 0.94, matchCount: 1 };
+			return {
+				index: allSubstringMatches[0].index,
+				confidence: 0.94,
+				matchCount: 1,
+				matchIndices,
+				strategy: "substring",
+			};
 		}
 
 		// Multiple matches: filter by ratio to disambiguate
@@ -619,13 +731,19 @@ export function findContextLine(
 			}
 		}
 		if (matchCount > 0) {
-			return { index: firstMatch, confidence: 0.94, matchCount };
+			return { index: firstMatch, confidence: 0.94, matchCount, matchIndices, strategy: "substring" };
 		}
 
 		// If we had substring matches but none passed ratio filter,
 		// return ambiguous result so caller knows matches exist
 		if (allSubstringMatches.length > 1) {
-			return { index: allSubstringMatches[0].index, confidence: 0.94, matchCount: allSubstringMatches.length };
+			return {
+				index: allSubstringMatches[0].index,
+				confidence: 0.94,
+				matchCount: allSubstringMatches.length,
+				matchIndices,
+				strategy: "substring",
+			};
 		}
 	}
 
@@ -633,12 +751,14 @@ export function findContextLine(
 	let bestIndex: number | undefined;
 	let bestScore = 0;
 	let matchCount = 0;
+	const matchIndices: number[] = [];
 
 	for (let i = startFrom; i < lines.length; i++) {
 		const lineNorm = normalizeForFuzzy(lines[i]);
 		const score = similarity(lineNorm, contextNorm);
 		if (score >= CONTEXT_FUZZY_THRESHOLD) {
 			matchCount++;
+			if (matchIndices.length < 5) matchIndices.push(i);
 		}
 		if (score > bestScore) {
 			bestScore = score;
@@ -647,7 +767,7 @@ export function findContextLine(
 	}
 
 	if (bestIndex !== undefined && bestScore >= CONTEXT_FUZZY_THRESHOLD) {
-		return { index: bestIndex, confidence: bestScore, matchCount };
+		return { index: bestIndex, confidence: bestScore, matchCount, matchIndices, strategy: "fuzzy" };
 	}
 
 	if (!options?.skipFunctionFallback && trimmedContext.endsWith("()")) {

package/src/patch/index.ts

@@ -167,6 +167,27 @@ class LspFileSystem implements FileSystem {
 	}
 }
 
+function mergeDiagnosticsWithWarnings(
+	diagnostics: FileDiagnosticsResult | undefined,
+	warnings: string[],
+): FileDiagnosticsResult | undefined {
+	if (warnings.length === 0) return diagnostics;
+	const warningMessages = warnings.map(warning => `patch: ${warning}`);
+	if (!diagnostics) {
+		return {
+			server: "patch",
+			messages: warningMessages,
+			summary: `Patch warnings: ${warnings.length}`,
+			errored: false,
+		};
+	}
+	return {
+		...diagnostics,
+		messages: [...warningMessages, ...diagnostics.messages],
+		summary: `${diagnostics.summary}; Patch warnings: ${warnings.length}`,
+	};
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Tool Class
 // ═══════════════════════════════════════════════════════════════════════════
@@ -319,9 +340,11 @@ export class EditTool implements AgentTool<TInput> {
 				const flushedDiagnostics = await flushLspWritethroughBatch(batchRequest.id, this.session.cwd, signal);
 				diagnostics ??= flushedDiagnostics;
 			}
+			const patchWarnings = result.warnings ?? [];
+			const mergedDiagnostics = mergeDiagnosticsWithWarnings(diagnostics, patchWarnings);
 
 			const meta = outputMeta()
-				.diagnostics(diagnostics?.summary ?? "", diagnostics?.messages ?? [])
+				.diagnostics(mergedDiagnostics?.summary ?? "", mergedDiagnostics?.messages ?? [])
 				.get();
 
 			return {
@@ -329,7 +352,7 @@ export class EditTool implements AgentTool<TInput> {
 				details: {
 					diff: diffResult.diff,
 					firstChangedLine: diffResult.firstChangedLine,
-					diagnostics,
+					diagnostics: mergedDiagnostics,
 					op,
 					rename: effRename,
 					meta,

package/src/patch/parser.ts

@@ -328,6 +328,11 @@ function parseOneHunk(lines: string[], lineNumber: number, allowMissingContext:
 	for (let i = startIndex; i < lines.length; i++) {
 		const line = lines[i];
 		const trimmed = line.trim();
+		const nextLine = lines[i + 1];
+
+		if (line === "" && parsedLines > 0 && nextLine?.trimStart().startsWith("@@")) {
+			break;
+		}
 
 		if (!isDiffContentLine(line) && line.trimEnd() === EOF_MARKER && line.startsWith(EOF_MARKER)) {
 			if (parsedLines === 0) {

package/src/patch/types.ts

@@ -46,9 +46,23 @@ export interface MatchOutcome {
 	occurrencePreviews?: string[];
 	/** Number of fuzzy matches above threshold */
 	fuzzyMatches?: number;
+	/** True when a dominant fuzzy match was accepted despite multiple candidates */
+	dominantFuzzy?: boolean;
 }
 
 /** Result of a sequence search */
+export type SequenceMatchStrategy =
+	| "exact"
+	| "trim-trailing"
+	| "trim"
+	| "comment-prefix"
+	| "unicode"
+	| "prefix"
+	| "substring"
+	| "fuzzy"
+	| "fuzzy-dominant"
+	| "character";
+
 export interface SequenceSearchResult {
 	/** Starting line index of the match (0-indexed) */
 	index: number | undefined;
@@ -56,9 +70,15 @@ export interface SequenceSearchResult {
 	confidence: number;
 	/** Number of matches at the same confidence level (for ambiguity detection) */
 	matchCount?: number;
+	/** Sample of matching indices (0-indexed, up to a small limit) */
+	matchIndices?: number[];
+	/** Matching strategy used */
+	strategy?: SequenceMatchStrategy;
 }
 
 /** Result of a context line search */
+export type ContextMatchStrategy = "exact" | "trim" | "unicode" | "prefix" | "substring" | "fuzzy";
+
 export interface ContextLineResult {
 	/** Index of the matching line (0-indexed) */
 	index: number | undefined;
@@ -66,6 +86,10 @@ export interface ContextLineResult {
 	confidence: number;
 	/** Number of matches at the same confidence level (for ambiguity detection) */
 	matchCount?: number;
+	/** Sample of matching indices (0-indexed, up to a small limit) */
+	matchIndices?: number[];
+	/** Matching strategy used */
+	strategy?: ContextMatchStrategy;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -133,6 +157,7 @@ export interface FileChange {
 /** Result of applying a patch */
 export interface ApplyPatchResult {
 	change: FileChange;
+	warnings?: string[];
 }
 
 /** Options for applying a patch */

package/src/sdk.ts

@@ -166,6 +166,8 @@ export interface CreateAgentSessionOptions {
 
 	/** Enable LSP integration (tool, formatting, diagnostics, warmup). Default: true */
 	enableLsp?: boolean;
+	/** Skip Python kernel availability check and prelude warmup */
+	skipPythonPreflight?: boolean;
 
 	/** Tool names explicitly requested (enables disabled-by-default tools) */
 	toolNames?: string[];
@@ -734,6 +736,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		cwd,
 		hasUI: options.hasUI ?? false,
 		enableLsp,
+		skipPythonPreflight: options.skipPythonPreflight,
+		contextFiles,
+		skills,
 		eventBus,
 		outputSchema: options.outputSchema,
 		requireCompleteTool: options.requireCompleteTool,
@@ -989,6 +994,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	const promptTemplates = options.promptTemplates ?? (await discoverPromptTemplates(cwd, agentDir));
 	time("discoverPromptTemplates");
+	toolSession.promptTemplates = promptTemplates;
 
 	const slashCommands = options.slashCommands ?? (await discoverSlashCommands(cwd));
 	time("discoverSlashCommands");

package/src/session/agent-session.ts

@@ -205,6 +205,7 @@ const noOpUIContext: ExtensionUIContext = {
 	input: async (_title, _placeholder, _dialogOptions) => undefined,
 	notify: () => {},
 	setStatus: () => {},
+	setWorkingMessage: () => {},
 	setWidget: () => {},
 	setTitle: () => {},
 	custom: async () => undefined as never,

package/src/session/session-manager.ts

@@ -1027,6 +1027,9 @@ export class SessionManager {
 			const explicitPath = this.sessionFile;
 			this._newSessionSync();
 			this.sessionFile = explicitPath; // preserve explicit path from --session flag
+			await this._rewriteFile();
+			this.flushed = true;
+			return;
 		}
 	}
 

package/src/task/agents.ts

@@ -18,7 +18,7 @@ interface AgentFrontmatter {
 	name: string;
 	description: string;
 	spawns?: string;
-	model?: string;
+	model?: string | string[];
 	thinkingLevel?: string;
 }