@shanepadgett/tau-agent 0.27.0 → 0.28.0

package/extensions/explore/traverse.ts

@@ -1,40 +1,80 @@
 import type { Stats } from "node:fs";
 import { lstat, opendir, readFile } from "node:fs/promises";
-import { dirname, join, matchesGlob, resolve, sep } from "node:path";
-import { formatPathForDisplay, isWithinPath, relativeSlash, toSlashPath } from "./path-display.ts";
+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 interface CollectPathOptions {
+export type TraversalLimit = "maxFiles" | "maxSourceBytes" | "maxDepth" | "maxElapsedMs" | "cancelled";
+
+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;
-	maxEntries?: 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",
@@ -47,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 {
@@ -75,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[]> {
@@ -90,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;
 }
@@ -131,31 +223,43 @@ 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, limit: number | undefined): Promise<string[]> {
+async function listNames(directory: string, cwd: string): Promise<string[]> {
 	try {
 		const names: string[] = [];
 		for await (const entry of await opendir(directory)) {
 			names.push(entry.name);
-			if (limit !== undefined && names.length >= limit) break;
 		}
 		return names;
 	} catch {
@@ -163,46 +267,109 @@ async function readDirectoryNames(directory: string, cwd: string, limit: number
 	}
 }
 
-export async function collectPaths(options: CollectPathOptions): Promise<TraversalEntry[]> {
-	const entries: TraversalEntry[] = [];
-	const entryByPath = new Map<string, TraversalEntry>();
-	let inspectedEntries = 0;
-	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 (options.maxEntries !== undefined && inspectedEntries >= options.maxEntries) 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 remaining = options.maxEntries === undefined ? undefined : options.maxEntries - inspectedEntries;
-		const names = await readDirectoryNames(directory, options.cwd, remaining);
+	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) {
-			if (options.maxEntries !== undefined && inspectedEntries >= options.maxEntries) break;
-			const childPath = `${directory}/${name}`;
-			const stats = await lstat(childPath);
-			inspectedEntries += 1;
+			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),
@@ -212,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";

package/extensions/publish/index.ts

@@ -11,8 +11,6 @@ const WORKFLOW_NAME = "publish.yml";
 const WORKFLOW_WAIT_MS = 10 * 60_000;
 const POLL_INTERVAL_MS = 5_000;
 const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
-const CARGO_BUILD_TIMEOUT_MS = 15 * 60_000;
-const TAU_AST_SCRIPT = "packages/agent/scripts/package-tau-ast.ts";
 
 type Bump = "patch" | "minor" | "major";
 
@@ -68,8 +66,6 @@ async function publish(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promise<
 	if (!repo) throw new Error("No git repository found.");
 	if (repo.fileCount > 0)
 		throw new Error("Working tree is not clean. Commit or stash every change before publishing.");
-	if (process.platform !== "darwin" || process.arch !== "arm64")
-		throw new Error(`/publish requires darwin-arm64; this host is ${process.platform}-${process.arch}.`);
 	await run(pi, ctx, "gh", ["auth", "status"], repo.root, DEFAULT_COMMAND_TIMEOUT_MS);
 	await run(pi, ctx, "npm", ["run", "check:package-sources"], repo.root, DEFAULT_COMMAND_TIMEOUT_MS);
 
@@ -129,87 +125,24 @@ async function completePublish(
 		progress?.update("write package versions");
 		await writeReleaseVersion(root, manifests, version);
 	}
-	try {
-		progress?.update("build tau-ast darwin-arm64");
-		await run(
-			pi,
-			ctx,
-			"cargo",
-			[
-				"build",
-				"--release",
-				"--locked",
-				"--target",
-				"aarch64-apple-darwin",
-				"--manifest-path",
-				"packages/agent/native/tau-ast/Cargo.toml",
-			],
-			root,
-			CARGO_BUILD_TIMEOUT_MS,
-		);
-		progress?.update("stage tau-ast");
-		await run(
-			pi,
-			ctx,
-			process.execPath,
-			["--experimental-strip-types", TAU_AST_SCRIPT, "stage"],
-			root,
-			DEFAULT_COMMAND_TIMEOUT_MS,
-		);
-		progress?.update("smoke test tau-ast");
-		await run(
-			pi,
-			ctx,
-			process.execPath,
-			["--experimental-strip-types", TAU_AST_SCRIPT, "smoke"],
-			root,
-			DEFAULT_COMMAND_TIMEOUT_MS,
-		);
-		progress?.update("npm pack --dry-run @shanepadgett/tau-tui");
-		await run(
-			pi,
-			ctx,
-			"npm",
-			["pack", "--dry-run", "--workspace", "@shanepadgett/tau-tui"],
-			root,
-			DEFAULT_COMMAND_TIMEOUT_MS,
-		);
-		progress?.update("npm pack --dry-run @shanepadgett/tau-agent");
-		await run(
-			pi,
-			ctx,
-			"npm",
-			["pack", "--dry-run", "--workspace", "@shanepadgett/tau-agent"],
-			root,
-			DEFAULT_COMMAND_TIMEOUT_MS,
-		);
-		progress?.update("verify packed tau-ast");
-		await run(
-			pi,
-			ctx,
-			process.execPath,
-			["--experimental-strip-types", TAU_AST_SCRIPT, "verify-pack"],
-			root,
-			DEFAULT_COMMAND_TIMEOUT_MS,
-		);
-	} finally {
-		await run(
-			pi,
-			ctx,
-			process.execPath,
-			["--experimental-strip-types", TAU_AST_SCRIPT, "clean"],
-			root,
-			DEFAULT_COMMAND_TIMEOUT_MS,
-		);
-	}
-
-	const trackedNativeFiles = await git.run(["ls-files", "--", "packages/agent/native-bin"], { cwd: root });
-	const stagedNativeFiles = await git.run(["diff", "--cached", "--name-only", "--", "packages/agent/native-bin"], {
-		cwd: root,
-	});
-	if (trackedNativeFiles || stagedNativeFiles)
-		throw new Error("Release blocked: packages/agent/native-bin/ contains tracked or staged files.");
-
+	progress?.update("npm pack --dry-run @shanepadgett/tau-tui");
+	await run(
+		pi,
+		ctx,
+		"npm",
+		["pack", "--dry-run", "--workspace", "@shanepadgett/tau-tui"],
+		root,
+		DEFAULT_COMMAND_TIMEOUT_MS,
+	);
+	progress?.update("npm pack --dry-run @shanepadgett/tau-agent");
+	await run(
+		pi,
+		ctx,
+		"npm",
+		["pack", "--dry-run", "--workspace", "@shanepadgett/tau-agent"],
+		root,
+		DEFAULT_COMMAND_TIMEOUT_MS,
+	);
 	if (tag) {
 		progress?.update("git add release files");
 		await git.run(["add", ...PACKAGE_PATHS, LOCKFILE_PATH], { cwd: root });

package/extensions/publish/publish-ui.ts

@@ -4,12 +4,8 @@ import { ToolPanel } from "@shanepadgett/tau-tui";
 
 const RELEASE_STEPS = [
 	"write package versions",
-	"build tau-ast darwin-arm64",
-	"stage tau-ast",
-	"smoke test tau-ast",
 	"npm pack --dry-run @shanepadgett/tau-tui",
 	"npm pack --dry-run @shanepadgett/tau-agent",
-	"verify packed tau-ast",
 	"git add release files",
 	"git commit",
 	"git tag",

package/extensions/soul/README.md

@@ -1,19 +1,22 @@
 # Soul
 
-Soul adds Rok's caveman voice and old-code senior judgment to Pi's native assistant prompt.
+Soul shapes how Tau works and talks by adding two independent sections to Pi's native assistant prompt:
+
+- **ponytail** — a lazy-senior-dev build ethos: do the smallest correct thing, reuse before writing, YAGNI, fix bugs at the root, never cut validation, security, or accessibility.
+- **caveman** — a terse communication style: drop filler, keep technical substance exact, quote the shortest decisive line, spell out anything where brevity would risk safety.
 
 Pi continues to own tool guidance, project instructions, skills, documentation paths, custom prompts, and working-directory context.
 
-Disable it in Tau settings:
+Toggle each section in Tau settings (both on by default):
 
 ```json
 {
   "extensions": {
-    "soul": { "enabled": false }
+    "soul": { "ponytail": true, "caveman": false }
   }
 }
 ```
 
-The setting takes effect on session start.
+Settings take effect on session start.
 
 After changing this extension, run `/reload` before testing the new behavior.

package/extensions/soul/index.ts

@@ -1,17 +1,23 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
-import { ROK_SOUL } from "./prompt.ts";
+import { CAVEMAN_STYLE, PONYTAIL_ETHOS } from "./prompt.ts";
 import soulSettings from "./settings.ts";
 
 export default function soulExtension(pi: ExtensionAPI): void {
-	let enabled = true;
+	let ponytail = true;
+	let caveman = true;
 
 	pi.on("session_start", async (_event, ctx) => {
-		enabled = (await loadTauExtensionSettings(ctx, soulSettings)).enabled;
+		const settings = await loadTauExtensionSettings(ctx, soulSettings);
+		ponytail = settings.ponytail;
+		caveman = settings.caveman;
 	});
 
 	pi.on("before_agent_start", (event) => {
-		if (!enabled) return undefined;
-		return { systemPrompt: `${event.systemPrompt}\n\n${ROK_SOUL}` };
+		const sections: string[] = [];
+		if (ponytail) sections.push(PONYTAIL_ETHOS);
+		if (caveman) sections.push(CAVEMAN_STYLE);
+		if (sections.length === 0) return undefined;
+		return { systemPrompt: [event.systemPrompt, ...sections].join("\n\n") };
 	});
 }