@prometheus-ai/agent 0.5.3 → 0.5.8

package/src/discovery/helpers.ts

@@ -163,7 +163,7 @@ export function buildRuleFromMarkdown(
 	},
 ): Rule {
 	const { frontmatter, body } = parseFrontmatter(content, { source: filePath });
-	const { condition, scope } = parseRuleConditionAndScope(frontmatter as RuleFrontmatter);
+	const { condition, astCondition, scope } = parseRuleConditionAndScope(frontmatter as RuleFrontmatter);
 
 	let globs: string[] | undefined;
 	if (Array.isArray(frontmatter.globs)) {
@@ -186,6 +186,7 @@ export function buildRuleFromMarkdown(
 		alwaysApply: frontmatter.alwaysApply === true,
 		description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
 		condition,
+		astCondition,
 		scope,
 		interruptMode,
 		_source: source,
@@ -490,6 +491,42 @@ interface ExtensionModuleManifest {
 	extensions?: string[];
 }
 
+async function discoverLinkedExtensionModuleFiles(dir: string): Promise<{
+	indexFiles: Array<{ path: string }>;
+	packageJsonFiles: Array<{ path: string }>;
+}> {
+	const entries = await readDirEntries(dir);
+	const indexFiles: Array<{ path: string }> = [];
+	const packageJsonFiles: Array<{ path: string }> = [];
+
+	await Promise.all(
+		entries.map(async entry => {
+			if (entry.name.startsWith(".") || entry.isDirectory()) return;
+
+			const entryPath = path.join(dir, entry.name);
+			const stat = await fs.promises.stat(entryPath).catch(() => null);
+			if (!stat?.isDirectory()) return;
+
+			const [packageJsonContent, indexTsContent, indexJsContent] = await Promise.all([
+				readFile(path.join(entryPath, "package.json")),
+				readFile(path.join(entryPath, "index.ts")),
+				readFile(path.join(entryPath, "index.js")),
+			]);
+
+			if (packageJsonContent !== null) {
+				packageJsonFiles.push({ path: `${entry.name}/package.json` });
+			}
+			if (indexTsContent !== null) {
+				indexFiles.push({ path: `${entry.name}/index.ts` });
+			} else if (indexJsContent !== null) {
+				indexFiles.push({ path: `${entry.name}/index.js` });
+			}
+		}),
+	);
+
+	return { indexFiles, packageJsonFiles };
+}
+
 async function readExtensionModuleManifest(
 	_ctx: LoadContext,
 	packageJsonPath: string,
@@ -519,14 +556,18 @@ async function readExtensionModuleManifest(
 export async function discoverExtensionModulePaths(_ctx: LoadContext, dir: string): Promise<string[]> {
 	const discovered = new Set<string>();
 	// Find all candidate files in parallel using glob
-	const [directFiles, indexFiles, packageJsonFiles] = await Promise.all([
+	const [directFiles, globIndexFiles, globPackageJsonFiles, linkedFiles] = await Promise.all([
 		// 1. Direct *.ts or *.js files
 		globIf(dir, "*.{ts,js}", FileType.File, false),
 		// 2. Subdirectory index files
 		globIf(dir, "*/index.{ts,js}", FileType.File, false),
 		// 3. Subdirectory package.json files
 		globIf(dir, "*/package.json", FileType.File, false),
+		// Native glob does not follow linked extension directories.
+		discoverLinkedExtensionModuleFiles(dir),
 	]);
+	const indexFiles = [...globIndexFiles, ...linkedFiles.indexFiles];
+	const packageJsonFiles = [...globPackageJsonFiles, ...linkedFiles.packageJsonFiles];
 
 	// Process direct files
 	for (const match of directFiles) {
@@ -820,12 +861,12 @@ export async function listClaudePluginRoots(
 	// In production `home` is `os.homedir()`, so `getPluginsDir(home)` resolves to the
 	// same XDG-aware path the marketplace writer uses (reads and writes always agree).
 	// Tests pass a temp dir, which short-circuits the resolver for deterministic isolation.
-	const ompRegistryPath = path.join(getPluginsDir(home), "installed_plugins.json");
-	const ompContent = await readFile(ompRegistryPath);
-	if (ompContent) {
-		const ompRegistry = parseClaudePluginsRegistry(ompContent);
-		if (ompRegistry) {
-			for (const [pluginId, entries] of Object.entries(ompRegistry.plugins)) {
+	const prometheusRegistryPath = path.join(getPluginsDir(home), "installed_plugins.json");
+	const prometheusContent = await readFile(prometheusRegistryPath);
+	if (prometheusContent) {
+		const prometheusRegistry = parseClaudePluginsRegistry(prometheusContent);
+		if (prometheusRegistry) {
+			for (const [pluginId, entries] of Object.entries(prometheusRegistry.plugins)) {
 				if (!Array.isArray(entries) || entries.length === 0) continue;
 
 				const atIndex = pluginId.lastIndexOf("@");
@@ -861,7 +902,7 @@ export async function listClaudePluginRoots(
 				}
 			}
 		} else {
-			warnings.push(`Failed to parse Prometheus plugin registry: ${ompRegistryPath}`);
+			warnings.push(`Failed to parse Prometheus plugin registry: ${prometheusRegistryPath}`);
 		}
 	}
 

package/src/discovery/prometheus-extension-roots.ts

@@ -7,9 +7,9 @@
  * sub-directories (`skills/`, `hooks/`, `tools/`, `commands/`, `rules/`,
  * `prompts/`, `.mcp.json`) are wired into discovery by `prometheus-plugins.ts`.
  *
- * CLI-provided paths are injected via {@link injectOmpExtensionCliRoots}
+ * CLI-provided paths are injected via {@link injectPrometheusExtensionCliRoots}
  * before discovery runs; settings paths are read lazily from
- * `<scope>/settings.json` in {@link listOmpExtensionRoots} to mirror what
+ * `<scope>/settings.json` in {@link listPrometheusExtensionRoots} to mirror what
  * `loadExtensionModules` already does.
  *
  * @see ./prometheus-plugins.ts
@@ -24,7 +24,7 @@ import { getEnabledPlugins } from "../extensibility/plugins/loader";
 import { expandTilde } from "../tools/path-utils";
 
 /** A resolved extension package directory wired into the discovery surfaces. */
-export interface OmpExtensionRoot {
+export interface PrometheusExtensionRoot {
 	/** Absolute path to the package directory. */
 	path: string;
 	/** Stable display name (basename of the package directory). */
@@ -47,9 +47,9 @@ let injectedCliRoots: InjectedRoot[] = [];
  * entrypoints have no package sub-tree to scan.
  *
  * Call once during startup before any capability load. Repeated calls extend
- * the registered set; {@link clearOmpExtensionCliRoots} resets for tests.
+ * the registered set; {@link clearPrometheusExtensionCliRoots} resets for tests.
  */
-export function injectOmpExtensionCliRoots(paths: readonly string[], home: string, cwd: string): void {
+export function injectPrometheusExtensionCliRoots(paths: readonly string[], home: string, cwd: string): void {
 	if (paths.length === 0) return;
 	const expanded = paths.map(raw => {
 		const tilde = expandTilde(raw, home);
@@ -65,12 +65,12 @@ export function injectOmpExtensionCliRoots(paths: readonly string[], home: strin
 }
 
 /** Drop every CLI-injected root. Tests use this between cases. */
-export function clearOmpExtensionCliRoots(): void {
+export function clearPrometheusExtensionCliRoots(): void {
 	injectedCliRoots = [];
 }
 
 /** Inspect currently-injected CLI roots (read-only). Exposed for diagnostics + tests. */
-export function getInjectedOmpExtensionCliRoots(): readonly OmpExtensionRoot[] {
+export function getInjectedPrometheusExtensionCliRoots(): readonly PrometheusExtensionRoot[] {
 	return injectedCliRoots.map(({ path: p, level }) => ({ path: p, level, name: path.basename(p) }));
 }
 
@@ -120,7 +120,7 @@ async function isDirectory(p: string): Promise<boolean> {
  * Sources, in order of precedence (later entries with the same absolute path
  * are dropped):
  *
- * 1. CLI roots injected via {@link injectOmpExtensionCliRoots}
+ * 1. CLI roots injected via {@link injectPrometheusExtensionCliRoots}
  * 2. Project `<cwd>/.prometheus/settings.json#extensions`
  * 3. User `~/.prometheus/agent/settings.json#extensions`
  * 4. Enabled plugins installed under `<plugins>/node_modules/` (e.g. via
@@ -132,7 +132,7 @@ async function isDirectory(p: string): Promise<boolean> {
  * `package.json`, etc.) are logged at `debug` and degrade gracefully — the
  * other sources still surface.
  */
-export async function listOmpExtensionRoots(ctx: LoadContext): Promise<OmpExtensionRoot[]> {
+export async function listPrometheusExtensionRoots(ctx: LoadContext): Promise<PrometheusExtensionRoot[]> {
 	const { project, user } = scopeDirs(ctx);
 	const [projectExtensions, userExtensions, installedPlugins] = await Promise.all([
 		readSettingsExtensions(path.join(project, "settings.json")),
@@ -157,7 +157,7 @@ export async function listOmpExtensionRoots(ctx: LoadContext): Promise<OmpExtens
 	}
 
 	const directoryFlags = await Promise.all(unique.map(c => isDirectory(c.path)));
-	const roots: OmpExtensionRoot[] = [];
+	const roots: PrometheusExtensionRoot[] = [];
 	for (let i = 0; i < unique.length; i++) {
 		if (!directoryFlags[i]) continue;
 		const { path: p, level } = unique[i];

package/src/discovery/prometheus-plugins.ts

@@ -29,7 +29,7 @@ import { type SlashCommand, slashCommandCapability } from "../capability/slash-c
 import { type CustomTool, toolCapability } from "../capability/tool";
 import type { LoadContext, LoadResult } from "../capability/types";
 import { buildRuleFromMarkdown, createSourceMeta, loadFilesFromDir, scanSkillsFromDir } from "./helpers";
-import { listOmpExtensionRoots, type OmpExtensionRoot } from "./prometheus-extension-roots";
+import { listPrometheusExtensionRoots, type PrometheusExtensionRoot } from "./prometheus-extension-roots";
 
 const PROVIDER_ID = "prometheus-plugins";
 const DISPLAY_NAME = "Prometheus Extension Packages";
@@ -42,7 +42,7 @@ const PRIORITY = 90;
 // =============================================================================
 
 async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
-	const roots = await listOmpExtensionRoots(ctx);
+	const roots = await listPrometheusExtensionRoots(ctx);
 	const results = await Promise.all(
 		roots.map(root =>
 			scanSkillsFromDir(ctx, {
@@ -64,7 +64,7 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 // =============================================================================
 
 async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
-	const roots = await listOmpExtensionRoots(ctx);
+	const roots = await listPrometheusExtensionRoots(ctx);
 	const results = await Promise.all(
 		roots.map(root =>
 			loadFilesFromDir<SlashCommand>(ctx, path.join(root.path, "commands"), PROVIDER_ID, root.level, {
@@ -90,7 +90,7 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 // =============================================================================
 
 async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
-	const roots = await listOmpExtensionRoots(ctx);
+	const roots = await listPrometheusExtensionRoots(ctx);
 	const results = await Promise.all(
 		roots.map(root =>
 			loadFilesFromDir<Rule>(ctx, path.join(root.path, "rules"), PROVIDER_ID, root.level, {
@@ -111,7 +111,7 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 // =============================================================================
 
 async function loadPrompts(ctx: LoadContext): Promise<LoadResult<Prompt>> {
-	const roots = await listOmpExtensionRoots(ctx);
+	const roots = await listPrometheusExtensionRoots(ctx);
 	const results = await Promise.all(
 		roots.map(root =>
 			loadFilesFromDir<Prompt>(ctx, path.join(root.path, "prompts"), PROVIDER_ID, root.level, {
@@ -138,8 +138,8 @@ async function loadPrompts(ctx: LoadContext): Promise<LoadResult<Prompt>> {
 const HOOK_TYPES: ReadonlyArray<"pre" | "post"> = ["pre", "post"];
 
 async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
-	const roots = await listOmpExtensionRoots(ctx);
-	const tasks: Array<{ root: OmpExtensionRoot; hookType: "pre" | "post" }> = [];
+	const roots = await listPrometheusExtensionRoots(ctx);
+	const tasks: Array<{ root: PrometheusExtensionRoot; hookType: "pre" | "post" }> = [];
 	for (const root of roots) {
 		for (const hookType of HOOK_TYPES) {
 			tasks.push({ root, hookType });
@@ -176,7 +176,7 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 const TOOL_EXTENSIONS = ["json", "md", "ts", "js", "sh", "bash", "py"];
 
 async function loadTools(ctx: LoadContext): Promise<LoadResult<CustomTool>> {
-	const roots = await listOmpExtensionRoots(ctx);
+	const roots = await listPrometheusExtensionRoots(ctx);
 	const perRoot = await Promise.all(
 		roots.map(async root => {
 			const toolsDir = path.join(root.path, "tools");
@@ -268,11 +268,11 @@ interface RawMcpServer {
 }
 
 async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
-	const roots = await listOmpExtensionRoots(ctx);
+	const roots = await listPrometheusExtensionRoots(ctx);
 	const items: MCPServer[] = [];
 	const warnings: string[] = [];
 
-	const tasks: Array<{ root: OmpExtensionRoot; mcpPath: string }> = [];
+	const tasks: Array<{ root: PrometheusExtensionRoot; mcpPath: string }> = [];
 	for (const root of roots) {
 		for (const filename of MCP_FILENAMES) {
 			tasks.push({ root, mcpPath: path.join(root.path, filename) });

package/src/edit/diff.ts

@@ -6,6 +6,7 @@
  */
 import * as Diff from "diff";
 import { resolveToCwd } from "../tools/path-utils";
+import { type BlockContextSource, findBlockContextLines } from "../utils/block-context";
 import { DEFAULT_FUZZY_THRESHOLD, EditMatchError, findMatch } from "./modes/replace";
 import { adjustIndentation, normalizeToLF, stripBom } from "./normalize";
 import { readEditFileText } from "./read-file";
@@ -54,11 +55,186 @@ function formatNumberedDiffLine(prefix: "+" | "-" | " ", lineNum: number, conten
 	return `${prefix}${lineNum}|${content}`;
 }
 
+interface ParsedNumberedDiffRow {
+	prefix: "+" | "-" | " ";
+	lineNumber: number;
+	content: string;
+}
+
+function parseNumberedDiffRow(row: string): ParsedNumberedDiffRow | undefined {
+	const match = /^([+\- ])(\d+)\|(.*)$/s.exec(row);
+	if (!match) return undefined;
+	const prefix = match[1] as "+" | "-" | " ";
+	const lineNumber = Number.parseInt(match[2], 10);
+	if (!Number.isFinite(lineNumber)) return undefined;
+	return { prefix, lineNumber, content: match[3] ?? "" };
+}
+
+function isDiffChangeRow(row: string | undefined): boolean {
+	return row !== undefined && (row.startsWith("+") || row.startsWith("-"));
+}
+
+/** Blank row separating non-contiguous regions of a numbered diff. */
+const DIFF_GAP_ROW = "";
+
+/** Old-file line number of a source-visible row (`-` or context); `+`/gap/other rows yield undefined. */
+function parseSourceRowLineNumber(row: string): number | undefined {
+	const parsed = parseNumberedDiffRow(row);
+	return parsed === undefined || parsed.prefix === "+" ? undefined : parsed.lineNumber;
+}
+
+/**
+ * Drop gap rows that no longer separate anything. Context rows are inserted
+ * one at a time, each adding its own gap rows from a snapshot of the diff, so
+ * the raw result can contain adjacent gap rows, gap rows whose neighbors
+ * became contiguous after a later insert filled the hole, and gap rows at the
+ * diff edges. The sweep keeps a gap row only when it sits between two
+ * source-numbered rows (old-file coordinates — the same numbering the
+ * insertion gap test uses) that are actually non-contiguous, and never keeps
+ * two in a row.
+ */
+function normalizeDiffGapRows(rows: string[]): void {
+	const kept: string[] = [];
+	for (let i = 0; i < rows.length; i++) {
+		const row = rows[i];
+		if (row !== DIFF_GAP_ROW) {
+			kept.push(row);
+			continue;
+		}
+		if (kept.length === 0 || kept[kept.length - 1] === DIFF_GAP_ROW) continue;
+		let before: number | undefined;
+		for (let j = kept.length - 1; j >= 0 && before === undefined; j--) {
+			before = parseSourceRowLineNumber(kept[j]);
+		}
+		let after: number | undefined;
+		for (let j = i + 1; j < rows.length && after === undefined; j++) {
+			if (rows[j] === DIFF_GAP_ROW) continue;
+			after = parseSourceRowLineNumber(rows[j]);
+		}
+		if (before === undefined || after === undefined || after <= before + 1) continue;
+		kept.push(row);
+	}
+	if (kept.length !== rows.length) rows.splice(0, rows.length, ...kept);
+}
+
+function adjustedContextInsertIndex(rows: readonly string[], index: number): number {
+	let start = index;
+	while (start > 0 && isDiffChangeRow(rows[start - 1])) start--;
+	let end = index;
+	while (end < rows.length && isDiffChangeRow(rows[end])) end++;
+	return index > start && index < end ? end : index;
+}
+
+function insertBracketContextRows(
+	rows: string[],
+	contextLines: ReadonlyMap<number, string>,
+	seenRows: Set<string>,
+): void {
+	const context = [...contextLines].sort(([left], [right]) => left - right);
+	for (const [lineNumber, text] of context) {
+		const row = formatNumberedDiffLine(" ", lineNumber, text);
+		if (seenRows.has(row)) continue;
+
+		let insertIndex = rows.length;
+		let previousSourceLine: number | undefined;
+		let nextSourceLine: number | undefined;
+		for (let i = 0; i < rows.length; i++) {
+			const parsed = parseNumberedDiffRow(rows[i]);
+			if (!parsed || parsed.prefix === "+") continue;
+			if (parsed.lineNumber < lineNumber) {
+				previousSourceLine = parsed.lineNumber;
+				continue;
+			}
+			nextSourceLine = parsed.lineNumber;
+			insertIndex = i;
+			break;
+		}
+
+		const chunk: string[] = [];
+		if (previousSourceLine !== undefined && lineNumber > previousSourceLine + 1) chunk.push(DIFF_GAP_ROW);
+		chunk.push(row);
+		if (nextSourceLine !== undefined && nextSourceLine > lineNumber + 1) chunk.push(DIFF_GAP_ROW);
+
+		const adjustedIndex = adjustedContextInsertIndex(rows, insertIndex);
+		rows.splice(adjustedIndex, 0, ...chunk);
+		seenRows.add(row);
+	}
+}
+
+/**
+ * Insert off-window block-boundary rows (enclosing header, matching closing
+ * bracket, …) into a numbered diff. Context rows carry pre-edit line numbers —
+ * the renumbering contract of `buildCompactDiffPreview` — so boundary lines
+ * discovered in the new file are translated back to their pre-edit numbers
+ * and merged with the old-file pass before a single insertion sweep. Without
+ * the translation, a context line sitting in a net-offset region would be
+ * re-inserted under its post-edit number: duplicated, out of order, and
+ * renumbered incorrectly by the preview.
+ */
+function addMatchingBracketContextRows(
+	rows: string[],
+	oldLines: readonly string[],
+	newLines: readonly string[],
+	source: BlockContextSource,
+): void {
+	const oldVisible: number[] = [];
+	const newVisible: number[] = [];
+	const seenRows = new Set(rows);
+	// Change positions in new-file coordinates, used to translate an unchanged
+	// new-file line number back to its pre-edit equivalent.
+	const changes: { newPos: number; delta: 1 | -1 }[] = [];
+	let offset = 0;
+
+	for (const row of rows) {
+		const parsed = parseNumberedDiffRow(row);
+		if (!parsed) continue;
+		switch (parsed.prefix) {
+			case "-":
+				oldVisible.push(parsed.lineNumber);
+				changes.push({ newPos: parsed.lineNumber + offset, delta: -1 });
+				offset--;
+				break;
+			case "+":
+				newVisible.push(parsed.lineNumber);
+				changes.push({ newPos: parsed.lineNumber, delta: 1 });
+				offset++;
+				break;
+			default:
+				// Context rows are visible in BOTH files: pre-edit number as
+				// written, post-edit number shifted by the net change so far.
+				oldVisible.push(parsed.lineNumber);
+				newVisible.push(parsed.lineNumber + offset);
+				break;
+		}
+	}
+
+	const toOldLineNumber = (newLineNumber: number): number => {
+		let shift = 0;
+		for (const change of changes) {
+			if (change.newPos <= newLineNumber) shift += change.delta;
+		}
+		return newLineNumber - shift;
+	};
+
+	const contextRows = findBlockContextLines(oldLines, oldVisible, source);
+	for (const [lineNumber, text] of findBlockContextLines(newLines, newVisible, source)) {
+		const oldLineNumber = toOldLineNumber(lineNumber);
+		if (!contextRows.has(oldLineNumber)) contextRows.set(oldLineNumber, text);
+	}
+	insertBracketContextRows(rows, contextRows, seenRows);
+	normalizeDiffGapRows(rows);
+}
+
 /**
  * Generate a unified diff string with line numbers and context.
  * Returns both the diff string and the first changed line number (in the new file).
  */
-export function generateDiffString(oldContent: string, newContent: string, contextLines = 2): DiffResult {
+export function generateDiffString(
+	oldContent: string,
+	newContent: string,
+	contextLines = 2,
+	source: BlockContextSource = {},
+): DiffResult {
 	const parts = Diff.diffLines(oldContent, newContent);
 	const output: string[] = [];
 
@@ -133,8 +309,10 @@ export function generateDiffString(oldContent: string, newContent: string, conte
 					newLineNum++;
 				}
 
+				// Mid-skip placeholder is omitted too: the jump between the trailing
+				// number of the leading context and the leading number of the
+				// trailing context conveys the gap, just like leading/trailing skips.
 				if (middleSkip > 0) {
-					output.push(formatNumberedDiffLine(" ", oldLineNum, "..."));
 					oldLineNum += middleSkip;
 					newLineNum += middleSkip;
 					for (const line of linesToShow.slice(firstChunkLength)) {
@@ -160,6 +338,8 @@ export function generateDiffString(oldContent: string, newContent: string, conte
 		}
 	}
 
+	addMatchingBracketContextRows(output, oldContent.split("\n"), newContent.split("\n"), source);
+
 	return { diff: output.join("\n"), firstChangedLine };
 }
 
@@ -187,7 +367,12 @@ export interface ReplaceResult {
  * Generate a unified diff string without file headers.
  * Returns both the diff string and the first changed line number (in the new file).
  */
-export function generateUnifiedDiffString(oldContent: string, newContent: string, contextLines = 3): DiffResult {
+export function generateUnifiedDiffString(
+	oldContent: string,
+	newContent: string,
+	contextLines = 3,
+	source: BlockContextSource = {},
+): DiffResult {
 	const patch = Diff.structuredPatch("", "", oldContent, newContent, "", "", { context: contextLines });
 	const output: string[] = [];
 	let firstChangedLine: number | undefined;
@@ -218,6 +403,8 @@ export function generateUnifiedDiffString(oldContent: string, newContent: string
 		}
 	}
 
+	addMatchingBracketContextRows(output, oldContent.split("\n"), newContent.split("\n"), source);
+
 	return { diff: output.join("\n"), firstChangedLine };
 }
 
@@ -805,7 +992,7 @@ export async function computeEditDiff(
 			};
 		}
 
-		return generateDiffString(normalizedContent, result.content);
+		return generateDiffString(normalizedContent, result.content, undefined, { path });
 	} catch (err) {
 		return { error: err instanceof Error ? err.message : String(err) };
 	}

package/src/edit/file-snapshot-store.ts

@@ -8,6 +8,9 @@
  * from `@prometheus-ai/hashline`; the only coding-agent-specific concern here
  * is wiring it onto the per-session owner object.
  */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { InMemorySnapshotStore } from "@prometheus-ai/hashline";
 import { normalizeToLF } from "./normalize";
 
@@ -33,6 +36,36 @@ export function getFileSnapshotStore(session: FileSnapshotStoreOwner): InMemoryS
 	return session.fileSnapshotStore;
 }
 
+/**
+ * Canonicalize an absolute path into the stable key the snapshot store uses.
+ *
+ * Different code paths reach the snapshot store via different path forms:
+ * `read local://foo.md` records under the file's `fs.realpath` (the local
+ * protocol handler resolves symlinks); a subsequent `edit` may address the
+ * same artifact via `local://foo.md`, whose resolver does NOT realpath, or
+ * via the absolute path returned in the `[path#tag]` header. macOS adds the
+ * same hazard at the working-tree level (`/tmp/...` vs `/private/tmp/...`).
+ * Collapsing every key through `realpath` makes those forms fuse onto one
+ * snapshot entry, so a freshly-minted tag is never rejected as stale just
+ * because the lookup spelled the same file differently.
+ *
+ * Non-existent paths (new-file writes) fall back to a realpath of the parent
+ * directory + basename, then to the input. This keeps creates and updates on
+ * the same canonical key.
+ */
+export function canonicalSnapshotKey(absolutePath: string): string {
+	try {
+		return fs.realpathSync.native(absolutePath);
+	} catch {
+		try {
+			const parent = fs.realpathSync.native(path.dirname(absolutePath));
+			return path.join(parent, path.basename(absolutePath));
+		} catch {
+			return absolutePath;
+		}
+	}
+}
+
 /**
  * Read the full text of `absolutePath` (within {@link SNAPSHOT_MAX_BYTES}),
  * record it as a version snapshot, and return its content-hash tag. Returns
@@ -52,7 +85,7 @@ export async function recordFileSnapshot(
 		const file = Bun.file(absolutePath);
 		if (file.size > SNAPSHOT_MAX_BYTES) return undefined;
 		const normalized = normalizeToLF(await file.text());
-		return getFileSnapshotStore(session).record(absolutePath, normalized);
+		return getFileSnapshotStore(session).record(canonicalSnapshotKey(absolutePath), normalized);
 	} catch {
 		return undefined;
 	}

package/src/edit/hashline/block-resolver.ts

@@ -8,7 +8,26 @@
 import type { BlockResolver } from "@prometheus-ai/hashline";
 import { blockRangeAt } from "@prometheus-ai/natives";
 
+/**
+ * `blockRangeAt` runs a full synchronous tree-sitter parse of `text` per
+ * call, and streaming previews re-resolve the same (text, line) every
+ * streamed chunk. Memoize by content: identical text + line always yields the
+ * same span. FIFO-bounded; hashing the text is orders of magnitude cheaper
+ * than re-parsing it.
+ */
+const resolutionCache = new Map<string, { start: number; end: number } | null>();
+const RESOLUTION_CACHE_MAX = 512;
+
 export const nativeBlockResolver: BlockResolver = ({ path, text, line }) => {
+	const key = `${Bun.hash(text).toString(36)}:${text.length}:${line}:${path}`;
+	const cached = resolutionCache.get(key);
+	if (cached !== undefined) return cached;
 	const range = blockRangeAt({ code: text, path, line });
-	return range ? { start: range.startLine, end: range.endLine } : null;
+	const result = range ? { start: range.startLine, end: range.endLine } : null;
+	if (resolutionCache.size >= RESOLUTION_CACHE_MAX) {
+		const oldest = resolutionCache.keys().next().value;
+		if (oldest !== undefined) resolutionCache.delete(oldest);
+	}
+	resolutionCache.set(key, result);
+	return result;
 };