@shanepadgett/tau-agent 0.26.0 → 0.28.0

package/extensions/explore/read/autoread.ts

@@ -0,0 +1,118 @@
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { prepareAutoreadMessage, registerAutoread, type PreparedAutoreadMessage } from "../../../shared/autoread.ts";
+import { createCompleteFileMeta } from "../../../shared/full-file-knowledge.ts";
+import { loadTauExtensionSettings } from "../../../shared/settings/load.ts";
+import type { ToolRowStateStore } from "../../../shared/tool-row-state.ts";
+import type { ExploreEngine } from "../ast/engine.ts";
+import { formatOutlineFile } from "../ast/format/outline.ts";
+import { formatLargeReadOutline, shouldOutlineFullRead, type ExploreReadSettings } from "../ast/read/policy.ts";
+import { outlinePath } from "../ast/queries/outline.ts";
+import exploreSettings from "../settings.ts";
+import { resolveExplorePath } from "../traverse.ts";
+
+const DEFAULT_OUTLINE_OPTIONS = {
+	includePrivate: false,
+	includeDocs: false,
+	names: [] as readonly string[],
+};
+
+export function registerExploreAutoread(
+	pi: ExtensionAPI,
+	rowState: ToolRowStateStore,
+	engineFor: (cwd: string) => ExploreEngine,
+): void {
+	let readSettings: ExploreReadSettings = exploreSettings.defaults.read;
+
+	pi.on("session_start", async (_event, ctx) => {
+		const settings = await loadTauExtensionSettings(ctx, exploreSettings);
+		readSettings = settings.read;
+	});
+
+	registerAutoread(pi, rowState, async (options) => {
+		return prepareExploreAutoreadMessage({
+			...options,
+			engine: engineFor(options.cwd),
+			readSettings,
+		});
+	});
+}
+
+async function prepareExploreAutoreadMessage(options: {
+	rowId: string;
+	path: string;
+	cwd: string;
+	source: string;
+	batchId: string;
+	signal: AbortSignal | undefined;
+	isLifecycleCurrent: () => boolean;
+	maximumBytes?: number;
+	engine: ExploreEngine;
+	readSettings: ExploreReadSettings;
+}): Promise<PreparedAutoreadMessage> {
+	const { engine, readSettings, ...shared } = options;
+	if (!readSettings.enabled) return prepareAutoreadMessage(shared);
+
+	const absolutePath = resolveExplorePath(options.cwd, options.path);
+	if (engine.registry.adapterForPath(absolutePath) === undefined) {
+		return prepareAutoreadMessage(shared);
+	}
+
+	assertPreparationCurrent(options.signal, options.isLifecycleCurrent);
+
+	let lineCount: number;
+	try {
+		const source = await engine.sourceForFile(absolutePath);
+		lineCount = source.ir.lineCount;
+	} catch {
+		return prepareAutoreadMessage(shared);
+	}
+
+	if (!shouldOutlineFullRead(lineCount, readSettings.structureThresholdLines)) {
+		return prepareAutoreadMessage(shared);
+	}
+
+	const abort = options.signal ?? new AbortController().signal;
+	const result = await outlinePath(engine, options.path, DEFAULT_OUTLINE_OPTIONS, abort);
+	assertPreparationCurrent(options.signal, options.isLifecycleCurrent);
+	if (result.mode !== "file") {
+		return prepareAutoreadMessage(shared);
+	}
+
+	const outlineBody =
+		result.file.rows.length === 0 ? "No declarations" : formatOutlineFile(result.file, engine.cwd, false);
+	const outlineText = formatLargeReadOutline(outlineBody);
+	const messageContent = `${options.path}\n${outlineText}`;
+	const pathKey = resolve(options.cwd, options.path);
+	const readCache = createCompleteFileMeta({
+		pathKey,
+		presentation: "plain",
+		servedHash: createHash("sha256").update(outlineText, "utf8").digest("hex"),
+		mode: "baseline",
+		sourceText: outlineText,
+		returnedText: messageContent,
+		totalLines: lineCount,
+		summary: `outline (${lineCount} lines)`,
+	});
+
+	return {
+		customType: "tau.autoread",
+		content: messageContent,
+		display: true,
+		details: {
+			rowId: options.rowId,
+			path: options.path,
+			cwd: options.cwd,
+			source: options.source,
+			batchId: options.batchId,
+			status: "read",
+			readCache,
+		},
+	};
+}
+
+function assertPreparationCurrent(signal: AbortSignal | undefined, isLifecycleCurrent: () => boolean): void {
+	signal?.throwIfAborted();
+	if (!isLifecycleCurrent()) throw new Error("Autoread preparation crossed a session lifecycle boundary");
+}

package/extensions/explore/settings.ts

@@ -0,0 +1,64 @@
+import { Type } from "typebox";
+import { defineTauExtensionSettings } from "../../shared/settings/define.ts";
+
+export default defineTauExtensionSettings({
+	key: "explore",
+	defaults: {
+		context: {
+			defaultBudgetTokens: 8000 as number,
+		},
+		read: {
+			enabled: true as boolean,
+			structureThresholdLines: 200 as number,
+			maxRangeLines: 200 as number,
+		},
+	},
+	schema: Type.Object(
+		{
+			context: Type.Optional(
+				Type.Object(
+					{
+						defaultBudgetTokens: Type.Optional(
+							Type.Integer({
+								default: 8000,
+								minimum: 1,
+								description: "Default token budget for context when the caller omits budget.",
+							}),
+						),
+					},
+					{ additionalProperties: false },
+				),
+			),
+			read: Type.Optional(
+				Type.Object(
+					{
+						enabled: Type.Optional(
+							Type.Boolean({
+								default: true,
+								description:
+									"Master switch for Explore structural read overlay and large-source autoread outline path. When false, Pi read and autoread keep ordinary full bodies.",
+							}),
+						),
+						structureThresholdLines: Type.Optional(
+							Type.Integer({
+								default: 200,
+								minimum: 1,
+								description:
+									"Registered source at or under this line count may be full-read. Above it, full read model-visible result is outline only.",
+							}),
+						),
+						maxRangeLines: Type.Optional(
+							Type.Integer({
+								default: 200,
+								minimum: 1,
+								description: "Maximum lines returned by one ranged read on registered source.",
+							}),
+						),
+					},
+					{ additionalProperties: false },
+				),
+			),
+		},
+		{ additionalProperties: false },
+	),
+});

package/extensions/explore/traverse.ts

@@ -1,39 +1,80 @@
 import type { Stats } from "node:fs";
-import { lstat, readdir, readFile } from "node:fs/promises";
-import { dirname, join, matchesGlob, resolve, sep } from "node:path";
-import { formatPathForDisplay, isWithinPath, relativeSlash, toSlashPath } from "./path-display.ts";
+import { lstat, opendir, readFile } from "node:fs/promises";
+import { isAbsolute, join, matchesGlob, relative, resolve, sep } from "node:path";
+
+/** Default recursive budgets for structural directory ops (path-conventions.md). */
+export const DEFAULT_TRAVERSAL_BUDGETS = {
+	maxFiles: 2000,
+	maxSourceBytes: 64 * 1024 * 1024,
+	maxDepth: 32,
+	maxElapsedMs: 20_000,
+} as const;
+
+export type TraversalBudgets = {
+	maxFiles: number;
+	maxSourceBytes: number;
+	maxDepth: number;
+	maxElapsedMs: number;
+};
 
 export type PathKind = "file" | "dir";
 
-export interface TraversalEntry {
+export type TraversalHit = {
 	absolutePath: string;
 	displayPath: string;
 	type: PathKind;
 	stats: Stats;
 	depth: number;
-	empty?: boolean;
-}
+};
+
+export type TraversalLimit = "maxFiles" | "maxSourceBytes" | "maxDepth" | "maxElapsedMs" | "cancelled";
 
-export interface CollectPathOptions {
+export type TraversalResult = {
+	entries: TraversalHit[];
+	/** Set when a budget or cancellation stopped the walk before the tree was complete. */
+	limit: TraversalLimit | undefined;
+	filesVisited: number;
+	sourceBytes: number;
+	elapsedMs: number;
+};
+
+export type WalkOptions = {
 	cwd: string;
 	root: string;
-	maxDepth?: number;
-	includeRoot: boolean;
-	includeHidden: boolean;
-	includeIgnored: boolean;
-	includeNoise: boolean;
-}
+	/** Include the root path itself when it is a file or directory. Default true. */
+	includeRoot?: boolean;
+	/** Descend into hidden path segments (name starts with `.`). Default false. */
+	includeHidden?: boolean;
+	/** Include paths matching gitignore-style rules. Default false. */
+	includeIgnored?: boolean;
+	/** Include common noise directories (node_modules, dist, …). Default false. */
+	includeNoise?: boolean;
+	/** Only yield files (skip directory entries in the result list). Default true. */
+	filesOnly?: boolean;
+	budgets?: Partial<TraversalBudgets>;
+	signal?: AbortSignal;
+	/**
+	 * Called after each accepted file. Return false to stop early without a budget limit
+	 * (caller owns the stop reason). Async allowed for cooperative yielding.
+	 */
+	onFile?: (hit: TraversalHit) => void | boolean | Promise<void | boolean>;
+	/**
+	 * If set, files for which this returns false are skipped without counting toward budgets.
+	 * Directories are not filtered here.
+	 */
+	matchFile?: (hit: TraversalHit) => boolean;
+};
 
-interface IgnoreRule {
+type IgnoreRule = {
 	baseDir: string;
 	pattern: string;
 	negated: boolean;
 	dirOnly: boolean;
 	hasSlash: boolean;
 	anchored: boolean;
-}
+};
 
-const NOISE_PATH_NAMES = new Set([
+const NOISE_NAMES = new Set([
 	".git",
 	"node_modules",
 	"dist",
@@ -46,20 +87,65 @@ const NOISE_PATH_NAMES = new Set([
 	"out",
 ]);
 
-function entryKind(stats: Stats): PathKind {
-	return stats.isDirectory() ? "dir" : "file";
+export function stripLeadingAt(value: string): string {
+	return value.startsWith("@") ? value.slice(1) : value;
+}
+
+function toSlashPath(value: string): string {
+	return value.replaceAll("\\", "/");
+}
+
+export function resolveExplorePath(cwd: string, input: string): string {
+	const path = stripLeadingAt(input);
+	if (path.length === 0) return resolve(cwd);
+	return isAbsolute(path) ? resolve(path) : resolve(cwd, path);
+}
+
+export function pathResolutionError(error: unknown, input: string): Error {
+	if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+		return new Error(`Path not found: ${stripLeadingAt(input)}`);
+	}
+	return error instanceof Error ? error : new Error(String(error));
+}
+
+function isWithinPath(parent: string, child: string): boolean {
+	const rel = relative(resolve(parent), resolve(child));
+	return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+export function formatPathForDisplay(absolutePath: string, cwd: string): string {
+	const resolvedCwd = resolve(cwd);
+	const resolvedPath = resolve(absolutePath);
+	const rel = relative(resolvedCwd, resolvedPath);
+	if (rel === "") return ".";
+	if (!rel.startsWith("..") && !isAbsolute(rel)) return toSlashPath(rel);
+	return toSlashPath(resolvedPath);
+}
+
+function relativeSlash(from: string, to: string): string {
+	const rel = relative(resolve(from), resolve(to));
+	return rel === "" ? "." : toSlashPath(rel);
+}
+
+function mergeBudgets(partial: Partial<TraversalBudgets> | undefined): TraversalBudgets {
+	return {
+		maxFiles: partial?.maxFiles ?? DEFAULT_TRAVERSAL_BUDGETS.maxFiles,
+		maxSourceBytes: partial?.maxSourceBytes ?? DEFAULT_TRAVERSAL_BUDGETS.maxSourceBytes,
+		maxDepth: partial?.maxDepth ?? DEFAULT_TRAVERSAL_BUDGETS.maxDepth,
+		maxElapsedMs: partial?.maxElapsedMs ?? DEFAULT_TRAVERSAL_BUDGETS.maxElapsedMs,
+	};
 }
 
 function pathSegments(displayPath: string): string[] {
 	return displayPath.split("/").filter((segment) => segment.length > 0 && segment !== ".");
 }
 
-function hasHiddenPathSegment(displayPath: string): boolean {
+function hasHiddenSegment(displayPath: string): boolean {
 	return pathSegments(displayPath).some((segment) => segment.startsWith("."));
 }
 
-function hasNoisePathSegment(displayPath: string): boolean {
-	return pathSegments(displayPath).some((segment) => NOISE_PATH_NAMES.has(segment));
+function hasNoiseSegment(displayPath: string): boolean {
+	return pathSegments(displayPath).some((segment) => NOISE_NAMES.has(segment));
 }
 
 function parseIgnoreLine(baseDir: string, rawLine: string): IgnoreRule | undefined {
@@ -74,7 +160,14 @@ function parseIgnoreLine(baseDir: string, rawLine: string): IgnoreRule | undefin
 	if (anchored) line = line.slice(1);
 	line = toSlashPath(line);
 	if (!line) return undefined;
-	return { baseDir, pattern: line, negated, dirOnly, hasSlash: line.includes("/"), anchored };
+	return {
+		baseDir,
+		pattern: line,
+		negated,
+		dirOnly,
+		hasSlash: line.includes("/"),
+		anchored,
+	};
 }
 
 async function readIgnoreRules(baseDir: string): Promise<IgnoreRule[]> {
@@ -89,27 +182,27 @@ async function readIgnoreRules(baseDir: string): Promise<IgnoreRule[]> {
 	}
 }
 
-async function appendIgnoreRulesForDirectory(
-	directory: string,
-	inherited: readonly IgnoreRule[],
-): Promise<IgnoreRule[]> {
-	const rules = await readIgnoreRules(directory);
-	return rules.length === 0 ? [...inherited] : [...inherited, ...rules];
+async function appendIgnoreRules(directory: string, inherited: readonly IgnoreRule[]): Promise<IgnoreRule[]> {
+	const local = await readIgnoreRules(directory);
+	return local.length === 0 ? [...inherited] : [...inherited, ...local];
 }
 
 async function collectIgnoreRulesToDirectory(cwd: string, directory: string): Promise<IgnoreRule[]> {
 	const resolvedCwd = resolve(cwd);
 	const resolvedDirectory = resolve(directory);
-	if (!isWithinPath(resolvedCwd, resolvedDirectory)) return [];
+	// Outside the session cwd (absolute foreign roots): load that directory's own ignore only.
+	if (!isWithinPath(resolvedCwd, resolvedDirectory)) {
+		return appendIgnoreRules(resolvedDirectory, []);
+	}
 
 	let current = resolvedCwd;
-	let rules: IgnoreRule[] = await appendIgnoreRulesForDirectory(current, []);
+	let rules = await appendIgnoreRules(current, []);
 	const rel = relativeSlash(resolvedCwd, resolvedDirectory);
 	if (rel === ".") return rules;
 
 	for (const segment of rel.split("/")) {
 		current = join(current, segment.split("/").join(sep));
-		rules = await appendIgnoreRulesForDirectory(current, rules);
+		rules = await appendIgnoreRules(current, rules);
 	}
 	return rules;
 }
@@ -130,68 +223,153 @@ function isIgnored(absolutePath: string, kind: PathKind, rules: readonly IgnoreR
 	return ignored;
 }
 
-function shouldSkipPath(
+function shouldSkip(
 	absolutePath: string,
 	kind: PathKind,
 	rules: readonly IgnoreRule[],
-	options: CollectPathOptions,
+	options: {
+		walkRoot: string;
+		includeHidden: boolean;
+		includeIgnored: boolean;
+		includeNoise: boolean;
+	},
 ): boolean {
-	const displayPath = formatPathForDisplay(absolutePath, options.cwd);
-	if (!options.includeHidden && hasHiddenPathSegment(displayPath)) return true;
-	if (!options.includeNoise && hasNoisePathSegment(displayPath)) return true;
+	// Hidden/noise are relative to the walk root — not the session cwd display path.
+	// Otherwise absolute roots under ~/.local (etc.) look entirely "hidden".
+	const rel = relativeSlash(options.walkRoot, absolutePath);
+	const underRoot = rel === "." || (!rel.startsWith("..") && !isAbsolute(rel));
+	const segmentPath = underRoot && rel !== "." ? rel : "";
+	if (!options.includeHidden && segmentPath.length > 0 && hasHiddenSegment(segmentPath)) return true;
+	if (!options.includeNoise && segmentPath.length > 0 && hasNoiseSegment(segmentPath)) return true;
 	return !options.includeIgnored && isIgnored(absolutePath, kind, rules);
 }
 
-function sortEntries(entries: TraversalEntry[]): TraversalEntry[] {
-	return entries.sort((a, b) => {
+function entryKind(stats: Stats): PathKind {
+	return stats.isDirectory() ? "dir" : "file";
+}
+
+function sortHits(hits: TraversalHit[]): TraversalHit[] {
+	return hits.sort((a, b) => {
 		if (a.type !== b.type) return a.type === "dir" ? -1 : 1;
 		return a.displayPath.localeCompare(b.displayPath);
 	});
 }
 
-async function readDirectoryNames(directory: string, cwd: string): Promise<string[]> {
+async function listNames(directory: string, cwd: string): Promise<string[]> {
 	try {
-		return await readdir(directory);
+		const names: string[] = [];
+		for await (const entry of await opendir(directory)) {
+			names.push(entry.name);
+		}
+		return names;
 	} catch {
 		throw new Error(`Cannot read directory: ${formatPathForDisplay(directory, cwd)}`);
 	}
 }
 
-export async function collectPaths(options: CollectPathOptions): Promise<TraversalEntry[]> {
-	const entries: TraversalEntry[] = [];
-	const entryByPath = new Map<string, TraversalEntry>();
-	const rootStats = await lstat(options.root);
-	const rootKind = entryKind(rootStats);
-	const rootDirectory = rootKind === "dir" ? options.root : dirname(options.root);
-	const rootRules = options.includeIgnored ? [] : await collectIgnoreRulesToDirectory(options.cwd, rootDirectory);
-
-	function pushEntry(absolutePath: string, stats: Stats, depth: number): TraversalEntry {
-		const entry = {
-			absolutePath,
-			displayPath: formatPathForDisplay(absolutePath, options.cwd),
-			type: entryKind(stats),
-			stats,
-			depth,
-		};
-		entries.push(entry);
-		entryByPath.set(absolutePath, entry);
-		return entry;
+/**
+ * Ignore-aware directory walk for structural scans.
+ * Budgets (files / source bytes / depth / elapsed) are separate from model output limits.
+ * Hitting a budget sets `result.limit` — not silent complete-tree success.
+ */
+export async function walkPaths(options: WalkOptions): Promise<TraversalResult> {
+	const budgets = mergeBudgets(options.budgets);
+	const includeRoot = options.includeRoot !== false;
+	const includeHidden = options.includeHidden === true;
+	const includeIgnored = options.includeIgnored === true;
+	const includeNoise = options.includeNoise === true;
+	const filesOnly = options.filesOnly !== false;
+	const started = Date.now();
+
+	const entries: TraversalHit[] = [];
+	let filesVisited = 0;
+	let sourceBytes = 0;
+	let limit: TraversalLimit | undefined;
+
+	const elapsed = () => Date.now() - started;
+
+	const budgetHit = (): TraversalLimit | undefined => {
+		if (options.signal?.aborted) return "cancelled";
+		if (elapsed() >= budgets.maxElapsedMs) return "maxElapsedMs";
+		if (filesVisited >= budgets.maxFiles) return "maxFiles";
+		if (sourceBytes > budgets.maxSourceBytes) return "maxSourceBytes";
+		return undefined;
+	};
+
+	const stopIfNeeded = (): boolean => {
+		const hit = budgetHit();
+		if (hit === undefined) return false;
+		limit = limit ?? hit;
+		return true;
+	};
+
+	async function pushFile(hit: TraversalHit): Promise<boolean> {
+		if (options.matchFile !== undefined && !options.matchFile(hit)) return true;
+		if (stopIfNeeded()) return false;
+		if (filesVisited >= budgets.maxFiles) {
+			limit = "maxFiles";
+			return false;
+		}
+		const nextBytes = sourceBytes + hit.stats.size;
+		// Allow the first file even if it alone exceeds the byte budget; report the limit.
+		if (filesVisited > 0 && nextBytes > budgets.maxSourceBytes) {
+			limit = "maxSourceBytes";
+			return false;
+		}
+		filesVisited += 1;
+		sourceBytes = nextBytes;
+		if (sourceBytes > budgets.maxSourceBytes) limit = "maxSourceBytes";
+		entries.push(hit);
+		const cont = await options.onFile?.(hit);
+		if (cont === false) return false;
+		return !stopIfNeeded();
 	}
 
-	if (options.includeRoot) pushEntry(options.root, rootStats, 0);
-	if (rootKind !== "dir") return entries;
+	const root = resolveExplorePath(options.cwd, options.root);
+	const rootStats = await lstat(root);
+	const rootKind = entryKind(rootStats);
+	const rootDir = rootKind === "dir" ? root : resolve(root, "..");
+	const walkRoot = rootKind === "dir" ? root : rootDir;
+	const skipOpts = { walkRoot, includeHidden, includeIgnored, includeNoise };
+	const rootRules = includeIgnored ? [] : await collectIgnoreRulesToDirectory(options.cwd, rootDir);
 
-	async function walkDirectory(directory: string, depth: number, rules: readonly IgnoreRule[]): Promise<number> {
-		if (options.maxDepth !== undefined && depth >= options.maxDepth) return 0;
+	if (includeRoot) {
+		const rootHit: TraversalHit = {
+			absolutePath: root,
+			displayPath: formatPathForDisplay(root, options.cwd),
+			type: rootKind,
+			stats: rootStats,
+			depth: 0,
+		};
+		if (rootKind === "file") {
+			await pushFile(rootHit);
+			return { entries, limit, filesVisited, sourceBytes, elapsedMs: elapsed() };
+		}
+		if (!filesOnly) entries.push(rootHit);
+	} else if (rootKind === "file") {
+		return { entries, limit, filesVisited, sourceBytes, elapsedMs: elapsed() };
+	}
 
-		const names = await readDirectoryNames(directory, options.cwd);
+	async function walkDir(directory: string, depth: number, rules: readonly IgnoreRule[]): Promise<void> {
+		if (stopIfNeeded()) return;
+		if (depth >= budgets.maxDepth) {
+			limit = limit ?? "maxDepth";
+			return;
+		}
 
-		const children: TraversalEntry[] = [];
+		const names = await listNames(directory, options.cwd);
+		const children: TraversalHit[] = [];
 		for (const name of names) {
-			const childPath = `${directory}/${name}`;
-			const stats = await lstat(childPath);
+			if (stopIfNeeded()) return;
+			const childPath = join(directory, name);
+			let stats: Stats;
+			try {
+				stats = await lstat(childPath);
+			} catch {
+				continue;
+			}
 			const kind = entryKind(stats);
-			if (shouldSkipPath(childPath, kind, rules, options)) continue;
+			if (shouldSkip(childPath, kind, rules, skipOpts)) continue;
 			children.push({
 				absolutePath: childPath,
 				displayPath: formatPathForDisplay(childPath, options.cwd),
@@ -201,26 +379,22 @@ export async function collectPaths(options: CollectPathOptions): Promise<Travers
 			});
 		}
 
-		for (const child of sortEntries(children)) {
-			entries.push(child);
-			entryByPath.set(child.absolutePath, child);
-			if (child.type !== "dir") continue;
-			const childRules = options.includeIgnored
-				? rules
-				: await appendIgnoreRulesForDirectory(child.absolutePath, rules);
-			const visibleChildren = await walkDirectory(child.absolutePath, child.depth, childRules);
-			if (visibleChildren === 0 && (options.maxDepth === undefined || child.depth < options.maxDepth)) {
-				child.empty = true;
+		for (const child of sortHits(children)) {
+			if (stopIfNeeded()) return;
+			if (child.type === "file") {
+				if (!(await pushFile(child))) return;
+				continue;
 			}
+			if (!filesOnly) entries.push(child);
+			if (child.depth >= budgets.maxDepth) {
+				limit = limit ?? "maxDepth";
+				continue;
+			}
+			const childRules = includeIgnored ? rules : await appendIgnoreRules(child.absolutePath, rules);
+			await walkDir(child.absolutePath, child.depth, childRules);
 		}
-
-		return children.length;
 	}
 
-	const visibleChildren = await walkDirectory(options.root, 0, rootRules);
-	const rootEntry = entryByPath.get(options.root);
-	if (rootEntry && visibleChildren === 0 && (options.maxDepth === undefined || options.maxDepth > 0)) {
-		rootEntry.empty = true;
-	}
-	return entries;
+	if (rootKind === "dir") await walkDir(root, 0, rootRules);
+	return { entries, limit, filesVisited, sourceBytes, elapsedMs: elapsed() };
 }

package/extensions/handoff/index.ts

@@ -6,7 +6,7 @@ import {
 	type ExtensionAPI,
 	serializeConversation,
 } from "@earendil-works/pi-coding-agent";
-import { prepareAutoreadMessage, type AutoreadDetails } from "../explore/autoread.ts";
+import { prepareAutoreadMessage, type AutoreadDetails } from "../../shared/autoread.ts";
 import { generateToolValidated, resolveCandidates } from "../../shared/model-fallback/index.ts";
 import { errorText } from "../../shared/text.ts";
 import { buildHandoffRequest, type HandoffDraft, handoffDraftFromToolInput, HANDOFF_TOOL } from "./model.ts";