@askjo/pi-reflect 1.0.0 → 1.2.0

package/extensions/reflect.ts

@@ -63,7 +63,7 @@ export interface ReflectConfig {
 }
 
 export interface EditRecord {
-	type: "strengthen" | "add";
+	type: "strengthen" | "add" | "remove" | "merge";
 	section: string;
 	reason: string;
 }
@@ -80,6 +80,8 @@ export interface ReflectRun {
 	edits?: EditRecord[];
 	sourceDate?: string;
 	date?: string; // legacy field from bash-script/batch runs
+	/** File size metrics after this run */
+	fileSize?: { chars: number; words: number; lines: number; estTokens: number };
 }
 
 export interface SessionExchange {
@@ -101,6 +103,8 @@ export interface TranscriptResult {
 	transcripts: string;
 	sessionCount: number;
 	includedCount: number;
+	/** Individual sessions for chunked processing when transcripts exceed context budget */
+	sessions?: SessionData[];
 }
 
 export interface EditResult {
@@ -110,11 +114,13 @@ export interface EditResult {
 }
 
 export interface AnalysisEdit {
-	type: "strengthen" | "add";
+	type: "strengthen" | "add" | "remove" | "merge";
 	section?: string;
 	old_text?: string | null;
 	new_text: string;
 	after_text?: string | null;
+	/** For "merge": array of exact text strings to remove (they're consolidated into new_text) */
+	merge_sources?: string[];
 	reason?: string;
 }
 
@@ -122,6 +128,10 @@ export interface ReflectionOptions {
 	sourceDateOverride?: string;
 	transcriptsOverride?: TranscriptResult;
 	dryRun?: boolean;
+	/** Override model — use the current session model instead of target.model */
+	currentModel?: any;
+	currentModelApiKey?: string;
+	currentModelHeaders?: Record<string, string>;
 }
 
 export type NotifyFn = (msg: string, level: "info" | "warning" | "error") => void;
@@ -141,6 +151,17 @@ export const DEFAULT_TARGET: ReflectTarget = {
 export const MAX_ASSISTANT_MSG_CHARS = 2000;
 export const MAX_THINKING_MSG_CHARS = 1500;
 
+// --- File size metrics ---
+
+export function computeFileMetrics(content: string): { chars: number; words: number; lines: number; estTokens: number } {
+	const chars = content.length;
+	const words = content.split(/\s+/).filter(Boolean).length;
+	const lines = content.split("\n").length;
+	// Rough estimate: ~4 chars per token for English/code mix
+	const estTokens = Math.round(chars / 4);
+	return { chars, words, lines, estTokens };
+}
+
 // --- Config ---
 
 export function loadConfig(): ReflectConfig {
@@ -395,7 +416,7 @@ async function collectSessionsForDates(
 	}
 
 	if (allSessions.length === 0) {
-		return { transcripts: "", sessionCount: totalScanned, includedCount: 0 };
+		return { transcripts: "", sessionCount: totalScanned, includedCount: 0, sessions: [] };
 	}
 
 	allSessions.sort((a, b) => {
@@ -426,6 +447,7 @@ async function collectSessionsForDates(
 		transcripts: header + parts.join(""),
 		sessionCount: totalScanned,
 		includedCount: included,
+		sessions: allSessions,
 	};
 }
 
@@ -483,6 +505,68 @@ function isWithinLookback(filename: string, cutoff: string): boolean {
 	return match[1] >= cutoff;
 }
 
+function findGlobBaseDir(globPattern: string): string {
+	const normalized = path.normalize(globPattern);
+	const segments = normalized.split(path.sep);
+	const globIndex = segments.findIndex((segment) => segment.includes("*"));
+
+	if (globIndex === -1) return path.dirname(normalized);
+
+	const baseSegments = segments.slice(0, globIndex).filter(Boolean);
+	if (normalized.startsWith(path.sep)) {
+		return baseSegments.length > 0 ? path.join(path.sep, ...baseSegments) : path.sep;
+	}
+	return baseSegments.length > 0 ? path.join(...baseSegments) : ".";
+}
+
+function globToRegex(globPattern: string): RegExp {
+	const normalized = globPattern.split(path.sep).join("/");
+	const escaped = normalized.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+	const globstarToken = "__PI_REFLECT_GLOBSTAR__";
+	const withGlobstarToken = escaped.replace(/\*\*\/?/g, globstarToken);
+	const withWildcards = withGlobstarToken.replace(/\*/g, "[^/]*");
+	const withGlobstar = withWildcards.replaceAll(globstarToken, "(?:.*/)?");
+	return new RegExp(`^${withGlobstar}$`);
+}
+
+function walkFilesRecursive(dir: string): string[] {
+	const files: string[] = [];
+
+	try {
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				files.push(...walkFilesRecursive(fullPath));
+			} else if (entry.isFile()) {
+				files.push(fullPath);
+			}
+		}
+	} catch {}
+
+	return files;
+}
+
+function findMatchingFiles(globPattern: string): { name: string; full: string }[] {
+	const baseDir = findGlobBaseDir(globPattern);
+	if (!fs.existsSync(baseDir)) return [];
+
+	const relativePattern = path.relative(baseDir, globPattern);
+	const relativeRegex = globToRegex(relativePattern);
+	const basenameRegex = !relativePattern.includes(path.sep) ? globToRegex(path.basename(globPattern)) : null;
+
+	return walkFilesRecursive(baseDir)
+		.filter((fullPath) => {
+			const relativePath = path.relative(baseDir, fullPath).split(path.sep).join("/");
+			const baseName = path.basename(fullPath);
+			return relativeRegex.test(relativePath) || (basenameRegex?.test(baseName) ?? false);
+		})
+		.map((fullPath) => ({
+			name: path.relative(baseDir, fullPath).split(path.sep).join("/"),
+			full: fullPath,
+		}));
+}
+
 export async function collectContext(sources: ContextSource[], lookbackDays: number): Promise<string> {
 	const parts: string[] = [];
 	const cutoff = lookbackCutoff(lookbackDays);
@@ -501,14 +585,7 @@ export async function collectContext(sources: ContextSource[], lookbackDays: num
 					let candidates: { name: string; full: string }[] = [];
 
 					if (expanded.includes("*")) {
-						const dir = path.dirname(expanded);
-						const filePattern = path.basename(expanded);
-						const regex = new RegExp("^" + filePattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$");
-						try {
-							candidates = fs.readdirSync(dir)
-								.filter(f => regex.test(f))
-								.map(f => ({ name: f, full: path.join(dir, f) }));
-						} catch {}
+						candidates = findMatchingFiles(expanded);
 					} else if (fs.existsSync(expanded)) {
 						candidates = [{ name: path.basename(expanded), full: expanded }];
 					}
@@ -582,8 +659,20 @@ export function getAvailableSessionDates(): string[] {
 
 export function buildReflectionPrompt(targetPath: string, targetContent: string, transcripts: string): string {
 	const fileName = path.basename(targetPath);
+	const charCount = targetContent.length;
+	const lineCount = targetContent.split("\n").length;
 	return `You are reviewing recent agent session transcripts to improve ${fileName}.
 
+## CRITICAL: Conciseness
+
+The target file is ${lineCount} lines / ${charCount} chars. Your #1 job is to keep it CONCISE.
+- Every rule should be 1-2 sentences max. If a rule is longer, condense it.
+- Remove session counts, escalating repetition tallies, and "this happened N times" histories — the rule itself is what matters, not how many times it was violated.
+- Remove verbose examples when the rule is self-explanatory.
+- Merge rules that say the same thing in different words.
+- Remove rules that are subsumed by other, better-worded rules.
+- A good rule file is SHORT and scannable. Walls of text get ignored by agents.
+
 ## Input
 
 ### Target file: ${fileName}
@@ -598,58 +687,52 @@ ${transcripts}
 
 ## Step 1: Identify Correction Patterns
 
-Read through all the transcripts carefully. Look for:
-- User redirecting the agent ("no", "not that", "I said...", "wrong", "actually...")
-- User expressing frustration ("bro", "wtf", "seriously", "come on", "sigh")
-- User having to repeat themselves or re-explain
-- User asking the agent to undo or revert something
-- User telling the agent to simplify or stop over-engineering
-- User correcting the agent's approach or understanding
-- Agent thinking that reveals a misunderstanding that the user then corrects
+Read the transcripts for genuine corrections — user redirecting the agent, expressing frustration, repeating themselves, or correcting approach. Ignore normal flow ("no worries", "actually that looks good").
 
-For each real correction, note: what the agent did wrong, what the user wanted, and which rule in ${fileName} (if any) already covers this.
+For each correction: what the agent did wrong, what the user wanted, and which rule (if any) already covers it.
 
-Ignore normal conversation flow — "no" in "no worries" or "actually, that looks good" are NOT corrections. Focus on genuine friction where the agent's behavior wasted the user's time.
+## Step 2: Propose Edits (prioritize conciseness)
 
-## Step 2: Propose Edits
+Four edit types available:
+1. **strengthen**: Tighten an existing rule's wording (make it clearer/shorter, not longer).
+2. **add**: Add a new rule for a pattern with 2+ occurrences. Keep it to 1-2 sentences.
+3. **remove**: Delete a rule that is redundant (covered by another rule), obsolete, or overly verbose noise.
+4. **merge**: Consolidate 2+ rules that overlap into one concise rule.
 
-Based on the patterns you found:
-- Only propose edits that address ACTUAL patterns in the transcripts. Don't invent hypothetical rules.
-- If an existing rule already covers the pattern but the agent still violated it, STRENGTHEN the wording (make it more prominent, add emphasis, add a concrete example).
-- If a correction pattern has no matching rule, propose a new bullet in the most appropriate existing section.
-- Do NOT reorganize, rewrite, or restructure the file. Propose minimal, targeted edits.
-- Do NOT remove any existing rules.
-- Do NOT add rules for one-off situations. Only add rules for patterns (2+ occurrences across different sessions).
-- Keep the same tone and style as the existing file.
+Guidelines:
+- Prefer strengthen/merge/remove over add. The file should get SHORTER or stay the same size, not grow.
+- When strengthening, make the rule SHORTER and CLEARER — don't add history or examples unless essential.
+- Strip "This happened in N sessions", "RECURRING", session dates, escalating violation counts. The rule text is enough.
+- Don't reorganize or restructure the file. Minimal, targeted edits only.
+- Don't add one-off rules. Only patterns with 2+ occurrences.
 
 ## Step 3: Output
 
-IMPORTANT: Your ENTIRE response must be a single JSON object. No markdown, no explanation, no preamble. Start with { and end with }.
+IMPORTANT: Your ENTIRE response must be a single JSON object. No markdown, no preamble.
 
-For "strengthen" edits: old_text must be a COMPLETE bullet point or rule from the file, copied character-for-character. new_text is the full replacement. Do NOT use partial strings — always include the complete line/bullet from "- **" to the end of the bullet point.
-For "add" edits: after_text must be a COMPLETE bullet point or line from the file, copied exactly. new_text is inserted on a new line after it. The new_text should be a complete new bullet point.
-CRITICAL: Never duplicate content. new_text should EXTEND or REPLACE old_text, not repeat it.
+For "strengthen": old_text = COMPLETE bullet/rule copied exactly. new_text = shorter/clearer replacement.
+For "add": after_text = COMPLETE bullet/line copied exactly. new_text = concise new bullet (1-2 sentences).
+For "remove": old_text = COMPLETE bullet/rule to delete. new_text = "" (empty string).
+For "merge": merge_sources = array of COMPLETE bullets to consolidate. new_text = single concise replacement. The merged text replaces the first source; others are removed.
 
 {
   "corrections_found": <number>,
   "sessions_with_corrections": <number>,
   "edits": [
     {
-      "type": "strengthen" | "add",
+      "type": "strengthen" | "add" | "remove" | "merge",
       "section": "which section of the file",
-      "old_text": "exact text to find (for strengthen) or null (for add)",
-      "new_text": "replacement text (for strengthen) or new text to insert (for add)",
-      "after_text": "text after which to insert (for add) or null (for strengthen)",
-      "reason": "why this edit is needed, with session evidence"
+      "old_text": "exact text to find (strengthen/remove) or null (add/merge)",
+      "new_text": "replacement/new text, or empty string for remove",
+      "after_text": "insertion point (add only) or null",
+      "merge_sources": ["exact text 1", "exact text 2"] or null (merge only),
+      "reason": "brief reason for this edit"
     }
   ],
   "patterns_not_added": [
-    {
-      "pattern": "description",
-      "reason": "why it wasn't added (one-off, already covered, etc.)"
-    }
+    { "pattern": "description", "reason": "why not added" }
   ],
-  "summary": "2-3 sentence summary of what was found and changed"
+  "summary": "2-3 sentence summary"
 }`;
 }
 
@@ -718,6 +801,56 @@ export function applyEdits(content: string, edits: AnalysisEdit[]): EditResult {
 
 			result = result.replace(edit.after_text, edit.after_text + "\n" + edit.new_text);
 			applied++;
+		} else if (edit.type === "remove" && edit.old_text) {
+			if (!result.includes(edit.old_text)) {
+				skipped.push(`Could not find text to remove: "${edit.old_text.slice(0, 80)}..."`);
+				continue;
+			}
+
+			const firstIdx = result.indexOf(edit.old_text);
+			const secondIdx = result.indexOf(edit.old_text, firstIdx + 1);
+			if (secondIdx !== -1) {
+				skipped.push(`Ambiguous match for removal (appears multiple times): "${edit.old_text.slice(0, 80)}..."`);
+				continue;
+			}
+
+			// Remove the text and any trailing blank line
+			result = result.replace(edit.old_text + "\n", "");
+			if (result.includes(edit.old_text)) {
+				result = result.replace(edit.old_text, "");
+			}
+			applied++;
+		} else if (edit.type === "merge" && edit.merge_sources && edit.merge_sources.length > 0 && edit.new_text) {
+			// Remove all source texts, then insert the consolidated new_text where the first source was
+			let firstSourceIdx = Infinity;
+			let firstSourceText = "";
+			let allFound = true;
+
+			for (const src of edit.merge_sources) {
+				if (!result.includes(src)) {
+					skipped.push(`Merge source not found: "${src.slice(0, 80)}..."`);
+					allFound = false;
+					break;
+				}
+				const idx = result.indexOf(src);
+				if (idx < firstSourceIdx) {
+					firstSourceIdx = idx;
+					firstSourceText = src;
+				}
+			}
+			if (!allFound) continue;
+
+			// Replace the first source with the merged text
+			result = result.replace(firstSourceText, edit.new_text);
+			// Remove the remaining sources
+			for (const src of edit.merge_sources) {
+				if (src === firstSourceText) continue;
+				result = result.replace(src + "\n", "");
+				if (result.includes(src)) {
+					result = result.replace(src, "");
+				}
+			}
+			applied++;
 		} else {
 			skipped.push(`Invalid edit: ${JSON.stringify(edit).slice(0, 100)}`);
 		}
@@ -726,8 +859,170 @@ export function applyEdits(content: string, edits: AnalysisEdit[]): EditResult {
 	return { result, applied, skipped };
 }
 
+// --- Batch helpers ---
+
+/** Split sessions into batches that each fit within maxBytes */
+export function buildTranscriptBatches(sessions: SessionData[], maxBytes: number): string[][] {
+	const batches: string[][] = [];
+	let currentBatch: string[] = [];
+	let currentSize = 0;
+
+	for (const sd of sessions) {
+		const entry = sd.transcript + "\n---\n\n";
+		if (currentSize + entry.length > maxBytes && currentBatch.length > 0) {
+			batches.push(currentBatch);
+			currentBatch = [];
+			currentSize = 0;
+		}
+		currentBatch.push(entry);
+		currentSize += entry.length;
+	}
+	if (currentBatch.length > 0) {
+		batches.push(currentBatch);
+	}
+	return batches;
+}
+
+function formatBatchTranscripts(parts: string[], batchIndex: number, totalBatches: number, totalSessions: number): string {
+	const header =
+		`# Session Transcripts (batch ${batchIndex + 1}/${totalBatches})\n` +
+		`# ${parts.length} sessions in this batch, ${totalSessions} total\n\n`;
+	return header + parts.join("");
+}
+
+interface AnalysisResult {
+	edits: AnalysisEdit[];
+	correctionsFound: number;
+	sessionsWithCorrections: number;
+	summary: string;
+	patternsNotAdded?: any[];
+}
+
+/** Run a single LLM analysis call on one batch of transcripts */
+export function buildReflectAnalysisTool() {
+	return {
+		name: "submit_analysis",
+		description: "Submit the reflection analysis results",
+		parameters: {
+			type: "object" as const,
+			properties: {
+				corrections_found: { type: "number", description: "Number of facts/rules added, updated, or removed" },
+				sessions_with_corrections: { type: "number", description: "Number of conversations containing new facts or corrections" },
+				edits: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							type: { type: "string", enum: ["strengthen", "add", "remove", "merge"], description: "strengthen = update existing text, add = insert new text, remove = delete redundant text, merge = consolidate multiple rules into one" },
+							section: { type: "string", description: "Which section of the file" },
+							old_text: { type: "string", description: "Exact text to find for strengthen or remove; omit otherwise" },
+							new_text: { type: "string", description: "Replacement/new text, or empty string for remove" },
+							after_text: { type: "string", description: "Exact insertion point for add; omit otherwise" },
+							merge_sources: { type: "array", items: { type: "string" }, description: "Exact source texts for merge; omit otherwise" },
+							reason: { type: "string", description: "Brief reason for this edit" },
+						},
+						required: ["type", "new_text"],
+					},
+				},
+				patterns_not_added: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							pattern: { type: "string" },
+							reason: { type: "string" },
+						},
+					},
+				},
+				summary: { type: "string", description: "2-3 sentence summary of what was added/updated" },
+			},
+			required: ["corrections_found", "sessions_with_corrections", "edits", "summary"],
+		},
+	};
+}
+
+async function analyzeTranscriptBatch(
+	target: ReflectTarget,
+	targetPath: string,
+	targetContent: string,
+	transcripts: string,
+	context: string,
+	model: any,
+	apiKey: string,
+	headers: Record<string, string> | undefined,
+	modelLabel: string,
+	notify: NotifyFn,
+	completeFn: (model: any, request: any, options: any) => Promise<any>,
+): Promise<AnalysisResult | null> {
+	const prompt = buildPromptForTarget(target, targetPath, targetContent, transcripts, context);
+
+	const reflectAnalysisTool = buildReflectAnalysisTool();
+
+	const response = await completeFn(model, {
+		systemPrompt: "You are a behavioral analysis tool that prioritizes CONCISENESS. Your goal is to keep the target file short and scannable — prefer merging, removing, and tightening rules over adding new ones. The file should get shorter or stay the same size, not grow. Analyze the session transcripts and call the submit_analysis tool with your results. Always call the tool — never respond with plain text.",
+		messages: [
+			{
+				role: "user" as const,
+				content: [{ type: "text" as const, text: prompt }],
+				timestamp: Date.now(),
+			},
+		],
+		tools: [reflectAnalysisTool],
+	}, { apiKey, headers, maxTokens: 16384 });
+
+	if (response.stopReason === "error") {
+		notify(`LLM error: ${response.errorMessage ?? 'unknown'}`, "error");
+		return null;
+	}
+
+	let analysis: any;
+	const toolCall = response.content.find((c: any) => c.type === "toolCall" && c.name === "submit_analysis");
+	if (toolCall && (toolCall as any).arguments) {
+		analysis = (toolCall as any).arguments;
+	} else {
+		const responseText = response.content
+			.filter((c: any) => c.type === "text")
+			.map((c: any) => c.text)
+			.join("")
+			.trim();
+		try {
+			const jsonStr = responseText.replace(/^```json?\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+			analysis = JSON.parse(jsonStr);
+		} catch {
+			notify(`Failed to parse LLM response as JSON. Raw response:\n${responseText.slice(0, 500)}`, "error");
+			return null;
+		}
+	}
+
+	return {
+		edits: analysis.edits ?? [],
+		correctionsFound: analysis.corrections_found ?? 0,
+		sessionsWithCorrections: analysis.sessions_with_corrections ?? 0,
+		summary: analysis.summary ?? "",
+		patternsNotAdded: analysis.patterns_not_added,
+	};
+}
+
 // --- Main reflection logic ---
 
+export async function resolveModelAuth(
+	modelRegistry: any,
+	model: any,
+): Promise<{ ok: true; apiKey?: string; headers?: Record<string, string> } | { ok: false; error?: string }> {
+	if (!modelRegistry) return { ok: false, error: "model registry unavailable" };
+	if (typeof modelRegistry.getApiKeyAndHeaders === "function") {
+		const auth = await modelRegistry.getApiKeyAndHeaders(model);
+		return auth?.ok
+			? { ok: true, apiKey: auth.apiKey, headers: auth.headers }
+			: { ok: false, error: auth?.error };
+	}
+	if (typeof modelRegistry.getApiKey === "function") {
+		const apiKey = await modelRegistry.getApiKey(model);
+		return apiKey ? { ok: true, apiKey } : { ok: false, error: "No API key" };
+	}
+	return { ok: false, error: "unsupported model registry" };
+}
+
 export interface RunReflectionDeps {
 	completeSimple: (model: any, request: any, options: any) => Promise<any>;
 	getModel: (provider: string, modelId: string) => any;
@@ -759,9 +1054,11 @@ export async function runReflection(
 	let transcripts: string;
 	let sessionCount = 0;
 	let includedCount = 0;
+	let allSessions: SessionData[] | undefined;
 
 	if (options?.transcriptsOverride) {
 		({ transcripts, sessionCount, includedCount } = options.transcriptsOverride);
+		allSessions = options.transcriptsOverride.sessions;
 	} else if (target.transcripts && target.transcripts.length > 0) {
 		// New array-based transcript sources
 		notify(`Extracting transcripts from ${target.transcripts.length} source(s) (last ${target.lookbackDays} day(s))...`, "info");
@@ -779,6 +1076,7 @@ export async function runReflection(
 			target.maxSessionBytes,
 		);
 		({ transcripts, sessionCount, includedCount } = result);
+		allSessions = result.sessions;
 	} else {
 		notify(`Extracting transcripts (last ${target.lookbackDays} day(s))...`, "info");
 		const fn = deps?.collectTranscriptsFn ?? collectTranscripts;
@@ -787,6 +1085,7 @@ export async function runReflection(
 			target.maxSessionBytes,
 		);
 		({ transcripts, sessionCount, includedCount } = result);
+		allSessions = result.sessions;
 	}
 
 	if (!transcripts || includedCount === 0) {
@@ -794,25 +1093,58 @@ export async function runReflection(
 		return null;
 	}
 
-	notify(`Extracted ${includedCount} sessions (${sessionCount} scanned, ${(transcripts.length / 1024).toFixed(0)}KB)`, "info");
-
-	// Resolve model
-	const getModelFn = deps?.getModel ?? (await import("@mariozechner/pi-ai")).getModel;
-	const [provider, modelId] = target.model.split("/", 2);
-	let model = getModelFn(provider as any, modelId as any);
+	// Use total session count from allSessions if available (includes sessions that didn't fit the budget)
+	const totalSessionCount = allSessions ? allSessions.length : includedCount;
+	const totalBytes = allSessions ? allSessions.reduce((sum, s) => sum + s.size, 0) : transcripts.length;
+	notify(`Extracted ${totalSessionCount} sessions (${sessionCount} scanned, ${(totalBytes / 1024).toFixed(0)}KB)`, "info");
 
-	if (!model) {
-		model = modelRegistry?.find(provider, modelId);
-	}
-	if (!model) {
-		notify(`Model not found: ${target.model}`, "error");
-		return null;
+	// Dedup: skip if we already reflected on this target+sourceDate
+	if (!options?.sourceDateOverride) {
+		const sourceDate = new Date();
+		sourceDate.setDate(sourceDate.getDate() - target.lookbackDays);
+		const sourceDateStr = sourceDate.toISOString().slice(0, 10);
+		const history = loadHistory();
+		const alreadyRan = history.some(
+			(r) => r.targetPath === targetPath && r.sourceDate === sourceDateStr,
+		);
+		if (alreadyRan) {
+			notify(`Already reflected on ${sourceDateStr} for this target — skipping`, "info");
+			return null;
+		}
 	}
 
-	const apiKey = await modelRegistry?.getApiKey(model);
-	if (!apiKey) {
-		notify(`No API key for model: ${target.model}`, "error");
-		return null;
+	// Resolve model — prefer current session model over target.model config
+	let model: any;
+	let apiKey: string | undefined;
+	let headers: Record<string, string> | undefined;
+	let modelLabel: string;
+
+	if (options?.currentModel && options?.currentModelApiKey) {
+		model = options.currentModel;
+		apiKey = options.currentModelApiKey;
+		headers = options.currentModelHeaders;
+		modelLabel = `${model.provider}/${model.id}`;
+	} else {
+		const getModelFn = deps?.getModel ?? (await import("@mariozechner/pi-ai")).getModel;
+		const [provider, modelId] = target.model.split("/", 2);
+		model = getModelFn(provider as any, modelId as any);
+
+		if (!model) {
+			model = modelRegistry?.find(provider, modelId);
+		}
+		if (!model) {
+			notify(`Model not found: ${target.model}`, "error");
+			return null;
+		}
+
+		const auth = await resolveModelAuth(modelRegistry, model);
+		if (!auth.ok) {
+			notify(`No API key for model: ${target.model}${auth?.error ? ` (${auth.error})` : ''}`, "error");
+			return null;
+		}
+		apiKey = auth.apiKey;
+		headers = auth.headers;
+		modelLabel = target.model;
 	}
 
 	// Collect additional context
@@ -825,41 +1157,71 @@ export async function runReflection(
 		}
 	}
 
-	// Build prompt and call LLM
-	notify(`Analyzing with ${target.model}...`, "info");
-	const prompt = buildPromptForTarget(target, targetPath, targetContent, transcripts, context);
-
+	// Build batches and call LLM
 	const completeFn = deps?.completeSimple ?? (await import("@mariozechner/pi-ai")).completeSimple;
-	const response = await completeFn(model, {
-		systemPrompt: "You are a behavioral analysis tool. You analyze agent session transcripts and output ONLY valid JSON. Never output markdown, explanations, or any text outside the JSON object.",
-		messages: [
-			{
-				role: "user" as const,
-				content: [{ type: "text" as const, text: prompt }],
-				timestamp: Date.now(),
-			},
-		],
-	}, { apiKey, maxTokens: 16384 });
-
-	const responseText = response.content
-		.filter((c: any) => c.type === "text")
-		.map((c: any) => c.text)
-		.join("")
-		.trim();
 
-	// Parse JSON response
-	let analysis: any;
-	try {
-		const jsonStr = responseText.replace(/^```json?\s*\n?/m, "").replace(/\n?```\s*$/m, "");
-		analysis = JSON.parse(jsonStr);
-	} catch {
-		notify(`Failed to parse LLM response as JSON. Raw response:\n${responseText.slice(0, 500)}`, "error");
-		return null;
+	// Determine if we need multiple batches
+	// Reserve space for target file, system prompt, tool schema, and context
+	const overhead = targetContent.length + (context?.length ?? 0) + 20_000; // 20KB for prompt/tool schema
+	const batchBudget = Math.max(target.maxSessionBytes - overhead, 100_000); // at least 100KB per batch
+	const needsBatching = allSessions && allSessions.length > 0 && totalBytes > batchBudget;
+	let allEdits: AnalysisEdit[] = [];
+	let totalCorrectionsFound = 0;
+	let allSummaries: string[] = [];
+
+	if (needsBatching) {
+		const batches = buildTranscriptBatches(allSessions!, batchBudget);
+		notify(`Sessions exceed context budget — splitting into ${batches.length} batches`, "info");
+
+		for (let i = 0; i < batches.length; i++) {
+			const batchTranscripts = formatBatchTranscripts(batches[i], i, batches.length, totalSessionCount);
+			// Re-read target content for each batch so later batches see earlier edits
+			const currentContent = i === 0 ? targetContent : fs.readFileSync(targetPath, "utf-8");
+			notify(`Analyzing batch ${i + 1}/${batches.length} (${batches[i].length} sessions, ${(batchTranscripts.length / 1024).toFixed(0)}KB) with ${modelLabel}...`, "info");
+
+			const result = await analyzeTranscriptBatch(
+				target, targetPath, currentContent, batchTranscripts, context,
+				model, apiKey!, headers, modelLabel, notify, completeFn,
+			);
+
+			if (!result) continue;
+
+			allEdits.push(...result.edits);
+			totalCorrectionsFound += result.correctionsFound;
+			if (result.summary) allSummaries.push(result.summary);
+
+			// Apply this batch's edits immediately so the next batch sees the updated file
+			if (result.edits.length > 0) {
+				const currentForApply = fs.readFileSync(targetPath, "utf-8");
+				const { result: updated, applied } = applyEdits(currentForApply, result.edits);
+				if (applied > 0) {
+					// Backup before first edit
+					if (i === 0) {
+						const bkDir = resolvePath(target.backupDir);
+						fs.mkdirSync(bkDir, { recursive: true });
+						const bkPath = path.join(bkDir, `${path.basename(targetPath, ".md")}_${formatTimestamp()}.md`);
+						fs.copyFileSync(targetPath, bkPath);
+					}
+					fs.writeFileSync(targetPath, updated, "utf-8");
+					notify(`Batch ${i + 1}: applied ${applied} edit(s)`, "info");
+				}
+			}
+		}
+	} else {
+		notify(`Analyzing with ${modelLabel}...`, "info");
+		const result = await analyzeTranscriptBatch(
+			target, targetPath, targetContent, transcripts, context,
+			model, apiKey!, headers, modelLabel, notify, completeFn,
+		);
+		if (!result) return null;
+		allEdits = result.edits;
+		totalCorrectionsFound = result.correctionsFound;
+		if (result.summary) allSummaries.push(result.summary);
 	}
 
-	const edits: AnalysisEdit[] = analysis.edits ?? [];
-	const correctionsFound = analysis.corrections_found ?? 0;
-	const correctionRate = includedCount > 0 ? correctionsFound / includedCount : 0;
+	const edits = allEdits;
+	const correctionsFound = totalCorrectionsFound;
+	const correctionRate = totalSessionCount > 0 ? correctionsFound / totalSessionCount : 0;
 
 	// sourceDate = the date of sessions being analyzed, not when reflect ran
 	let sourceDateStr: string;
@@ -871,19 +1233,22 @@ export async function runReflection(
 		sourceDateStr = sourceDate.toISOString().slice(0, 10);
 	}
 
+	const combinedSummary = allSummaries.join(" ") || `${edits.length} edits from ${totalSessionCount} sessions.`;
+
 	if (edits.length === 0) {
-		notify(`No edits needed. ${analysis.summary ?? ""}`, "info");
+		notify(`No edits needed. ${combinedSummary}`, "info");
 		return {
 			timestamp: new Date().toISOString(),
 			targetPath,
-			sessionsAnalyzed: includedCount,
+			sessionsAnalyzed: totalSessionCount,
 			correctionsFound,
 			editsApplied: 0,
-			summary: analysis.summary ?? "No edits needed.",
+			summary: combinedSummary,
 			diffLines: 0,
 			correctionRate,
 			edits: [],
 			sourceDate: sourceDateStr,
+			fileSize: computeFileMetrics(fs.readFileSync(targetPath, "utf-8")),
 		};
 	}
 
@@ -897,98 +1262,107 @@ export async function runReflection(
 				reason: e.reason,
 			}));
 
-		const summary = analysis.summary ?? `${edits.length} edits proposed (dry run).`;
-		notify(`[dry run] ${summary}`, "info");
+		notify(`[dry run] ${combinedSummary}`, "info");
 
 		return {
 			timestamp: new Date().toISOString(),
 			targetPath,
-			sessionsAnalyzed: includedCount,
+			sessionsAnalyzed: totalSessionCount,
 			correctionsFound,
 			editsApplied: 0,
-			summary,
+			summary: combinedSummary,
 			diffLines: 0,
 			correctionRate,
 			edits: editRecords,
 			sourceDate: sourceDateStr,
+			fileSize: computeFileMetrics(fs.readFileSync(targetPath, "utf-8")),
 		};
 	}
 
-	// Backup before editing
+	// Apply edits
 	const backupDir = resolvePath(target.backupDir);
-	fs.mkdirSync(backupDir, { recursive: true });
-	const backupPath = path.join(backupDir, `${path.basename(targetPath, ".md")}_${formatTimestamp()}.md`);
-	fs.copyFileSync(targetPath, backupPath);
+	let totalApplied = 0;
+
+	if (needsBatching) {
+		// Batched: edits were already applied inline in the loop above.
+		// Count total applied from the diff.
+		const finalContent = fs.readFileSync(targetPath, "utf-8");
+		const origLines = targetContent.split("\n");
+		const finalLines = finalContent.split("\n");
+		for (let i = 0; i < Math.max(origLines.length, finalLines.length); i++) {
+			if (origLines[i] !== finalLines[i]) totalApplied++;
+		}
+		// Use edit count as applied since we tracked them per-batch
+		totalApplied = edits.length; // best estimate — individual batch applied counts were logged
+	} else {
+		// Single batch — backup and apply
+		fs.mkdirSync(backupDir, { recursive: true });
+		const backupPath = path.join(backupDir, `${path.basename(targetPath, ".md")}_${formatTimestamp()}.md`);
+		fs.copyFileSync(targetPath, backupPath);
 
-	// Apply edits with safety checks
-	const { result, applied, skipped } = applyEdits(targetContent, edits);
+		const { result, applied, skipped } = applyEdits(targetContent, edits);
 
-	if (applied === 0) {
-		notify(`All ${edits.length} edits failed to apply. Skipped: ${skipped.join("; ")}`, "warning");
-		try { fs.unlinkSync(backupPath); } catch {}
-		return null;
-	}
+		if (applied === 0) {
+			notify(`All ${edits.length} edits failed to apply. Skipped: ${skipped.join("; ")}`, "warning");
+			try { fs.unlinkSync(backupPath); } catch {}
+			return null;
+		}
 
-	// Size sanity check — reject if result lost more than half the content
-	if (result.length < targetContent.length * 0.5) {
-		notify(`Result is suspiciously small (${result.length} vs ${targetContent.length} bytes). Aborting.`, "error");
-		return null;
-	}
+		if (result.length < targetContent.length * 0.5) {
+			notify(`Result is suspiciously small (${result.length} vs ${targetContent.length} bytes). Aborting.`, "error");
+			return null;
+		}
 
-	fs.writeFileSync(targetPath, result, "utf-8");
+		fs.writeFileSync(targetPath, result, "utf-8");
+		totalApplied = applied;
 
-	// Count changed lines
+		if (skipped.length > 0) {
+			notify(`Applied ${applied}/${edits.length} edits (${skipped.length} skipped). Backup: ${backupPath}`, "warning");
+		} else {
+			notify(`Applied ${applied} edit(s). Backup: ${backupPath}`, "info");
+		}
+	}
+
+	// Compute final diff
+	const finalContent = fs.readFileSync(targetPath, "utf-8");
 	const originalLines = targetContent.split("\n");
-	const resultLines = result.split("\n");
+	const resultLines = finalContent.split("\n");
 	let diffLines = 0;
 	const maxLen = Math.max(originalLines.length, resultLines.length);
 	for (let i = 0; i < maxLen; i++) {
 		if (originalLines[i] !== resultLines[i]) diffLines++;
 	}
 
-	if (skipped.length > 0) {
-		notify(`Applied ${applied}/${edits.length} edits (${skipped.length} skipped). Backup: ${backupPath}`, "warning");
-	} else {
-		notify(`Applied ${applied} edit(s). Backup: ${backupPath}`, "info");
-	}
-
-	const summary = analysis.summary ?? `${applied} edits applied from ${includedCount} sessions.`;
-	notify(summary, "info");
+	notify(combinedSummary, "info");
 
-	// If target is in a git repo, commit the change
+	// Git commit
 	try {
 		const realPath = fs.realpathSync(targetPath);
 		const repoDir = path.dirname(realPath);
 		if (fs.existsSync(path.join(repoDir, ".git"))) {
 			const { execFileSync } = require("node:child_process");
 			execFileSync("git", ["add", "-A"], { cwd: repoDir, stdio: "ignore", timeout: 5000 });
-			execFileSync("git", ["commit", "-m", `reflect: ${path.basename(realPath)} — ${applied} edits from ${includedCount} sessions`, "--no-verify"], { cwd: repoDir, stdio: "ignore", timeout: 5000 });
+			execFileSync("git", ["commit", "-m", `reflect: ${path.basename(realPath)} — ${totalApplied} edits from ${totalSessionCount} sessions`, "--no-verify"], { cwd: repoDir, stdio: "ignore", timeout: 5000 });
 			notify(`Committed to ${path.basename(repoDir)}`, "info");
 		}
-	} catch {
-		// Not in a git repo or commit failed — that's fine
-	}
+	} catch {}
 
-	// Extract per-edit detail for recidivism tracking
 	const editRecords: EditRecord[] = edits
 		.filter((e: any) => e.section && e.reason)
-		.map((e: any) => ({
-			type: e.type ?? "add",
-			section: e.section,
-			reason: e.reason,
-		}));
+		.map((e: any) => ({ type: e.type ?? "add", section: e.section, reason: e.reason }));
 
 	return {
 		timestamp: new Date().toISOString(),
 		targetPath,
-		sessionsAnalyzed: includedCount,
+		sessionsAnalyzed: totalSessionCount,
 		correctionsFound,
-		editsApplied: applied,
-		summary,
+		editsApplied: totalApplied,
+		summary: combinedSummary,
 		diffLines,
 		correctionRate,
 		edits: editRecords,
 		sourceDate: sourceDateStr,
+		fileSize: computeFileMetrics(fs.readFileSync(targetPath, "utf-8")),
 	};
 }