@shanepadgett/tau-agent 0.33.0 → 0.34.0

package/extensions/context/sync.ts

@@ -11,16 +11,14 @@ import {
 	extensionPathsForTools,
 	runSubagentTurn,
 } from "../subagent/run.ts";
-import { collectSyncEvidence, CONTEXT_SYNC_EVIDENCE_TOOL } from "./evidence.ts";
 import { pathExists } from "./definitions.ts";
 import contextSettings from "./settings.ts";
-import { formatContextValidationFailure, validateContextCatalog } from "./validation.ts";
-import { restoreOutsideContextMutations, snapshotOutsideContext } from "./write-scope.ts";
+import { formatContextValidationFailure, listEligibleDirtyPaths, validateContextCatalog } from "./validation.ts";
 
 const CONTEXT_SYNC_AGENT = "context-sync";
 
 export interface ContextSyncDetails {
-	outcome: "applied" | "no-change" | "failed";
+	outcome: "applied" | "no-change" | "failed" | "cancelled";
 	summary: string;
 	reason: string;
 	changedContextFiles: string[];
@@ -28,53 +26,80 @@ export interface ContextSyncDetails {
 	validationFailure?: string;
 }
 
+type SyncStatus = (status: string) => void | Promise<void>;
+type GitRunner = ReturnType<typeof createGitRunner>;
+
 let syncQueue = Promise.resolve();
 
 export async function runContextSync(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
-	options: { nudge?: string; signal?: AbortSignal; onStatus?: (status: string) => void | Promise<void> } = {},
+	options: { nudge?: string; signal?: AbortSignal; onStatus?: SyncStatus } = {},
 ): Promise<ContextSyncDetails> {
 	return withSyncLock(() => runContextSyncLocked(pi, ctx, options));
 }
 
-async function runContextSyncLocked(
+function noChangeResult(reason: string, agentResponse?: string): ContextSyncDetails {
+	return {
+		outcome: "no-change",
+		summary: "Existing context mappings already fit the changed scope.",
+		reason,
+		changedContextFiles: [],
+		agentResponse,
+	};
+}
+
+async function inspectSyncNeed(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
-	options: { nudge?: string; signal?: AbortSignal; onStatus?: (status: string) => void | Promise<void> },
-): Promise<ContextSyncDetails> {
-	if (!ctx.isProjectTrusted()) throw new Error("Context sync requires a trusted project");
-	await options.onStatus?.("Inspecting repository context");
+	nudge: string | undefined,
+	onStatus?: SyncStatus,
+): Promise<
+	| { kind: "done"; result: ContextSyncDetails }
+	| { kind: "run"; git: GitRunner; root: string; ignoreGlobs: readonly string[] }
+> {
+	await onStatus?.("Inspecting repository context");
 	const git = createGitRunner(pi, ctx);
 	const status = await loadRepoStatus(git);
 	if (!status) throw new Error("No Git repository found");
 	const settings = await loadTauExtensionSettings(ctx, contextSettings);
-	const evidence = await collectSyncEvidence(git, status.root, settings.validation.ignoreGlobs);
-	if (evidence.files.length === 0 && evidence.missingPaths.size === 0)
+	const ignoreGlobs = settings.validation.ignoreGlobs;
+	const validation = await validateContextCatalog(git, status.root, ignoreGlobs);
+	const dirtyEligible = await listEligibleDirtyPaths(git, status.root, ignoreGlobs);
+	const force = Boolean(nudge?.trim());
+	if (!force && validation.stale.length === 0 && validation.uncovered.length === 0 && dirtyEligible.length === 0) {
 		return {
-			outcome: "no-change",
-			summary: "Existing context mappings already fit the changed scope.",
-			reason: "Changed files are outside context catalog scope.",
-			changedContextFiles: [],
+			kind: "done",
+			result: noChangeResult("No eligible dirty files, stale catalog paths, or sync nudge."),
 		};
+	}
+	return { kind: "run", git, root: status.root, ignoreGlobs };
+}
 
-	const beforeCatalog = await catalogFileSnapshot(status.root);
-	const outsideBefore = await snapshotOutsideContext(git, status.root);
+async function resolveContextSyncDefinition(ctx: ExtensionContext) {
 	const discovery = await discoverAgents(ctx.cwd, ctx.isProjectTrusted());
 	const definition = discovery.agents.get(CONTEXT_SYNC_AGENT);
-	if (!definition) {
-		const reason =
-			discovery.invalid
-				.get(CONTEXT_SYNC_AGENT)
-				?.map((item) => item.reason)
-				.join("; ") ?? "unknown agent";
-		throw new Error(`Context sync agent unavailable: ${reason}`);
-	}
-
-	const task = buildContextSyncTask(status.root, options.nudge);
-	const signal = options.signal ?? ctx.signal ?? new AbortController().signal;
+	if (definition) return definition;
+	const reason =
+		discovery.invalid
+			.get(CONTEXT_SYNC_AGENT)
+			?.map((item) => item.reason)
+			.join("; ") ?? "unknown agent";
+	throw new Error(`Context sync agent unavailable: ${reason}`);
+}
 
-	await options.onStatus?.("Running context-sync subagent");
+async function runContextSyncAgent(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	root: string,
+	nudge: string | undefined,
+	signal: AbortSignal,
+	onStatus: SyncStatus | undefined,
+	beforeCatalog: Map<string, string>,
+): Promise<ContextSyncDetails | { agentResponse: string }> {
+	const definition = await resolveContextSyncDefinition(ctx);
+	const task = buildContextSyncTask(root, nudge);
+	await onStatus?.("Running context-sync subagent");
 	const thread = await createSubagentThread({
 		id: `context-sync-${Date.now()}`,
 		displayName: definition.names[0] ?? definition.name,
@@ -88,7 +113,6 @@ async function runContextSyncLocked(
 			ctx.ui.notify(`Context sync agent: ${warning}`, "warning");
 		},
 	});
-	let agentResponse = "";
 	try {
 		const result = await runSubagentTurn({
 			thread,
@@ -97,49 +121,36 @@ async function runContextSyncLocked(
 			signal,
 			onUpdate: async (details) => {
 				const activity = details.currentActivity ?? details.response;
-				if (activity) await options.onStatus?.(activity.slice(0, 160));
+				if (activity) await onStatus?.(activity.slice(0, 160));
 			},
 		});
-		agentResponse = result.content;
+		if (signal.aborted || result.details.status === "aborted") return cancelledResult(result.content);
 		if (result.details.status !== "completed") {
-			const writeScopeViolations = await restoreOutsideContextMutations(git, status.root, outsideBefore);
 			return {
 				outcome: "failed",
 				summary: "Context sync subagent failed.",
-				reason: [
-					result.details.error ?? result.content,
-					writeScopeViolations.length
-						? `Restored out-of-scope writes:\n${writeScopeViolations.map((path) => `- ${path}`).join("\n")}`
-						: undefined,
-				]
-					.filter((line): line is string => Boolean(line))
-					.join("\n\n"),
-				changedContextFiles: changedCatalogPaths(beforeCatalog, await catalogFileSnapshot(status.root)),
-				agentResponse,
+				reason: result.details.error ?? result.content,
+				changedContextFiles: changedCatalogPaths(beforeCatalog, await catalogFileSnapshot(root)),
+				agentResponse: result.content,
 			};
 		}
+		return { agentResponse: result.content };
 	} finally {
 		await disposeSubagentThread(thread);
 	}
+}
 
-	await options.onStatus?.("Verifying write scope");
-	const writeScopeViolations = await restoreOutsideContextMutations(git, status.root, outsideBefore);
-	const afterCatalog = await catalogFileSnapshot(status.root);
-	const changedContextFiles = changedCatalogPaths(beforeCatalog, afterCatalog);
-	if (writeScopeViolations.length > 0) {
-		return {
-			outcome: "failed",
-			summary: "Context sync wrote outside .pi/contexts; out-of-scope paths were restored.",
-			reason: `Out-of-scope writes restored:\n${writeScopeViolations.map((path) => `- ${path}`).join("\n")}`,
-			changedContextFiles,
-			agentResponse,
-		};
-	}
-
-	await options.onStatus?.("Verifying context catalog");
-	const validationFailure = formatContextValidationFailure(
-		await validateContextCatalog(git, status.root, settings.validation.ignoreGlobs),
-	);
+async function finalizeContextSync(
+	git: GitRunner,
+	root: string,
+	ignoreGlobs: readonly string[],
+	beforeCatalog: Map<string, string>,
+	agentResponse: string,
+	onStatus?: SyncStatus,
+): Promise<ContextSyncDetails> {
+	const changedContextFiles = changedCatalogPaths(beforeCatalog, await catalogFileSnapshot(root));
+	await onStatus?.("Verifying context catalog");
+	const validationFailure = formatContextValidationFailure(await validateContextCatalog(git, root, ignoreGlobs));
 	if (validationFailure) {
 		return {
 			outcome: "failed",
@@ -151,13 +162,7 @@ async function runContextSyncLocked(
 		};
 	}
 	if (changedContextFiles.length === 0) {
-		return {
-			outcome: "no-change",
-			summary: "Existing context mappings already fit the changed scope.",
-			reason: agentResponse.trim() || "Context-sync subagent made no catalog edits.",
-			changedContextFiles: [],
-			agentResponse,
-		};
+		return noChangeResult(agentResponse.trim() || "Context-sync subagent made no catalog edits.", agentResponse);
 	}
 	return {
 		outcome: "applied",
@@ -168,13 +173,59 @@ async function runContextSyncLocked(
 	};
 }
 
-export function buildContextSyncTask(root: string, nudge?: string): string {
+async function runContextSyncLocked(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	options: { nudge?: string; signal?: AbortSignal; onStatus?: SyncStatus },
+): Promise<ContextSyncDetails> {
+	if (!ctx.isProjectTrusted()) throw new Error("Context sync requires a trusted project");
+	const signal = options.signal ?? ctx.signal ?? new AbortController().signal;
+	if (signal.aborted) return cancelledResult();
+
+	const need = await inspectSyncNeed(pi, ctx, options.nudge, options.onStatus);
+	if (need.kind === "done") return need.result;
+	if (signal.aborted) return cancelledResult();
+
+	const beforeCatalog = await catalogFileSnapshot(need.root);
+	const agentResult = await runContextSyncAgent(
+		pi,
+		ctx,
+		need.root,
+		options.nudge,
+		signal,
+		options.onStatus,
+		beforeCatalog,
+	);
+	if ("outcome" in agentResult) return agentResult;
+	if (signal.aborted) return cancelledResult(agentResult.agentResponse);
+	return finalizeContextSync(
+		need.git,
+		need.root,
+		need.ignoreGlobs,
+		beforeCatalog,
+		agentResult.agentResponse,
+		options.onStatus,
+	);
+}
+
+function cancelledResult(agentResponse?: string): ContextSyncDetails {
+	return {
+		outcome: "cancelled",
+		summary: "Context sync cancelled",
+		reason: agentResponse?.trim() || "Cancelled by user.",
+		changedContextFiles: [],
+		agentResponse,
+	};
+}
+
+function buildContextSyncTask(root: string, nudge?: string): string {
 	const trimmed = nudge?.trim();
 	return [
-		`Synchronize the repository context catalog at ${root}.`,
-		"Use context_sync_evidence for git/catalog facts. Edit only .pi/contexts with patch.",
-		"Walk the typology ladder out loud before path placement. Recheck invariants before finishing.",
-		trimmed ? `Human nudge (soft steer, does not skip evidence or ladder):\n${trimmed}` : undefined,
+		`Keep the repository context catalog at ${root} honest.`,
+		"Job: update `.pi/contexts` so work packs match the codebase.",
+		"Use normal repo tools. Prefer patch for catalog edits under `.pi/contexts`.",
+		"Walk domain → concept → job entry before placing paths. Harness verifies catalog coverage after you finish.",
+		trimmed ? `Human nudge (soft steer, does not skip the ladder or coverage):\n${trimmed}` : undefined,
 	]
 		.filter((line): line is string => Boolean(line))
 		.join("\n\n");
@@ -198,18 +249,20 @@ async function catalogFileSnapshot(root: string): Promise<Map<string, string>> {
 	const snapshot = new Map<string, string>();
 	const base = join(root, ".pi", "contexts");
 	if (!(await pathExists(base))) return snapshot;
-	for (const tab of (await readdir(base, { withFileTypes: true }))
-		.filter((item) => item.isDirectory())
-		.sort((a, b) => a.name.localeCompare(b.name))) {
-		for (const file of (await readdir(join(base, tab.name), { withFileTypes: true }))
-			.filter((item) => item.isFile() && extname(item.name) === ".toml")
-			.sort((a, b) => a.name.localeCompare(b.name))) {
-			const absolute = join(base, tab.name, file.name);
-			const path = relative(root, absolute).split(sep).join("/");
-			const hash = createHash("sha256")
-				.update(await readFile(absolute))
-				.digest("hex");
-			snapshot.set(path, hash);
+	const stack = [base];
+	while (stack.length > 0) {
+		const directory = stack.pop();
+		if (!directory) continue;
+		for (const entry of await readdir(directory, { withFileTypes: true })) {
+			const fullPath = join(directory, entry.name);
+			if (entry.isDirectory()) {
+				stack.push(fullPath);
+				continue;
+			}
+			if (!entry.isFile() || extname(entry.name) !== ".toml") continue;
+			const relativePath = relative(root, fullPath).split(sep).join("/");
+			const content = await readFile(fullPath, "utf8");
+			snapshot.set(relativePath, createHash("sha256").update(content).digest("hex"));
 		}
 	}
 	return snapshot;
@@ -221,6 +274,3 @@ function changedCatalogPaths(before: Map<string, string>, after: Map<string, str
 		.filter((path) => before.get(path) !== after.get(path))
 		.sort((left, right) => left.localeCompare(right));
 }
-
-// Ensure evidence tool name stays aligned with agent definition tooling.
-export const CONTEXT_SYNC_REQUIRED_TOOLS = ["read", "bash", "patch", CONTEXT_SYNC_EVIDENCE_TOOL] as const;

package/extensions/context/validation.ts

@@ -8,6 +8,17 @@ export interface ContextValidationResult {
 	uncovered: string[];
 }
 
+export async function listEligibleDirtyPaths(
+	git: GitRunner,
+	root: string,
+	ignoreGlobs: readonly string[],
+): Promise<string[]> {
+	const status = await git.run(["status", "--porcelain=v2", "-z", "--untracked-files=all"], { cwd: root });
+	return [...parseDirtyPaths(status)]
+		.filter((path) => !isSensitiveContextPath(path) && isContextEligiblePath(path, ignoreGlobs))
+		.sort((left, right) => left.localeCompare(right));
+}
+
 export async function validateContextCatalog(
 	git: GitRunner,
 	root: string,
@@ -28,31 +39,8 @@ export async function validateContextCatalog(
 		}
 	}
 
-	const status = await git.run(["status", "--porcelain=v2", "-z", "--untracked-files=all"], { cwd: root });
-	const records = status.split("\0");
-	const dirty = new Set<string>();
-	for (let index = 0; index < records.length; index++) {
-		const record = records[index];
-		if (!record) continue;
-		if (record.startsWith("? ")) {
-			dirty.add(record.slice(2).replaceAll("\\", "/"));
-			continue;
-		}
-		const fields = record.split(" ");
-		const state = fields[1] ?? "..";
-		if (record.startsWith("1 ") && !state.includes("D")) {
-			dirty.add(fields.slice(8).join(" ").replaceAll("\\", "/"));
-		} else if (record.startsWith("2 ")) {
-			if (!state.includes("D")) dirty.add(fields.slice(9).join(" ").replaceAll("\\", "/"));
-			index += 1;
-		} else if (record.startsWith("u ")) {
-			dirty.add(fields.slice(10).join(" ").replaceAll("\\", "/"));
-		}
-	}
-	const uncovered = [...dirty]
-		.filter(
-			(path) => !isSensitiveContextPath(path) && isContextEligiblePath(path, ignoreGlobs) && !memberships.has(path),
-		)
+	const uncovered = (await listEligibleDirtyPaths(git, root, ignoreGlobs))
+		.filter((path) => !memberships.has(path))
 		.sort((left, right) => left.localeCompare(right));
 	return { stale: stale.sort((left, right) => left.path.localeCompare(right.path)), uncovered };
 }
@@ -74,3 +62,27 @@ export function formatContextValidationFailure(result: ContextValidationResult):
 	);
 	return output.join("\n");
 }
+
+function parseDirtyPaths(status: string): Set<string> {
+	const records = status.split("\0");
+	const dirty = new Set<string>();
+	for (let index = 0; index < records.length; index++) {
+		const record = records[index];
+		if (!record) continue;
+		if (record.startsWith("? ")) {
+			dirty.add(record.slice(2).replaceAll("\\", "/"));
+			continue;
+		}
+		const fields = record.split(" ");
+		const state = fields[1] ?? "..";
+		if (record.startsWith("1 ") && !state.includes("D")) {
+			dirty.add(fields.slice(8).join(" ").replaceAll("\\", "/"));
+		} else if (record.startsWith("2 ")) {
+			if (!state.includes("D")) dirty.add(fields.slice(9).join(" ").replaceAll("\\", "/"));
+			index += 1;
+		} else if (record.startsWith("u ")) {
+			dirty.add(fields.slice(10).join(" ").replaceAll("\\", "/"));
+		}
+	}
+	return dirty;
+}

package/extensions/effort/README.md

@@ -2,6 +2,6 @@
 
 Switches active chat model and thinking level as one effort tier. Available providers come from current logins, and each provider can fall back through its ranked models.
 
-Run `/effort` to choose a tier and provider. `/effort low`, `/effort medium`, and `/effort high` skip the tier prompt. Press `Ctrl+Shift+E` to cycle tiers on current provider.
+Run `/effort` to choose a tier and provider. `/effort quick`, `/effort standard`, and `/effort deep` skip the tier prompt. Press `Ctrl+Shift+E` to cycle tiers on current provider.
 
 If selected provider has no usable model for tier, current model stays active. Footer shows an effort label whenever current provider, model, and thinking level match a configured tier; otherwise it shows no label.

package/extensions/effort/index.ts

@@ -9,7 +9,7 @@ import {
 } from "../../shared/model-effort.ts";
 import { EFFORT_STATE_TYPE, effortState, nextEffort } from "./state.ts";
 
-const EFFORTS: readonly ModelEffort[] = ["low", "medium", "high"];
+const EFFORTS: readonly ModelEffort[] = ["quick", "standard", "deep"];
 
 export default function effortExtension(pi: ExtensionAPI): void {
 	let activeEffort: ModelEffort | undefined;
@@ -81,7 +81,7 @@ export default function effortExtension(pi: ExtensionAPI): void {
 			}
 			const arg = args.trim().toLowerCase();
 			if (arg && !isModelEffort(arg)) {
-				ctx.ui.notify("Usage: /effort [low|medium|high]", "error");
+				ctx.ui.notify("Usage: /effort [quick|standard|deep]", "error");
 				return;
 			}
 			let effort: ModelEffort | undefined = isModelEffort(arg) ? arg : undefined;
@@ -130,5 +130,5 @@ export default function effortExtension(pi: ExtensionAPI): void {
 }
 
 function isModelEffort(value: string): value is ModelEffort {
-	return value === "low" || value === "medium" || value === "high";
+	return value === "quick" || value === "standard" || value === "deep";
 }

package/extensions/effort/state.ts

@@ -1,4 +1,3 @@
-import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 import type { ModelEffort } from "../../shared/model-effort.ts";
 
 export const EFFORT_STATE_TYPE = "tau.model-effort.state";
@@ -12,22 +11,8 @@ export function effortState(effort: ModelEffort | undefined): EffortStateV1 {
 	return { v: 1, effort: effort ?? null };
 }
 
-export function replayEffortState(branch: readonly SessionEntry[]): ModelEffort | undefined {
-	for (let index = branch.length - 1; index >= 0; index -= 1) {
-		const entry = branch[index];
-		if (entry?.type !== "custom" || entry.customType !== EFFORT_STATE_TYPE) continue;
-		const data = entry.data;
-		if (!data || typeof data !== "object") continue;
-		const value = data as Record<string, unknown>;
-		if (value.v !== 1) continue;
-		if (value.effort === null) return undefined;
-		if (value.effort === "low" || value.effort === "medium" || value.effort === "high") return value.effort;
-	}
-	return undefined;
-}
-
 export function nextEffort(effort: ModelEffort | undefined): ModelEffort {
-	if (effort === "low") return "medium";
-	if (effort === "medium") return "high";
-	return "low";
+	if (effort === "quick") return "standard";
+	if (effort === "standard") return "deep";
+	return "quick";
 }

package/extensions/explore/guidance.ts

@@ -1,52 +1,11 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { ExploreEngine } from "./ast/engine.ts";
-import { walkPaths } from "./traverse.ts";
 
-const GUIDANCE_SCAN_MAX_ENTRIES = 4096;
+const GUIDANCE = `## Explore
+Shape-backed languages: \`markdown\`, \`typescript\`, \`tsx\`, \`go\`, \`rust\`, \`c_sharp\`, \`java\`, \`kotlin\`, \`swift\`.
 
-export function registerExploreGuidance(pi: ExtensionAPI, engineFor: (cwd: string) => ExploreEngine): void {
-	pi.on("before_agent_start", async (event, ctx) => {
-		try {
-			const engine = engineFor(ctx.cwd);
-			const advertised = engine.registry
-				.registeredLanguages()
-				.filter((language) => language.capabilities.shape)
-				.map((language) => language.id);
-			const advertisedSet = new Set(advertised);
-			const detected = new Set<string>();
+Structural tools (\`outline\`, \`show\`, \`discover\`, \`ast_search\`, deps/relationships, \`impact\`, \`context\`) apply to those languages. Other files: harness \`read\` / \`grep\` / \`find\` / \`ls\`.
+Full \`read\` of a large registered source returns outline + follow-up hint, not the body — use ranged \`read\` or \`show\`.`;
 
-			await walkPaths({
-				cwd: engine.cwd,
-				root: ".",
-				filesOnly: true,
-				budgets: { maxFiles: GUIDANCE_SCAN_MAX_ENTRIES },
-				onFile(hit) {
-					const language = engine.registry.adapterForPath(hit.absolutePath)?.id;
-					if (language !== undefined && advertisedSet.has(language)) detected.add(language);
-					return detected.size < advertisedSet.size;
-				},
-			});
-
-			const backed = advertised.filter((language) => detected.has(language));
-			if (backed.length === 0) return undefined;
-
-			const guidance = `## Explore source policy
-Structurally backed languages detected in this workspace: ${backed.map((language) => `\`${language}\``).join(", ")}.
-
-- Use the same workflow for every backed language. Identify the job type before loading deeply: locate, reuse, edit, explain, or debug.
-- Ask the smallest sufficient query and stop when it answers the question.
-- Prefer \`outline\` for unfamiliar trees and known packages. A large full harness \`read\` returns an outline; use ranged \`read\` or \`show\` for bodies.
-- Prefer \`discover\` when reuse is the goal and the path is unknown. Search package/public surfaces first.
-- Bind targets with path + name (+ line when needed). Use \`show\` views cheapest to richest: \`signature\`, \`signatureWithDocs\`, \`declaration\`, \`declarationWithImports\`.
-- Run \`impact\` before a non-trivial symbol change. Use \`context\` to understand one symbol in one bounded pack.
-- After selecting a target, use \`callers\`, \`callees\`, \`references\`, or \`implementations\` for focused relationship questions.
-- Use \`ast_search\` for code shapes and harness \`grep\` for literals. Use harness \`read\` for formatting, comments, gaps, and unsupported files.
-- List and search paths with harness \`ls\`, \`find\`, and \`grep\`. Edit only with harness patch/edit/write tools.
-- Trust structural hits as exact path, line, and source text. Do not ask for scores or engine metadata.`;
-
-			return { systemPrompt: `${event.systemPrompt}\n\n${guidance}` };
-		} catch {
-			return undefined;
-		}
-	});
+export function registerExploreGuidance(pi: ExtensionAPI): void {
+	pi.on("before_agent_start", (event) => ({ systemPrompt: `${event.systemPrompt}\n\n${GUIDANCE}` }));
 }

package/extensions/explore/index.ts

@@ -3,50 +3,42 @@ import { resolve } from "node:path";
 import { onTauEvent } from "../../shared/events.ts";
 import { createTemporaryOutputStore } from "../../shared/temporary-output-store.ts";
 import { createToolRowStateStore } from "../../shared/tool-row-state.ts";
-import { createExploreEngine, type ExploreEngine } from "./ast/engine.ts";
-import { createFileGraph, type ExploreFileGraph } from "./ast/graph/file-graph.ts";
-import { registerReadOutlineHook } from "./ast/read/hook.ts";
-import { createAstSearchTool } from "./ast/tools/ast-search.ts";
-import { createContextTool } from "./ast/tools/context.ts";
-import { createDepsTool } from "./ast/tools/deps.ts";
-import { createDiscoverTool } from "./ast/tools/discover.ts";
-import { createImpactTool } from "./ast/tools/impact.ts";
-import { createOutlineTool } from "./ast/tools/outline.ts";
+import type { ExploreEngine } from "../../src/ast/engine.ts";
+import type { ExploreFileGraph } from "../../src/ast/graph/file-graph.ts";
+import {
+	astEngineFor,
+	astGraphFor,
+	clearAstSession,
+	invalidateAstPaths,
+	restartAstSession,
+	shutdownAstSession,
+} from "../../src/ast/session.ts";
+import { registerFileInjection } from "../../src/file-injection/index.ts";
+import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
+import { registerReadOutlineHook } from "./read/hook.ts";
+import { createAstSearchTool } from "./tools/ast-search.ts";
+import { createContextTool } from "./tools/context.ts";
+import { createDepsTool } from "./tools/deps.ts";
+import { createDiscoverTool } from "./tools/discover.ts";
+import { createImpactTool } from "./tools/impact.ts";
+import { createOutlineTool } from "./tools/outline.ts";
 import {
 	createCalleesTool,
 	createCallersTool,
 	createImplementationsTool,
 	createReferencesTool,
-} from "./ast/tools/relationships.ts";
-import { createReverseDepsTool } from "./ast/tools/reverse-deps.ts";
-import { createShowTool } from "./ast/tools/show.ts";
+} from "./tools/relationships.ts";
+import { createReverseDepsTool } from "./tools/reverse-deps.ts";
+import { createShowTool } from "./tools/show.ts";
 import { registerExploreGuidance } from "./guidance.ts";
-import { registerExploreOutlineInjection } from "./outline-injection.ts";
-import { registerExploreAutoread } from "./read/autoread.ts";
+import exploreSettings from "./settings.ts";
 
 export default function exploreExtension(pi: ExtensionAPI): void {
 	const rowState = createToolRowStateStore(pi, "explore.tool-row-state");
 	const temporaryOutput = createTemporaryOutputStore();
-	let engine: ExploreEngine | undefined;
-	let graph: ExploreFileGraph | undefined;
-
-	const engineFor = (cwd: string): ExploreEngine => {
-		const absoluteCwd = resolve(cwd);
-		if (engine !== undefined && engine.cwd === absoluteCwd) return engine;
-		engine?.shutdown();
-		graph?.clear();
-		engine = createExploreEngine({ cwd: absoluteCwd });
-		graph = createFileGraph(engine);
-		return engine;
-	};
-
-	const graphFor = (cwd: string): ExploreFileGraph => {
-		engineFor(cwd);
-		if (graph === undefined) {
-			throw new Error("Explore file graph failed to initialize");
-		}
-		return graph;
-	};
+	let readSettings = exploreSettings.defaults.read;
+	const engineFor = (cwd: string): ExploreEngine => astEngineFor(cwd);
+	const graphFor = (cwd: string): ExploreFileGraph => astGraphFor(cwd);
 
 	pi.registerTool(createOutlineTool(rowState, temporaryOutput, engineFor));
 	pi.registerTool(createShowTool(rowState, engineFor));
@@ -61,45 +53,38 @@ export default function exploreExtension(pi: ExtensionAPI): void {
 	pi.registerTool(createImpactTool(rowState, temporaryOutput, engineFor, graphFor));
 	pi.registerTool(createContextTool(rowState, temporaryOutput, engineFor, graphFor));
 	registerReadOutlineHook(pi, engineFor);
-	registerExploreAutoread(pi, rowState, engineFor);
-	registerExploreOutlineInjection(pi, rowState, temporaryOutput, engineFor);
-	registerExploreGuidance(pi, engineFor);
+	registerFileInjection(pi, rowState, {
+		temporaryOutput,
+		autoOutline: () => ({ enabled: readSettings.enabled, thresholdLines: readSettings.structureThresholdLines }),
+	});
+	registerExploreGuidance(pi);
 
 	pi.on("session_start", async (_event, ctx) => {
+		readSettings = (await loadTauExtensionSettings(ctx, exploreSettings)).read;
 		await temporaryOutput.shutdown();
 		await temporaryOutput.start();
 		rowState.clear();
-		engine?.shutdown();
-		graph?.clear();
-		engine = createExploreEngine({ cwd: ctx.cwd });
-		graph = createFileGraph(engine);
+		restartAstSession(ctx.cwd);
 	});
 
 	onTauEvent(pi, "explore.ast", "tau:file-mutation.applied", (event) => {
-		if (engine === undefined) return;
 		const paths = event.changes.flatMap((change) => {
 			const main = resolve(event.cwd, change.path);
 			if (change.move === undefined) return [main];
 			return [main, resolve(event.cwd, change.move.from), resolve(event.cwd, change.move.to)];
 		});
-		engine.invalidate(paths);
-		const topologyChanged = event.changes.some(
-			(change) => change.kind === "add" || change.kind === "delete" || change.move !== undefined,
+		invalidateAstPaths(
+			paths,
+			event.changes.some((change) => change.kind === "add" || change.kind === "delete" || change.move !== undefined),
 		);
-		if (topologyChanged) graph?.clear();
-		else graph?.invalidate(paths);
 	});
 
 	pi.on("session_tree", () => {
-		engine?.clear();
-		graph?.clear();
+		clearAstSession();
 	});
 
 	pi.on("session_shutdown", async () => {
-		engine?.shutdown();
-		engine = undefined;
-		graph?.clear();
-		graph = undefined;
+		shutdownAstSession();
 		await temporaryOutput.shutdown();
 	});
 }