@shanepadgett/tau-agent 0.33.1 → 0.35.0

package/extensions/runtime-context/context.ts

@@ -1,5 +1,4 @@
 import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
 import { type Dirent, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 
@@ -19,13 +18,6 @@ export function freezeRuntimeContext(cwd: string): RuntimeContext {
 	return { cwd: cwd.replace(/\\/g, "/"), rootSnapshot: listRootSnapshot(cwd) };
 }
 
-export function formatLocalDateKey(date: Date): string {
-	const year = date.getFullYear();
-	const month = String(date.getMonth() + 1).padStart(2, "0");
-	const day = String(date.getDate()).padStart(2, "0");
-	return `${year}-${month}-${day}`;
-}
-
 export function formatLocalDisplayDate(date: Date): string {
 	const months = [
 		"January",
@@ -44,12 +36,6 @@ export function formatLocalDisplayDate(date: Date): string {
 	return `${date.getDate()} ${months[date.getMonth()]} ${date.getFullYear()}`;
 }
 
-export function fingerprintRuntimeSnapshot(context: RuntimeContext): string {
-	return createHash("sha256")
-		.update(JSON.stringify({ version: 1, cwd: context.cwd, paths: context.rootSnapshot }))
-		.digest("hex");
-}
-
 export function formatRuntimeContextMessage(displayDate: string, rootSnapshot: readonly string[] | undefined): string {
 	const blocks = [`Current local date: ${displayDate}`];
 	if (rootSnapshot?.length) {
@@ -58,42 +44,60 @@ export function formatRuntimeContextMessage(displayDate: string, rootSnapshot: r
 	return blocks.join("\n");
 }
 
-function listRootSnapshot(cwd: string): string[] {
-	const root = resolve(cwd);
+function visibleRootEntries(root: string): SnapshotEntry[] {
 	const rootEntries = listSnapshotEntries(root, ".");
 	const ignoredRootPaths = gitIgnoredPaths(
 		root,
 		rootEntries.map((entry) => entry.path),
 	);
-	const visibleRootEntries = rootEntries.filter(
+	return rootEntries.filter(
 		(entry) => !isAlwaysHiddenFromSnapshot(entry.dirent.name) && !ignoredRootPaths.has(entry.path),
 	);
-	const childEntriesByParent = new Map<string, SnapshotEntry[]>();
-	const childPaths: string[] = [];
+}
 
-	for (const entry of visibleRootEntries) {
+function childEntriesByParent(
+	root: string,
+	roots: readonly SnapshotEntry[],
+): {
+	byParent: Map<string, SnapshotEntry[]>;
+	ignoredChildPaths: Set<string>;
+} {
+	const byParent = new Map<string, SnapshotEntry[]>();
+	const childPaths: string[] = [];
+	for (const entry of roots) {
 		if (!entry.dirent.isDirectory()) continue;
 		const childEntries = listSnapshotEntries(root, entry.path).filter(
 			(childEntry) => !isAlwaysHiddenFromSnapshot(childEntry.dirent.name),
 		);
-		childEntriesByParent.set(entry.path, childEntries);
+		byParent.set(entry.path, childEntries);
 		childPaths.push(...childEntries.map((childEntry) => childEntry.path));
 	}
+	return { byParent, ignoredChildPaths: gitIgnoredPaths(root, childPaths) };
+}
 
-	const ignoredChildPaths = gitIgnoredPaths(root, childPaths);
+function collectSnapshotPaths(
+	roots: readonly SnapshotEntry[],
+	byParent: Map<string, SnapshotEntry[]>,
+	ignoredChildPaths: ReadonlySet<string>,
+): string[] {
 	const paths: string[] = [];
-
-	for (const entry of visibleRootEntries) {
+	for (const entry of roots) {
 		pushSnapshotPath(paths, entry);
 		if (paths.length >= ROOT_SNAPSHOT_MAX_PATHS) break;
-
-		for (const childEntry of childEntriesByParent.get(entry.path) ?? []) {
+		for (const childEntry of byParent.get(entry.path) ?? []) {
 			if (ignoredChildPaths.has(childEntry.path)) continue;
 			pushSnapshotPath(paths, childEntry);
 			if (paths.length >= ROOT_SNAPSHOT_MAX_PATHS) break;
 		}
 	}
+	return paths;
+}
 
+function listRootSnapshot(cwd: string): string[] {
+	const root = resolve(cwd);
+	const roots = visibleRootEntries(root);
+	const children = childEntriesByParent(root, roots);
+	const paths = collectSnapshotPaths(roots, children.byParent, children.ignoredChildPaths);
 	return paths.length === ROOT_SNAPSHOT_MAX_PATHS ? [...paths, "..."] : paths;
 }
 

package/extensions/script-runner/README.md

@@ -1,7 +1,7 @@
 # Script Runner
 
-Gives the agent a first-class `script_runner` tool for running Python 3 and TypeScript instead of falling back to bash. The agent picks whichever language is more efficient for the task.
+Gives the agent a first-class `script_runner` tool for running Python 3, Node.js, and Deno scripts instead of falling back to bash. The agent picks whichever runtime is more efficient for the task.
 
 When a run fails, the tool keeps the script and returns a `scriptId`. The agent retries with targeted `{oldText, newText}` edits against what it just wrote instead of resending the whole script, saving output tokens and keeping duplicate scripts out of context. Only the source the agent already sent is referenced; no file path is exposed.
 
-Languages are detected from the environment: Python 3 via `python3`, TypeScript via Node with `--experimental-strip-types` (Node 22.6 or newer). The tool registers only the languages actually available and is hidden from the prompt entirely when neither is present.
+Runtimes are detected from the environment: Python 3 via `python3`, Node via the current process when Node is 22.6 or newer (`node --experimental-strip-types`), Deno via `deno` (`deno run -A`). The `node` language is the local Node.js runtime with full Node APIs; scripts may be TypeScript with erasable syntax or plain JavaScript. The `deno` language is the local Deno runtime with full permissions and native TypeScript/JavaScript. The tool registers only the runtimes actually available and is hidden from the prompt entirely when none are present.

package/extensions/script-runner/index.ts

@@ -16,11 +16,12 @@ import {
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
-type Language = "python3" | "typescript";
+type Language = "python3" | "node" | "deno";
 
 interface Runtimes {
 	python3: string | undefined;
-	typescript: string | undefined;
+	node: string | undefined;
+	deno: string | undefined;
 }
 
 interface StoredScript {
@@ -40,15 +41,34 @@ function detectRuntimes(): Runtimes {
 		// runtime not installed
 	}
 	const [major, minor] = process.versions.node.split(".").map(Number);
-	let typescript: string | undefined;
+	let node: string | undefined;
 	if (major > 22 || (major === 22 && minor >= 6)) {
-		typescript = process.execPath;
+		node = process.execPath;
 	}
-	return { python3, typescript };
+	let deno: string | undefined;
+	try {
+		execFileSync("deno", ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
+		deno = "deno";
+	} catch {
+		// runtime not installed
+	}
+	return { python3, node, deno };
 }
 
 function capitalize(lang: Language): string {
-	return lang === "python3" ? "Python 3" : "TypeScript";
+	if (lang === "python3") return "Python 3";
+	if (lang === "node") return "Node";
+	return "Deno";
+}
+
+function formatLangList(langs: readonly Language[]): string {
+	const names = langs.map(capitalize);
+	if (names.length <= 2) return names.join(" or ");
+	return `${names.slice(0, -1).join(", ")}, or ${names[names.length - 1]}`;
+}
+
+function languageLabel(lang: string): string {
+	return lang === "node" ? "node (Node.js)" : lang;
 }
 
 function newScriptId(): string {
@@ -65,9 +85,7 @@ function applyEdits(source: string, edits: ReadonlyArray<{ oldText: string; newT
 	for (const edit of edits) {
 		const idx = next.indexOf(edit.oldText);
 		if (idx === -1) {
-			throw new Error(
-				"An edits oldText was not found in the script. Copy the exact text from the script you wrote.",
-			);
+			throw new Error("edits oldText not found. Copy exact text from the script you wrote.");
 		}
 		next = next.slice(0, idx) + edit.newText + next.slice(idx + edit.oldText.length);
 	}
@@ -90,14 +108,64 @@ function renderEditsPreview(edits: ReadonlyArray<{ oldText: string; newText: str
 		.join("\n");
 }
 
+function resolveScriptSource(
+	scripts: Map<string, StoredScript>,
+	language: Language,
+	params: {
+		script?: string;
+		scriptId?: string;
+		edits?: ReadonlyArray<{ oldText: string; newText: string }>;
+	},
+): { scriptId: string; source: string } {
+	const edits = params.edits;
+	if (edits && edits.length > 0) {
+		const scriptId = params.scriptId;
+		if (!scriptId) throw new Error("edits require scriptId from the failed run.");
+		const stored = scripts.get(scriptId);
+		if (!stored) throw new Error(`No stored script for scriptId ${scriptId}. Evicted; resend full script.`);
+		if (stored.language !== language) {
+			throw new Error(`Language mismatch: scriptId ${scriptId} is ${stored.language}, not ${language}.`);
+		}
+		return { scriptId, source: applyEdits(stored.source, edits) };
+	}
+	if (typeof params.script !== "string" || params.script.length === 0) {
+		throw new Error("Provide script, or edits + scriptId.");
+	}
+	return { scriptId: params.scriptId ?? newScriptId(), source: params.script };
+}
+
+function formatTruncatedTail(text: string): { body: string; note: string } {
+	const trunc = truncateTail(text, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
+	const note = trunc.truncated
+		? `\n\n[output truncated: kept tail ${trunc.outputLines} / ${trunc.totalLines} lines]`
+		: "";
+	return { body: trunc.content, note };
+}
+
+function successScriptResult(stdout: string): { content: [{ type: "text"; text: string }]; details: undefined } {
+	const { body, note } = formatTruncatedTail(stdout.trim());
+	const out = body.trim();
+	return {
+		content: [{ type: "text", text: out ? `${out}${note}` : `(no output)${note}` }],
+		details: undefined,
+	};
+}
+
+function throwScriptFailure(scriptId: string, result: { stdout: string; stderr: string }): never {
+	const diag = result.stderr.trim() || result.stdout.trim();
+	const { body, note } = formatTruncatedTail(diag);
+	const detail = body ? `${body}${note}\n\n` : "";
+	throw new Error(`${detail}scriptId: ${scriptId}`);
+}
+
 export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 	const runtimes = detectRuntimes();
-	const detected = (["python3", "typescript"] as const).filter(
-		(lang): lang is Language => (lang === "python3" ? runtimes.python3 : runtimes.typescript) !== undefined,
+	const detected = (["python3", "node", "deno"] as const).filter(
+		(lang): lang is Language => runtimes[lang] !== undefined,
 	);
 	if (detected.length === 0) return;
 
-	const langPhrase = detected.map(capitalize).join(" or ");
+	const langPhrase = formatLangList(detected);
 
 	const scripts = new Map<string, StoredScript>();
 	let tempDir: string | undefined;
@@ -112,14 +180,13 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 	}
 
 	function resolveCommand(language: Language): string {
-		if (language === "python3") {
-			const cmd = runtimes.python3;
-			if (!cmd) throw new Error("Python 3 is not available on this machine.");
-			return cmd;
+		const cmd = runtimes[language];
+		if (cmd) return cmd;
+		if (language === "python3") throw new Error("Python 3 is not available on this machine.");
+		if (language === "node") {
+			throw new Error("Node unavailable (needs Node >= 22.6 with --experimental-strip-types).");
 		}
-		const cmd = runtimes.typescript;
-		if (!cmd) throw new Error("TypeScript is not available (requires Node >= 22.6).");
-		return cmd;
+		throw new Error("Deno is not available on this machine.");
 	}
 
 	async function ensureTempDir(): Promise<string> {
@@ -138,7 +205,12 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 		const dir = await ensureTempDir();
 		const file = join(dir, language === "python3" ? "_run.py" : "_run.ts");
 		await writeFile(file, source, "utf8");
-		const args = language === "python3" ? [file] : ["--experimental-strip-types", file];
+		const args =
+			language === "python3"
+				? [file]
+				: language === "node"
+					? ["--experimental-strip-types", file]
+					: ["run", "-A", file];
 		const result = await pi.exec(command, args, { cwd, signal, timeout: TIMEOUT_MS });
 		return {
 			...result,
@@ -149,13 +221,13 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 
 	const paramsSchema = Type.Object(
 		{
-			language: StringEnum(detected, { description: "Execution language available on this machine." }),
+			language: StringEnum(detected, {
+				description: "Execution runtime.",
+			}),
 			script: Type.Optional(
-				Type.String({ description: "Full script source for a new run. Omit when retrying with edits." }),
-			),
-			scriptId: Type.Optional(
-				Type.String({ description: "scriptId returned by a failed run. Required when retrying with edits." }),
+				Type.String({ description: "Full source for a new run. Omit when retrying with edits." }),
 			),
+			scriptId: Type.Optional(Type.String({ description: "From a failed run. Required with edits." })),
 			edits: Type.Optional(
 				Type.Array(
 					Type.Object({
@@ -163,8 +235,7 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 						newText: Type.String({ description: "Replacement text." }),
 					}),
 					{
-						description:
-							"Targeted oldText/newText patches applied to the stored script before rerun. Prefer this over resending the whole script.",
+						description: "Patches applied to the stored script before rerun.",
 					},
 				),
 			),
@@ -172,15 +243,26 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 		{ additionalProperties: false },
 	);
 
+	const runtimeNotes = [
+		detected.includes("node")
+			? "language=node: local Node.js via node --experimental-strip-types (not tsc/ts-node)."
+			: undefined,
+		detected.includes("deno") ? "language=deno: local Deno via deno run -A." : undefined,
+	].filter((note): note is string => note !== undefined);
+
 	const tool = defineTool<typeof paramsSchema, undefined>({
 		name: "script_runner",
 		label: "Script Runner",
-		description: `Run a ${langPhrase} script in the project working directory and return its output. On a non-zero exit, returns a scriptId; retry by sending targeted {oldText,newText} edits against the script you already wrote (same language + scriptId) instead of resending the whole script. Available on this machine: ${langPhrase}.`,
-		promptSnippet: `Run ${langPhrase} scripts; fix failures with targeted edits instead of rewriting the whole script.`,
+		description: [
+			`Run a ${langPhrase} script in the project cwd and return stdout.`,
+			...runtimeNotes,
+			"On non-zero exit: result includes scriptId. Retry with same language + scriptId + edits [{oldText,newText}]; do not resend the full script unless the approach is wrong.",
+			`Available: ${langPhrase}.`,
+		].join("\n"),
+		promptSnippet: `Run ${langPhrase} scripts; on failure retry with edits + scriptId.`,
 		promptGuidelines: [
-			`Prefer script_runner over bash for ${langPhrase} when computation, data handling, or bulk file work is cleaner than chaining built-in tools.`,
-			`When script_runner fails, do not resend the full script. Call script_runner again with the same language, the returned scriptId, and an edits array of {oldText,newText} patches against the script you just wrote. Only resend a full script if the approach itself was wrong.`,
-			`script_runner never exposes the script file path, and you already know the script you sent. Never try to read it back.`,
+			`Prefer script_runner over bash for ${langPhrase} when computation, data handling, or bulk file work is cleaner than chaining tools.`,
+			"script_runner never exposes the script path; you already have the source. Never try to read it back.",
 		],
 		parameters: paramsSchema,
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
@@ -188,65 +270,23 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 			if (signal?.aborted) {
 				return { content: [{ type: "text", text: "Cancelled." }], details: undefined };
 			}
-
 			const command = resolveCommand(language);
-			const edits = params.edits;
-			let scriptId: string | undefined = params.scriptId;
-			let source: string;
-
-			if (edits && edits.length > 0) {
-				if (!scriptId) throw new Error("edits require the scriptId returned by the failed run.");
-				const stored = scripts.get(scriptId);
-				if (!stored) {
-					throw new Error(
-						`No stored script for scriptId ${scriptId}. It may have been evicted; resend the full script.`,
-					);
-				}
-				if (stored.language !== language) {
-					throw new Error(`Language mismatch: scriptId ${scriptId} is ${stored.language}, not ${language}.`);
-				}
-				source = applyEdits(stored.source, edits);
-			} else {
-				if (typeof params.script !== "string" || params.script.length === 0) {
-					throw new Error("Provide a script for a new run, or edits + scriptId to retry.");
-				}
-				source = params.script;
-				if (!scriptId) scriptId = newScriptId();
-			}
-
+			const { scriptId, source } = resolveScriptSource(scripts, language, params);
 			remember(scriptId, { language, source });
-			await onUpdate?.({ content: [{ type: "text", text: `Running ${language}...` }], details: undefined });
-
+			await onUpdate?.({
+				content: [{ type: "text", text: `Running ${languageLabel(language)}...` }],
+				details: undefined,
+			});
 			const result = await runScript(language, command, source, ctx.cwd, signal);
 			if (result.code === 0 && !result.killed) {
 				scripts.delete(scriptId);
-				const trunc = truncateTail(result.stdout.trim(), {
-					maxLines: DEFAULT_MAX_LINES,
-					maxBytes: DEFAULT_MAX_BYTES,
-				});
-				const out = trunc.content.trim();
-				const note = trunc.truncated
-					? `\n\n[output truncated: kept tail ${trunc.outputLines} / ${trunc.totalLines} lines]`
-					: "";
-				return {
-					content: [{ type: "text", text: out ? `${out}${note}` : `(no output)${note}` }],
-					details: undefined,
-				};
+				return successScriptResult(result.stdout);
 			}
-
-			const diag = result.stderr.trim() || result.stdout.trim();
-			const trunc = truncateTail(diag, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
-			const note = trunc.truncated
-				? `\n\n[output truncated: kept tail ${trunc.outputLines} / ${trunc.totalLines} lines]`
-				: "";
-			const detail = trunc.content ? `${trunc.content}${note}\n\n` : "";
-			throw new Error(
-				`${detail}scriptId: ${scriptId}\nRetry with edits: [{oldText,newText}] using the same language and scriptId; do not resend the full script.`,
-			);
+			throwScriptFailure(scriptId, result);
 		},
 		renderCall(args, theme, context) {
 			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-			const header = `${theme.fg("toolTitle", theme.bold("script_runner"))} ${theme.fg("muted", args.language)}`;
+			const header = `${theme.fg("toolTitle", theme.bold("script_runner"))} ${theme.fg("muted", languageLabel(args.language))}`;
 			const edits = args.edits;
 			const body =
 				edits && edits.length > 0

package/extensions/silent-command-runner/index.ts

@@ -146,25 +146,11 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 		attentionHoldId = undefined;
 	});
 
-	async function runChangedCommands(
-		cwd: string,
-		turnStart: number,
+	async function collectCommandFailures(
+		projectRoot: string,
+		changed: readonly CommandConfig[],
 		notify: (message: string, type?: "info" | "warning" | "error") => void,
-	): Promise<void> {
-		if (!settings.enabled || settings.commands.length === 0) return;
-
-		const projectRoot = await resolveProjectRoot(cwd);
-		const paths = await walkFiles(projectRoot);
-		const changed = await scanChangedCommands(projectRoot, settings.commands, paths, turnPaths, turnStart);
-		if (!sessionActive || changed.length === 0) return;
-
-		notify(
-			changed.length === 1
-				? `silent-command-runner: running ${changed[0]?.name ?? "command"}`
-				: `silent-command-runner: running ${changed.length} commands`,
-			"info",
-		);
-
+	): Promise<FailedCommandDetails[] | undefined> {
 		const failures: FailedCommandDetails[] = [];
 		const controller = new AbortController();
 		abortController = controller;
@@ -175,32 +161,61 @@ export default function silentCommandRunnerExtension(pi: ExtensionAPI): void {
 				try {
 					result = await runCommand(pi, projectRoot, command, controller.signal, settings.maxOutputBytes);
 				} catch (error: unknown) {
-					if (controller.signal.aborted) return;
+					if (controller.signal.aborted) return undefined;
 					throw error;
 				}
-				if (controller.signal.aborted) return;
+				if (controller.signal.aborted) return undefined;
 				if (result.code !== 0 || result.killed) failures.push(result);
 			}
 		} finally {
 			if (abortController === controller) abortController = undefined;
 		}
-		if (!sessionActive) return;
+		return failures;
+	}
 
+	function reportCommandResults(
+		changed: readonly CommandConfig[],
+		failures: readonly FailedCommandDetails[],
+		notify: (message: string, type?: "info" | "warning" | "error") => void,
+	): void {
 		const failedNames = new Set(failures.map((failure) => failure.name));
 		const passed = changed.filter((command) => !failedNames.has(command.name));
 		if (passed.length > 0) notify(`silent-command-runner: passed ${formatCommandNames(passed)}`, "info");
 		if (failures.length === 0) return;
-
 		pi.sendMessage<FailureDetails>(
 			{
 				customType: MESSAGE_TYPE,
 				content: formatAgentMessage(failures),
 				display: true,
-				details: { failed: failures },
+				details: { failed: [...failures] },
 			},
 			{ deliverAs: "followUp" },
 		);
 	}
+
+	async function runChangedCommands(
+		cwd: string,
+		turnStart: number,
+		notify: (message: string, type?: "info" | "warning" | "error") => void,
+	): Promise<void> {
+		if (!settings.enabled || settings.commands.length === 0) return;
+
+		const projectRoot = await resolveProjectRoot(cwd);
+		const paths = await walkFiles(projectRoot);
+		const changed = await scanChangedCommands(projectRoot, settings.commands, paths, turnPaths, turnStart);
+		if (!sessionActive || changed.length === 0) return;
+
+		notify(
+			changed.length === 1
+				? `silent-command-runner: running ${changed[0]?.name ?? "command"}`
+				: `silent-command-runner: running ${changed.length} commands`,
+			"info",
+		);
+
+		const failures = await collectCommandFailures(projectRoot, changed, notify);
+		if (failures === undefined || !sessionActive) return;
+		reportCommandResults(changed, failures, notify);
+	}
 }
 
 function normalizeSettings(value: typeof silentCommandRunnerSettings.defaults): Settings {

package/extensions/soul/README.md

@@ -3,7 +3,7 @@
 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.
+- **simplified** — Simplified Technical English (ASD-STE100): use short sentences and paragraphs, explain jargon, and shape plans and conversations in small chunks.
 
 Pi continues to own tool guidance, project instructions, skills, documentation paths, custom prompts, and working-directory context.
 
@@ -12,7 +12,7 @@ Toggle each section in Tau settings (both on by default):
 ```json
 {
   "extensions": {
-    "soul": { "ponytail": true, "caveman": false }
+    "soul": { "ponytail": true, "simplified": false }
   }
 }
 ```

package/extensions/soul/index.ts

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

package/extensions/soul/prompt.ts

@@ -26,18 +26,14 @@ Non-trivial logic leaves one runnable check behind: the smallest thing that fail
 
 Mark a deliberate simplification that cuts a real corner with a named ceiling and its upgrade path.`;
 
-export const CAVEMAN_STYLE = `## Communication style
+export const SIMPLIFIED_TECHNICAL_ENGLISH = `## Communication style
 
-Primary directive: simple, terse, human-like conversation. Talk to the human the way a person does, not the way a document reads. A wall of text does not get read. Outside a plan or a file you were asked to write, keep replies short. All technical substance stays. Only fluff dies.
+Use Simplified Technical English (ASD-STE100) when you communicate with the user. Assume the user is tired and has limited capacity for jargon.
 
-Drop articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), and hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). No emoji, no decorative tables, no tool-call narration. Do not dump long raw logs. Quote the shortest decisive line.
+Use short sentences and short paragraphs. Explain one idea at a time. Prefer common words, active voice, and concrete explanations. Avoid idioms, vague language, filler, and unexplained abbreviations. Explain unavoidable jargon in plain words when you first use it.
 
-Standard well-known acronyms OK (DB, API, HTTP). Never invent abbreviations (cfg, impl, req, fn). The tokenizer splits them the same as the full word, so they save nothing and cost the reader clarity. No causal arrows. Technical terms, code blocks, and error strings stay exact and verbatim.
+Keep technical content exact. Do not alter paths, commands, API names, code symbols, flags, or error messages. Explain what they mean around the exact text.
 
-Preserve the user's language. Compress the style, not the language.
+Work in small chunks. Answer the immediate question first. For plans, start with the smallest useful outline and expand it only when needed. Expect plans to change after each decision. Do not write a novel before the plan has been checked.
 
-No self-reference. Never name or announce the style.
-
-No filler emphasis or manufactured insight. Skip "here's the thing", "that's the part that really matters", "and that's the key". Skip "not just X, it's Y" and "it's not X, it's Y" framing. Skip grand closers that restate the point as a lesson. State the fact, the mechanism, or the next step, then stop.
-
-Full clear sentences, terse style dropped, for security warnings, irreversible-action confirmations, multi-step sequences where order matters, and anywhere compression would create ambiguity. Resume terse after.`;
+Keep responses short enough to scan, while giving enough explanation for the user to understand the reason and next step. Do not replace explanations with fragments just to be brief. Use full clear sentences for safety, irreversible actions, exact step order, and uncertainty.`;

package/extensions/soul/settings.ts

@@ -3,14 +3,17 @@ import { defineTauExtensionSettings } from "../../shared/settings/define.ts";
 
 export default defineTauExtensionSettings({
 	key: "soul",
-	defaults: { ponytail: true as boolean, caveman: true as boolean },
+	defaults: { ponytail: true as boolean, simplified: true as boolean },
 	schema: Type.Object(
 		{
 			ponytail: Type.Optional(
 				Type.Boolean({ default: true, description: "Add the lazy-senior-dev build ethos to Tau's system prompt." }),
 			),
-			caveman: Type.Optional(
-				Type.Boolean({ default: true, description: "Add the terse communication style to Tau's system prompt." }),
+			simplified: Type.Optional(
+				Type.Boolean({
+					default: true,
+					description: "Add Simplified Technical English and small-chunk explanations to Tau's system prompt.",
+				}),
 			),
 		},
 		{ additionalProperties: false },