@iowarp/clio-coder 0.3.0 → 0.3.2

package/src/domains/context/contract.ts

@@ -0,0 +1,68 @@
+import type { DomainContract } from "../../core/domain-loader.js";
+import type { RunBootstrapInput, RunBootstrapResult } from "./bootstrap.js";
+import type { RunContextClearInput, RunContextClearResult } from "./clear.js";
+import type { ParsedClioMd } from "./clio-md.js";
+import type { RunContextRefreshInput, RunContextRefreshResult } from "./refresh.js";
+import type { RunWikiGenerateInput, RunWikiGenerateResult } from "./wiki/generate.js";
+
+export interface ProjectPromptContext {
+	text: string;
+	clioMd: ParsedClioMd | null;
+	warnings: string[];
+	/**
+	 * Absolute paths of the effective project handbooks, ancestor to nearest.
+	 * An override resets the inherited chain, so this names exactly the files
+	 * whose content is in `text`; empty when no selected handbook parsed.
+	 */
+	handbookFiles: string[];
+}
+
+/**
+ * Structured fields from the effective layered project handbook for bounded injection into worker prompts.
+ * Deliberately excludes the identity paragraph and any raw handbook prose.
+ */
+export interface ProjectStructuredContext {
+	projectName: string;
+	conventions: ReadonlyArray<string>;
+	invariants: ReadonlyArray<string>;
+	/**
+	 * Bodies of effective handbook H2 sections titled exactly "Verification expectations"
+	 * (case-insensitive). The only custom section ever projected to workers;
+	 * dispatch includes it for verification-class runs only. Absent when the
+	 * handbook has no such section.
+	 */
+	verificationExpectations?: string;
+}
+
+export interface ContextState {
+	clioMd: "ok" | "stale" | "none" | "malformed";
+	memoryCount: number;
+}
+
+export interface ContextContract extends DomainContract {
+	runBootstrap(input?: RunBootstrapInput): Promise<RunBootstrapResult>;
+	runContextClear(input?: RunContextClearInput): Promise<RunContextClearResult>;
+	/**
+	 * Rebuild the codewiki index and `.clio-coder` state without touching project handbooks.
+	 * Markdown wiki updates require the explicit refresh input flag.
+	 * Backs `/context refresh` and `clio-coder context refresh`.
+	 */
+	runContextRefresh(input?: RunContextRefreshInput): Promise<RunContextRefreshResult>;
+	runWikiGenerate(input?: RunWikiGenerateInput): Promise<RunWikiGenerateResult>;
+	renderPromptContext(cwd: string): ProjectPromptContext;
+	/**
+	 * Effective project handbook fields (project name, conventions, invariants)
+	 * or null when no selected handbook parses. Never returns raw handbook
+	 * text; used by dispatch to give workers bounded project context.
+	 */
+	projectStructuredContext(cwd?: string): ProjectStructuredContext | null;
+	contextState(cwd?: string): ContextState;
+	startupHints(): string[];
+	/**
+	 * Incrementally refresh the codewiki for files changed during the session
+	 * (e.g. after an edit or write). No-op when the project was never indexed;
+	 * full reconciliation still happens at session start and stop. Best-effort:
+	 * failures are swallowed so a tool call is never blocked by indexing.
+	 */
+	noteFileChanges(paths: ReadonlyArray<string>, cwd?: string): void;
+}

package/src/domains/context/excluded-dirs.ts

@@ -0,0 +1 @@
+export { WORKSPACE_EXCLUDED_DIRS as EXCLUDED_DIRS } from "../../core/workspace-files.js";

package/src/domains/context/extension.ts

@@ -0,0 +1,358 @@
+import { existsSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { BusChannels, type ContextActivityPayload } from "../../core/bus-events.js";
+import type { DomainBundle, DomainContext, DomainExtension } from "../../core/domain-loader.js";
+import { clioDataDir } from "../../core/xdg.js";
+import { loadMemoryRecordsSync } from "../memory/index.js";
+import { detectProjectType, type ProjectType } from "../session/workspace/project-type.js";
+import { adoptionSourcesChanged } from "./adoption.js";
+import { runBootstrap } from "./bootstrap.js";
+import { runContextClear } from "./clear.js";
+import { loadProjectClioMd } from "./clio-md.js";
+import { codewikiPath } from "./codewiki/artifact.js";
+import { coordinateCodewikiWrite, drainCodewikiWrites } from "./codewiki/coordinator.js";
+import type { ContextContract, ContextState } from "./contract.js";
+import { renderPromptContext } from "./prompt-context.js";
+import { runContextRefresh } from "./refresh.js";
+import { type ClioProjectState, readClioState, writeClioState } from "./state.js";
+import { runWikiGenerate } from "./wiki/generate.js";
+
+/**
+ * Persist the current Clio state for `cwd`, preserving imported-context source
+ * tracking and stamping the supplied fingerprint/index time. Shared by the session-start
+ * freshness check, in-session incremental updates, and session stop.
+ */
+function persistState(
+	cwd: string,
+	fingerprint: ClioProjectState["fingerprint"],
+	indexedAt: string,
+	prev: ClioProjectState | null,
+	codewikiVersion: number,
+	projectType: ProjectType,
+): void {
+	writeClioState(cwd, {
+		version: 1,
+		projectType: prev?.projectType ?? projectType,
+		fingerprint,
+		codewikiVersion,
+		...(prev?.contextSources ? { contextSources: prev.contextSources } : {}),
+		...(prev?.contextSourceHash ? { contextSourceHash: prev.contextSourceHash } : {}),
+		...(prev?.lastBootstrap ? { lastBootstrap: prev.lastBootstrap } : {}),
+		...(prev?.lastInitAt ? { lastInitAt: prev.lastInitAt } : {}),
+		lastSessionAt: prev?.lastSessionAt ?? new Date().toISOString(),
+		lastIndexedAt: indexedAt,
+	});
+}
+
+/**
+ * Rebuild the codewiki when it is missing or the working tree has drifted since
+ * the last full index. Runs once at session start (catches branch switches, git
+ * pulls, and out-of-session edits). Skips projects that were never indexed so we
+ * never index an arbitrary directory unprompted. This is the only place a
+ * session reconciles the index with the tree: in-session edits arrive through
+ * `noteFileChanges`, and stop() deliberately does no indexing at all.
+ *
+ * Every phase runs through one shared slicer. This work overlaps a mounted TUI:
+ * before slicing, a drifted tree on a 1100-file repository held the event loop
+ * for roughly four seconds at session start, during which the prompt was on
+ * screen and keystrokes queued silently. `void` on the promise never helped,
+ * because nothing inside it awaited.
+ */
+async function ensureCodewikiFresh(cwd: string): Promise<void> {
+	// The bootstrap model-generation child runs a headless session purely to draft
+	// CLIO-CODER.md; it must not re-index while the parent context-init owns the rebuild.
+	if (process.env.CLIO_CODER_BOOTSTRAP_GENERATE_CHILD === "1") return;
+	const state = readClioState(cwd);
+	if (!state && !existsSync(codewikiPath(cwd))) return;
+	const indexedAt = new Date().toISOString();
+	await coordinateCodewikiWrite(
+		cwd,
+		(current, workspace) => {
+			const language = readClioState(workspace)?.projectType ?? current?.language;
+			return {
+				kind: "ensure",
+				cwd,
+				...(language ? { language } : {}),
+				current,
+				previous: readClioState(workspace)?.fingerprint ?? null,
+			};
+		},
+		{
+			afterCommit: ({ codewiki, fingerprint }, workspace) =>
+				persistState(workspace, fingerprint, indexedAt, readClioState(workspace), codewiki.version, codewiki.language),
+		},
+	);
+}
+
+const CONTEXT_STATE_CACHE_TTL_MS = 1500;
+
+function memoryCount(): number {
+	try {
+		return loadMemoryRecordsSync(clioDataDir()).length;
+	} catch {
+		return 0;
+	}
+}
+
+function resolveClioMdState(cwd: string): ContextState["clioMd"] {
+	const clio = loadProjectClioMd(cwd);
+	if (clio.files.length === 0 && clio.errors.length === 0) return "none";
+	if (clio.errors.length > 0) return "malformed";
+	const state = readClioState(cwd);
+	const localStandardIsEffective = clio.files.some((file) => file.path === join(resolve(cwd), "CLIO-CODER.md"));
+	if (
+		localStandardIsEffective &&
+		state?.contextSources !== undefined &&
+		adoptionSourcesChanged(state.contextSources, { cwd })
+	) {
+		return "stale";
+	}
+	return "ok";
+}
+
+function createContextStateReader(): { read(cwd?: string): ContextState; invalidate(cwd?: string): void } {
+	let cached: { cwd: string; at: number; state: ContextState } | null = null;
+	return {
+		read(cwd = process.cwd()): ContextState {
+			const now = Date.now();
+			if (cached && cached.cwd === cwd && now - cached.at < CONTEXT_STATE_CACHE_TTL_MS) return cached.state;
+			const state: ContextState = { clioMd: resolveClioMdState(cwd), memoryCount: memoryCount() };
+			cached = { cwd, at: now, state };
+			return state;
+		},
+		invalidate(cwd) {
+			if (!cached) return;
+			if (!cwd || cached.cwd === cwd) cached = null;
+		},
+	};
+}
+
+export interface ContextBundleOptions {
+	noContextFiles?: boolean;
+}
+
+function collectStartupHints(cwd: string, options: ContextBundleOptions = {}): string[] {
+	const hints: string[] = [];
+	let projectType: ReturnType<typeof detectProjectType>;
+	try {
+		projectType = detectProjectType(cwd);
+	} catch {
+		projectType = "unknown";
+	}
+	const clio = loadProjectClioMd(cwd);
+	if (
+		clio.files.length === 0 &&
+		clio.errors.length === 0 &&
+		projectType !== "unknown" &&
+		options.noContextFiles !== true
+	) {
+		hints.push("clio: No CLIO-CODER.md detected. Run /context init to explore the repo and bootstrap context.");
+	}
+	for (const issue of clio.errors) {
+		hints.push(`clio: malformed ${issue.path} ignored: ${issue.error}`);
+	}
+	const state = readClioState(cwd);
+	if (!state) return hints;
+	if (state.contextSources !== undefined && adoptionSourcesChanged(state.contextSources, { cwd })) {
+		hints.push("clio: Imported agent context changed. Run /context init --adopt to refresh.");
+	}
+	return hints;
+}
+
+export function createContextBundle(
+	_context: DomainContext,
+	options: ContextBundleOptions = {},
+): DomainBundle<ContextContract> {
+	let lastCwd = process.cwd();
+	let stopping = false;
+	let startupHints: string[] = [];
+	const contextState = createContextStateReader();
+	const onStart = (): void => {
+		lastCwd = process.cwd();
+		void ensureCodewikiFresh(lastCwd).catch(() => {
+			// Indexing is best-effort; a failed refresh must not block session start.
+		});
+		startupHints = collectStartupHints(lastCwd, options);
+		if (process.env.CLIO_CODER_INTERACTIVE === "1") return;
+		for (const hint of startupHints) process.stderr.write(`${hint}\n`);
+	};
+
+	// Incremental updates are read-modify-write on the artifact; overlapping runs
+	// would compute from a stale base and drop each other's records, so batches
+	// serialize through this queue and stop() drains it before the process exits.
+	let incrementalQueue: Promise<void> = Promise.resolve();
+	const noteFileChanges = (paths: ReadonlyArray<string>, cwd: string = lastCwd): void => {
+		if (stopping) return;
+		const workspace = resolve(cwd);
+		incrementalQueue = incrementalQueue
+			.then(async () => {
+				if (paths.length === 0) return;
+				const rel = paths
+					.map((p) => (isAbsolute(p) ? relative(workspace, p) : p))
+					.filter((p) => p.length > 0 && !p.startsWith(".."));
+				// Fires after every write the agent makes, mid-turn, with the TUI
+				// mounted; an edge rebuild here is the same cost as one at start.
+				await coordinateCodewikiWrite(
+					workspace,
+					(current) => (current ? { kind: "incremental", cwd: workspace, current, paths: rel } : null),
+					{
+						requireExisting: true,
+						afterCommit: ({ codewiki, fingerprint, changed }, committedWorkspace) => {
+							if (!changed) return;
+							persistState(
+								committedWorkspace,
+								fingerprint,
+								new Date().toISOString(),
+								readClioState(committedWorkspace),
+								codewiki.version,
+								codewiki.language,
+							);
+						},
+					},
+				);
+				contextState.invalidate(workspace);
+			})
+			.catch(() => {
+				// Best-effort: never let incremental indexing surface as a tool error.
+			});
+	};
+
+	let unsubscribeSessionStart: (() => void) | null = null;
+	const extension: DomainExtension = {
+		start() {
+			unsubscribeSessionStart = _context.bus.on(BusChannels.SessionStart, onStart);
+		},
+		async stop() {
+			stopping = true;
+			unsubscribeSessionStart?.();
+			unsubscribeSessionStart = null;
+			// Everything the session changed already went through noteFileChanges,
+			// so the only work still owed at stop is the tail of that queue. Nothing
+			// here re-indexes: a stop-time rebuild used to run the same full scan as
+			// start on every exit, on the shutdown path, where one synchronous
+			// tree-sitter parse of a large file holds the event loop past every
+			// shutdown budget (issue #99). Out-of-band drift is start's job on the
+			// next session, and a never-indexed cwd stays that way; indexing an
+			// arbitrary directory because a process exited in it is not a favor.
+			await Promise.all([incrementalQueue, drainCodewikiWrites(lastCwd)]);
+			const state = readClioState(lastCwd);
+			if (!state) return;
+			// The fingerprint is left as the last index wrote it. Stamping a fresh
+			// one without re-indexing would hide drift from the next start.
+			writeClioState(lastCwd, { ...state, lastSessionAt: new Date().toISOString() });
+		},
+	};
+
+	const contract: ContextContract = {
+		async runBootstrap(input) {
+			const emitProgress = (event: Omit<ContextActivityPayload, "kind" | "at">): void => {
+				_context.bus.emit(BusChannels.ContextActivity, { kind: "context-init", at: Date.now(), ...event });
+				input?.onProgress?.(event);
+			};
+			try {
+				const result = await runBootstrap(input ? { ...input, onProgress: emitProgress } : { onProgress: emitProgress });
+				const cwd = input?.cwd ?? process.cwd();
+				contextState.invalidate(cwd);
+				if (cwd === lastCwd) startupHints = collectStartupHints(cwd, options);
+				return result;
+			} catch (err) {
+				emitProgress({
+					phase: "done",
+					status: "failed",
+					message: "context init failed",
+					detail: err instanceof Error ? err.message : String(err),
+				});
+				throw err;
+			}
+		},
+		async runContextClear(input) {
+			const emitProgress = (event: Omit<ContextActivityPayload, "kind" | "at">): void => {
+				_context.bus.emit(BusChannels.ContextActivity, { kind: "context-clear", at: Date.now(), ...event });
+			};
+			emitProgress({ phase: "done", status: "started", message: "clearing context" });
+			try {
+				const result = await runContextClear(input);
+				const cwd = input?.cwd ?? process.cwd();
+				contextState.invalidate(cwd);
+				if (cwd === lastCwd) startupHints = collectStartupHints(cwd, options);
+				emitProgress({ phase: "done", status: "completed", message: "context cleared" });
+				return result;
+			} catch (err) {
+				emitProgress({
+					phase: "done",
+					status: "failed",
+					message: "context clear failed",
+					detail: err instanceof Error ? err.message : String(err),
+				});
+				throw err;
+			}
+		},
+		async runContextRefresh(input) {
+			const emitProgress = (event: Omit<ContextActivityPayload, "kind" | "at">): void => {
+				_context.bus.emit(BusChannels.ContextActivity, { kind: "context-refresh", at: Date.now(), ...event });
+				input?.onProgress?.(event);
+			};
+			try {
+				const result = await runContextRefresh(
+					input ? { ...input, onProgress: emitProgress } : { onProgress: emitProgress },
+				);
+				const cwd = input?.cwd ?? process.cwd();
+				contextState.invalidate(cwd);
+				if (cwd === lastCwd) startupHints = collectStartupHints(cwd, options);
+				return result;
+			} catch (err) {
+				emitProgress({
+					phase: "done",
+					status: "failed",
+					message: "context refresh failed",
+					detail: err instanceof Error ? err.message : String(err),
+				});
+				throw err;
+			}
+		},
+		async runWikiGenerate(input) {
+			const emitProgress = (event: Omit<ContextActivityPayload, "kind" | "at">): void => {
+				_context.bus.emit(BusChannels.ContextActivity, { kind: "context-wiki", at: Date.now(), ...event });
+				input?.onProgress?.(event);
+			};
+			try {
+				return await runWikiGenerate(
+					input ? { ...input, onProgress: emitProgress } : { model: "configured-clio-target", onProgress: emitProgress },
+				);
+			} catch (err) {
+				emitProgress({
+					phase: "done",
+					status: "failed",
+					message: "context wiki failed",
+					detail: err instanceof Error ? err.message : String(err),
+				});
+				throw err;
+			}
+		},
+		renderPromptContext,
+		projectStructuredContext(cwd = process.cwd()) {
+			const clio = loadProjectClioMd(cwd).value;
+			if (!clio) return null;
+			// Exact-title allowlist: "Verification expectations" is the only
+			// custom section ever projected to workers (verification class only,
+			// enforced dispatch-side). Same case-insensitive comparison as
+			// clio-md's sectionBody().
+			const verificationBody = clio.sections
+				.filter((section) => section.title.toLowerCase() === "verification expectations")
+				.map((section) => section.body.trim())
+				.filter((body) => body.length > 0)
+				.join("\n\n");
+			return {
+				projectName: clio.projectName,
+				conventions: [...clio.conventions],
+				invariants: [...clio.invariants],
+				...(verificationBody.length > 0 ? { verificationExpectations: verificationBody } : {}),
+			};
+		},
+		contextState: contextState.read,
+		startupHints: () => [...startupHints],
+		noteFileChanges,
+	};
+
+	return { extension, contract };
+}

package/src/domains/context/fingerprint.ts

@@ -0,0 +1,198 @@
+import { execFile, execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { enumerateWorkspaceFiles, enumerateWorkspaceFilesAsync } from "../../core/workspace-files.js";
+import { readCodewiki, readCodewikiAsync } from "./codewiki/artifact.js";
+import { type CooperativeSlicer, createSlicer } from "./codewiki/cooperative.js";
+import { isIndexablePath } from "./codewiki/paths.js";
+import type { Codewiki } from "./codewiki/schema.js";
+import { EXCLUDED_DIRS } from "./excluded-dirs.js";
+
+const execFileAsync = promisify(execFile);
+
+export interface Fingerprint {
+	treeHash: string;
+	gitHead: string | null;
+	loc: number;
+}
+
+export interface FingerprintCacheOptions {
+	ttlMs?: number;
+}
+
+const DEFAULT_FINGERPRINT_CACHE_TTL_MS = 5_000;
+
+interface CachedFingerprint {
+	fingerprint: Fingerprint;
+	expiresAtMs: number;
+}
+
+const cachedFingerprints = new Map<string, CachedFingerprint>();
+
+const LOC_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".mjs",
+	".cjs",
+	".py",
+	".rs",
+	".go",
+	".cc",
+	".cpp",
+	".cxx",
+	".hpp",
+	".hh",
+	".hxx",
+	".c",
+	".h",
+	".cu",
+	".cuh",
+	".java",
+	".kt",
+]);
+
+function extensionOf(name: string): string {
+	const index = name.lastIndexOf(".");
+	return index === -1 ? "" : name.slice(index);
+}
+
+function currentGitHead(cwd: string): string | null {
+	try {
+		return execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+			cwd,
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+
+async function currentGitHeadAsync(cwd: string): Promise<string | null> {
+	try {
+		const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd, encoding: "utf8" });
+		return stdout.trim();
+	} catch {
+		return null;
+	}
+}
+
+function countLines(filePath: string): number {
+	try {
+		const text = readFileSync(filePath, "utf8");
+		if (text.length === 0) return 0;
+		let lines = 1;
+		for (const ch of text) {
+			if (ch === "\n") lines += 1;
+		}
+		return lines;
+	} catch {
+		return 0;
+	}
+}
+
+function locFromCodewiki(codewiki: Codewiki | null): number | null {
+	if (!codewiki) return null;
+	return codewiki.files.reduce((sum, file) => (file.lang === "config" ? sum : sum + file.loc), 0);
+}
+
+/**
+ * Hash one file's identity into the tree hash and accumulate its line count.
+ * Shared verbatim by the sync and sliced walks so the two produce identical
+ * fingerprints for the same tree.
+ */
+function accumulateFile(
+	cwd: string,
+	relPath: string,
+	hash: ReturnType<typeof createHash>,
+	artifactLoc: number | null,
+): number {
+	const absPath = join(cwd, relPath);
+	let stat: ReturnType<typeof statSync>;
+	try {
+		stat = statSync(absPath);
+	} catch {
+		return 0;
+	}
+	hash.update(`${relPath}:${stat.size}:${Math.floor(stat.mtimeMs)}\n`);
+	if (artifactLoc === null && LOC_EXTENSIONS.has(extensionOf(relPath))) return countLines(absPath);
+	return 0;
+}
+
+export function computeFingerprint(cwd: string, codewiki: Codewiki | null = readCodewiki(cwd)): Fingerprint {
+	const files = enumerateWorkspaceFiles(cwd, EXCLUDED_DIRS).filter(isIndexablePath);
+
+	const hash = createHash("sha256");
+	const artifactLoc = locFromCodewiki(codewiki);
+	let loc = 0;
+	for (const relPath of files) loc += accumulateFile(cwd, relPath, hash, artifactLoc);
+
+	return {
+		treeHash: hash.digest("hex"),
+		gitHead: currentGitHead(cwd),
+		loc: artifactLoc ?? loc,
+	};
+}
+
+export interface ComputeFingerprintAsyncOptions {
+	slicer?: CooperativeSlicer;
+}
+
+/**
+ * Same fingerprint, sliced. One `statSync` per visible file plus a `git
+ * rev-parse` is tens of milliseconds on a large repository, which is a dropped
+ * frame if it lands in one turn. Callers on a status-surface poll or on the
+ * session-start path should use this; one-shot CLI paths need not bother.
+ *
+ * The enumeration itself runs through `enumerateWorkspaceFilesAsync` on the
+ * same slicer, so the former 34 ms synchronous floor is gone too.
+ */
+export async function computeFingerprintAsync(
+	cwd: string,
+	codewiki: Codewiki | null | undefined = undefined,
+	options: ComputeFingerprintAsyncOptions = {},
+): Promise<Fingerprint> {
+	const slicer = options.slicer ?? createSlicer();
+	const artifact = codewiki === undefined ? await readCodewikiAsync(cwd) : codewiki;
+	await slicer.tick();
+	const files = (await enumerateWorkspaceFilesAsync(cwd, EXCLUDED_DIRS, undefined, slicer)).filter(isIndexablePath);
+
+	const hash = createHash("sha256");
+	const artifactLoc = locFromCodewiki(artifact);
+	let loc = 0;
+	for (const relPath of files) {
+		await slicer.tick();
+		loc += accumulateFile(cwd, relPath, hash, artifactLoc);
+	}
+
+	return {
+		treeHash: hash.digest("hex"),
+		gitHead: await currentGitHeadAsync(cwd),
+		loc: artifactLoc ?? loc,
+	};
+}
+
+export function computeFingerprintCached(
+	cwd: string,
+	codewiki: Codewiki | null = readCodewiki(cwd),
+	options: FingerprintCacheOptions = {},
+): Fingerprint {
+	const now = Date.now();
+	const cached = cachedFingerprints.get(cwd);
+	if (cached && cached.expiresAtMs > now) return cached.fingerprint;
+
+	const fingerprint = computeFingerprint(cwd, codewiki);
+	const ttlMs = options.ttlMs ?? DEFAULT_FINGERPRINT_CACHE_TTL_MS;
+	cachedFingerprints.set(cwd, {
+		fingerprint,
+		expiresAtMs: Date.now() + Math.max(0, ttlMs),
+	});
+	return fingerprint;
+}
+
+export function isStale(prev: Fingerprint, curr: Fingerprint): boolean {
+	return prev.treeHash !== curr.treeHash;
+}