@askjo/pi-reflect 1.1.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 {
@@ -112,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;
 }
 
@@ -127,6 +131,7 @@ export interface ReflectionOptions {
 	/** 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;
@@ -146,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 {
@@ -489,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);
@@ -507,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 }];
 					}
@@ -588,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}
@@ -604,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"
 }`;
 }
 
@@ -724,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)}`);
 		}
@@ -772,21 +899,8 @@ interface AnalysisResult {
 }
 
 /** Run a single LLM analysis call on one batch of transcripts */
-async function analyzeTranscriptBatch(
-	target: ReflectTarget,
-	targetPath: string,
-	targetContent: string,
-	transcripts: string,
-	context: string,
-	model: any,
-	apiKey: string,
-	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 = {
+export function buildReflectAnalysisTool() {
+	return {
 		name: "submit_analysis",
 		description: "Submit the reflection analysis results",
 		parameters: {
@@ -799,12 +913,13 @@ async function analyzeTranscriptBatch(
 					items: {
 						type: "object",
 						properties: {
-							type: { type: "string", enum: ["strengthen", "add"], description: "strengthen = update existing text, add = insert new text" },
+							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", "null"], description: "Exact text to find (for strengthen) or null (for add)" },
-							new_text: { type: "string", description: "Replacement text (for strengthen) or new text to insert (for add)" },
-							after_text: { type: ["string", "null"], description: "Text after which to insert (for add) or null (for strengthen)" },
-							reason: { type: "string", description: "What fact/rule this captures and where in the conversations it appeared" },
+							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"],
 					},
@@ -824,9 +939,27 @@ async function analyzeTranscriptBatch(
 			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. Analyze the session transcripts and call the submit_analysis tool with your results. Always call the tool — never respond with plain text.",
+		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,
@@ -835,7 +968,7 @@ async function analyzeTranscriptBatch(
 			},
 		],
 		tools: [reflectAnalysisTool],
-	}, { apiKey, maxTokens: 16384 });
+	}, { apiKey, headers, maxTokens: 16384 });
 
 	if (response.stopReason === "error") {
 		notify(`LLM error: ${response.errorMessage ?? 'unknown'}`, "error");
@@ -872,6 +1005,24 @@ async function analyzeTranscriptBatch(
 
 // --- 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;
@@ -947,14 +1098,31 @@ export async function runReflection(
 	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");
 
+	// 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;
+		}
+	}
+
 	// 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;
@@ -969,11 +1137,13 @@ export async function runReflection(
 			return null;
 		}
 
-		apiKey = await modelRegistry?.getApiKey(model);
-		if (!apiKey) {
-			notify(`No API key for model: ${target.model}`, "error");
+		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;
 	}
 
@@ -1011,7 +1181,7 @@ export async function runReflection(
 
 			const result = await analyzeTranscriptBatch(
 				target, targetPath, currentContent, batchTranscripts, context,
-				model, apiKey!, modelLabel, notify, completeFn,
+				model, apiKey!, headers, modelLabel, notify, completeFn,
 			);
 
 			if (!result) continue;
@@ -1041,7 +1211,7 @@ export async function runReflection(
 		notify(`Analyzing with ${modelLabel}...`, "info");
 		const result = await analyzeTranscriptBatch(
 			target, targetPath, targetContent, transcripts, context,
-			model, apiKey!, modelLabel, notify, completeFn,
+			model, apiKey!, headers, modelLabel, notify, completeFn,
 		);
 		if (!result) return null;
 		allEdits = result.edits;
@@ -1078,6 +1248,7 @@ export async function runReflection(
 			correctionRate,
 			edits: [],
 			sourceDate: sourceDateStr,
+			fileSize: computeFileMetrics(fs.readFileSync(targetPath, "utf-8")),
 		};
 	}
 
@@ -1104,6 +1275,7 @@ export async function runReflection(
 			correctionRate,
 			edits: editRecords,
 			sourceDate: sourceDateStr,
+			fileSize: computeFileMetrics(fs.readFileSync(targetPath, "utf-8")),
 		};
 	}
 
@@ -1190,6 +1362,7 @@ export async function runReflection(
 		correctionRate,
 		edits: editRecords,
 		sourceDate: sourceDateStr,
+		fileSize: computeFileMetrics(fs.readFileSync(targetPath, "utf-8")),
 	};
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askjo/pi-reflect",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Self-improving behavioral files for pi coding agents. Analyzes session transcripts for correction patterns and makes surgical edits to prevent recurrence.",
   "keywords": [
     "pi-package",

package/release.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BUMP="${1:-patch}"
+if [[ "$BUMP" != "patch" && "$BUMP" != "minor" && "$BUMP" != "major" ]]; then
+  echo "Usage: ./release.sh [patch|minor|major]"
+  exit 1
+fi
+
+cd "$(dirname "$0")"
+
+echo "🔍 Pre-flight checks..."
+if [[ -n "$(git status --porcelain)" ]]; then
+  echo "❌ Working tree is dirty. Commit changes first."
+  exit 1
+fi
+if [[ "$(git branch --show-current)" != "main" ]]; then
+  echo "❌ Not on main."
+  exit 1
+fi
+git fetch origin main --quiet
+if [[ "$(git rev-parse HEAD)" != "$(git rev-parse origin/main)" ]]; then
+  echo "❌ Local main differs from origin/main."
+  exit 1
+fi
+
+echo "🧪 Running tests..."
+npm test
+
+echo "📦 Bumping version: $BUMP"
+npm version "$BUMP" --message "v%s"
+NEW_VERSION=$(node -p "require('./package.json').version")
+
+echo "📤 Pushing main and v${NEW_VERSION} tag..."
+git push origin main --follow-tags
+
+echo "✅ Release v${NEW_VERSION} triggered"
+echo "   Actions: https://github.com/jo-inc/pi-reflect/actions"
+echo "   Package: https://www.npmjs.com/package/@askjo/pi-reflect"

package/tests/apply-edits.test.ts

@@ -345,4 +345,55 @@ describe("applyEdits", () => {
 		assert.ok(result.includes("Line one, improved."));
 		assert.ok(result.includes("Continuation line, also improved."));
 	});
+
+	it("removes a rule with type=remove", () => {
+		const content = "- Rule A\n- Rule B (redundant)\n- Rule C\n";
+		const { result, applied } = applyEdits(content, [
+			{ type: "remove", old_text: "- Rule B (redundant)", new_text: "" },
+		]);
+		assert.equal(applied, 1);
+		assert.ok(!result.includes("Rule B"));
+		assert.ok(result.includes("Rule A"));
+		assert.ok(result.includes("Rule C"));
+	});
+
+	it("skips remove when text not found", () => {
+		const content = "- Rule A\n- Rule B\n";
+		const { applied, skipped } = applyEdits(content, [
+			{ type: "remove", old_text: "- Rule X", new_text: "" },
+		]);
+		assert.equal(applied, 0);
+		assert.equal(skipped.length, 1);
+	});
+
+	it("merges multiple rules into one", () => {
+		const content = "- Always check schema before SQL.\n- Verify column names before queries.\n- Other rule.\n";
+		const { result, applied } = applyEdits(content, [
+			{
+				type: "merge",
+				merge_sources: [
+					"- Always check schema before SQL.",
+					"- Verify column names before queries.",
+				],
+				new_text: "- Always check DB schema before writing any SQL query.",
+			},
+		]);
+		assert.equal(applied, 1);
+		assert.ok(result.includes("- Always check DB schema before writing any SQL query."));
+		assert.ok(!result.includes("Verify column names"));
+		assert.ok(result.includes("Other rule"));
+	});
+
+	it("skips merge when a source is not found", () => {
+		const content = "- Rule A\n- Rule B\n";
+		const { applied, skipped } = applyEdits(content, [
+			{
+				type: "merge",
+				merge_sources: ["- Rule A", "- Rule X"],
+				new_text: "- Merged rule.",
+			},
+		]);
+		assert.equal(applied, 0);
+		assert.equal(skipped.length, 1);
+	});
 });

package/tests/batching.test.ts

@@ -119,7 +119,7 @@ function makeTarget(overrides: Partial<ReflectTarget> = {}): ReflectTarget {
 function makeModelRegistry() {
 	return {
 		find: () => ({ provider: "test", id: "test-model" }),
-		getApiKey: async () => "test-key",
+		getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "test-key", headers: undefined }),
 	};
 }
 

package/tests/context-files.test.ts

@@ -0,0 +1,59 @@
+import { afterEach, beforeEach, describe, it } from "node:test";
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { collectContext } from "../extensions/reflect.js";
+import { cleanup, makeTempDir } from "./helpers.js";
+
+describe("collectContext file sources", () => {
+	let tmpDir: string;
+
+	beforeEach(() => {
+		tmpDir = makeTempDir();
+	});
+
+	afterEach(() => {
+		cleanup(tmpDir);
+	});
+
+	it("finds matching files in nested subdirectories for a filetype glob", async () => {
+		fs.mkdirSync(path.join(tmpDir, "nested", "deeper"), { recursive: true });
+		fs.writeFileSync(path.join(tmpDir, "top.md"), "top-level note", "utf-8");
+		fs.writeFileSync(path.join(tmpDir, "nested", "deeper", "child.md"), "nested note", "utf-8");
+		fs.writeFileSync(path.join(tmpDir, "nested", "deeper", "ignore.txt"), "ignore me", "utf-8");
+
+		const context = await collectContext([
+			{ type: "files", label: "notes", paths: [path.join(tmpDir, "*.md")] },
+		], 1);
+
+		assert.match(context, /### top\.md\ntop-level note/);
+		assert.match(context, /### nested\/deeper\/child\.md\nnested note/);
+		assert.doesNotMatch(context, /ignore me/);
+	});
+
+	it("supports explicit recursive glob patterns", async () => {
+		fs.mkdirSync(path.join(tmpDir, "a", "b"), { recursive: true });
+		fs.writeFileSync(path.join(tmpDir, "root.md"), "root file", "utf-8");
+		fs.writeFileSync(path.join(tmpDir, "a", "b", "deep.md"), "deep file", "utf-8");
+
+		const context = await collectContext([
+			{ type: "files", label: "notes", paths: [path.join(tmpDir, "**", "*.md")] },
+		], 1);
+
+		assert.match(context, /### root\.md\nroot file/);
+		assert.match(context, /### a\/b\/deep\.md\ndeep file/);
+	});
+
+	it("prunes nested dated files outside the lookback window", async () => {
+		fs.mkdirSync(path.join(tmpDir, "archive"), { recursive: true });
+		fs.writeFileSync(path.join(tmpDir, "archive", "2000-01-01-old.md"), "old note", "utf-8");
+		fs.writeFileSync(path.join(tmpDir, "archive", "2099-01-01-new.md"), "new note", "utf-8");
+
+		const context = await collectContext([
+			{ type: "files", label: "dated", paths: [path.join(tmpDir, "*.md")] },
+		], 1);
+
+		assert.match(context, /2099-01-01-new\.md\nnew note/);
+		assert.doesNotMatch(context, /2000-01-01-old\.md\nold note/);
+	});
+});