@shanepadgett/tau-agent 0.12.0 → 0.14.0

package/docs/subagents.md

@@ -2,6 +2,15 @@
 
 Tau's `subagent` tool delegates one focused task to an isolated child Pi session. You can add your own agent definitions without writing TypeScript.
 
+Each fresh call returns a thread ID. Continue that thread when feedback or follow-up work depends on the child's prior reads and reasoning:
+
+```text
+subagent({ agent: "scout", task: "Trace configuration loading" })
+subagent({ thread: "thread-1", task: "Now check whether this proposed fix covers every caller" })
+```
+
+Retained threads keep their child conversation and tool results for the current parent session. Start fresh for unrelated work or when earlier context is stale or oversized. Tau keeps up to 16 threads and evicts the least recently used idle thread when needed.
+
 ## Where definitions live
 
 | Scope | Path | Use when |
@@ -46,8 +55,10 @@ Named tools and configured models must exist in the normally loaded child Pi env
 
 - Children use the parent's cwd and inherit model/thinking unless the definition overrides them.
 - Children do not receive the parent conversation.
+- Follow-up calls reuse the retained child's conversation, model, thinking level, tools, and cwd.
 - Children load only the extensions that own their declared tools. Unrelated extension hooks do not run in child sessions.
 - At most four children run at once; extra calls wait in order.
+- Calls to the same retained thread run one at a time.
 - Returned text is capped (50 KB / 2,000 lines); full truncated output is saved to a private temp file.
 
 ## Built-ins

package/extensions/context/README.md

@@ -2,7 +2,7 @@
 
 Context stores reusable repository work scopes in `.pi/contexts`. Folder names become selector tabs, TOML files become concepts, and TOML sections become selectable entries.
 
-Use `/context` to select entries and inject their files through Tau autoread. Use `/context-sync` to reconcile affected scopes from the current Git changes. Tau validates context membership after agent turns and asks the agent to sync uncovered changed files or stale references automatically.
+Use `/context` to select entries. Entry `files` are injected through Tau autoread. Entry `anchors` supply lazy navigation paths that the agent can grep or read in ranges when needed. Use `/context-sync` to reconcile affected scopes from the current Git changes. Tau validates both file classes as context membership after agent turns and asks the agent to sync uncovered changed files or stale references automatically.
 
 Validation is disabled by default. Enable it globally or per project in Tau settings:
 
@@ -30,6 +30,7 @@ files = ["src/player/input.ts"]
 [movement]
 description = "Player locomotion and collision"
 files = ["src/player/movement.ts"]
+anchors = ["src/runtime/fetch-handler.ts"]
 ```
 
-For example, `.pi/contexts/gameplay/player.toml` appears in the `gameplay` tab as the `Player` concept with `input` and `movement` entries.
+For example, `.pi/contexts/gameplay/player.toml` appears in the `gameplay` tab as the `Player` concept with `input` and `movement` entries. When `movement` is selected, Tau autoreads `src/player/movement.ts` and lists `src/runtime/fetch-handler.ts` as an unloaded anchor. If one selected entry marks a path as a file and another marks it as an anchor, autoread wins.

package/extensions/context/definitions.ts

@@ -13,6 +13,7 @@ export interface ContextEntry {
 	name: string;
 	description: string;
 	files: string[];
+	anchors: string[];
 	path: string;
 }
 
@@ -36,6 +37,7 @@ const CONTEXT_IGNORED_FILENAMES = new Set([
 	"uv.lock",
 	"yarn.lock",
 ]);
+const CONTEXT_ENTRY_FIELDS = new Set(["description", "files", "anchors"]);
 
 export function isContextEligiblePath(path: string, ignoreGlobs: readonly string[] = []): boolean {
 	return (
@@ -97,6 +99,10 @@ function sortedUnique(values: readonly string[]): string[] {
 	return [...new Set(values)].sort((a, b) => a.localeCompare(b));
 }
 
+export function contextEntryPaths(entry: Pick<ContextEntry, "files" | "anchors">): string[] {
+	return sortedUnique([...entry.files, ...entry.anchors]);
+}
+
 export async function requireFiles(root: string, inputs: readonly string[]): Promise<string[]> {
 	const files = sortedUnique(inputs.map((input) => normalizeProjectPath(root, input)));
 	for (const file of files) {
@@ -132,15 +138,24 @@ export async function loadContextEntries(root: string): Promise<ContextEntry[]>
 				if (!value || typeof value !== "object" || Array.isArray(value))
 					throw new Error(`Invalid context entry: ${path} [${name}]`);
 				const record = value as Record<string, unknown>;
+				const unknownField = Object.keys(record).find((field) => !CONTEXT_ENTRY_FIELDS.has(field));
+				if (unknownField) throw new Error(`Invalid context entry field: ${path} [${name}] ${unknownField}`);
+				const anchors = record.anchors ?? [];
 				if (
 					typeof record.description !== "string" ||
 					!record.description.trim() ||
 					!Array.isArray(record.files) ||
-					record.files.length === 0 ||
-					record.files.some((item) => typeof item !== "string")
+					record.files.some((item) => typeof item !== "string") ||
+					!Array.isArray(anchors) ||
+					anchors.some((item) => typeof item !== "string") ||
+					(record.files.length === 0 && anchors.length === 0)
 				)
 					throw new Error(`Invalid context entry: ${path} [${name}]`);
 				const entry = validSlug(name, "Context entry");
+				const entryFiles = sortedUnique((record.files as string[]).map((item) => normalizeProjectPath(root, item)));
+				const entryAnchors = sortedUnique((anchors as string[]).map((item) => normalizeProjectPath(root, item)));
+				const overlap = entryFiles.find((item) => entryAnchors.includes(item));
+				if (overlap) throw new Error(`Context path cannot be both file and anchor: ${path} [${name}] ${overlap}`);
 				result.push({
 					id: `${tab}/${concept}/${entry}`,
 					tab,
@@ -149,7 +164,8 @@ export async function loadContextEntries(root: string): Promise<ContextEntry[]>
 					conceptDescription,
 					name: entry,
 					description: record.description.trim(),
-					files: sortedUnique((record.files as string[]).map((item) => normalizeProjectPath(root, item))),
+					files: entryFiles,
+					anchors: entryAnchors,
 					path,
 				});
 			}

package/extensions/context/index.ts

@@ -53,19 +53,35 @@ export default function contextExtension(pi: ExtensionAPI): void {
 			);
 			if (!selected?.length) return;
 			const files = [...new Set(selected.flatMap((entry) => entry.files))].sort();
+			const fileSet = new Set(files);
+			const anchors = [...new Set(selected.flatMap((entry) => entry.anchors))]
+				.filter((path) => !fileSet.has(path))
+				.sort();
 			pi.sendMessage(
 				createInjectedContext(
-					"Treat the autoread files as the authoritative project context and current snapshots. Do not reread them or search for coverage around them. Start work from them immediately. Explore outside them only when the user's request or concrete evidence in those files requires missing code or information.",
+					[
+						"Selected repository context:",
+						...selected.map((entry) => `- ${entry.id}: ${entry.description}`),
+						"",
+						"Eager snapshots supplied through autoread:",
+						...(files.length ? files.map((path) => `- ${path}`) : ["(none)"]),
+						"",
+						"Lazy navigation anchors whose contents have not been loaded:",
+						...(anchors.length ? anchors.map((path) => `- ${path}`) : ["(none)"]),
+						"",
+						"Treat eager snapshots as authoritative current project context. Do not reread them or search for coverage around them. Inspect only the anchors needed for the request, using grep or bounded reads. Explore elsewhere only when the request or concrete evidence requires missing information.",
+					].join("\n"),
 					{ source: "context", title: "Project context" },
 				),
 			);
-			emitTauEvent(pi, "tau:autoread.requested", {
-				source: "context",
-				title: "Project context",
-				cwd: root,
-				batchId: randomUUID(),
-				files: files.map((path) => ({ path })),
-			});
+			if (files.length)
+				emitTauEvent(pi, "tau:autoread.requested", {
+					source: "context",
+					title: "Project context",
+					cwd: root,
+					batchId: randomUUID(),
+					files: files.map((path) => ({ path })),
+				});
 		},
 	});
 

package/extensions/context/panel.ts

@@ -73,14 +73,15 @@ export class ContextPanel implements Component {
 		const list = this.activeList();
 		if (!list?.isFilterFocused()) {
 			const keys = getKeybindings();
-			const pageSize = this.filePageSize();
-			if (this.current.files.length > pageSize && matchesKey(data, Key.alt("up"))) {
+			const paths = this.currentPaths();
+			const pageSize = this.pathPageSize();
+			if (paths.length > pageSize && matchesKey(data, Key.alt("up"))) {
 				this.fileOffset = Math.max(0, this.fileOffset - pageSize);
 				this.sync();
 				return;
 			}
-			if (this.current.files.length > pageSize && matchesKey(data, Key.alt("down"))) {
-				this.fileOffset = Math.min(this.current.files.length - pageSize, this.fileOffset + pageSize);
+			if (paths.length > pageSize && matchesKey(data, Key.alt("down"))) {
+				this.fileOffset = Math.min(paths.length - pageSize, this.fileOffset + pageSize);
 				this.sync();
 				return;
 			}
@@ -122,35 +123,51 @@ export class ContextPanel implements Component {
 		return {
 			render: (width) => {
 				const tabs = this.tabs.render(width);
-				const pageSize = this.filePageSize(tabs.length);
-				const maxOffset = Math.max(0, this.current.files.length - pageSize);
+				const paths = this.currentPaths();
+				const pageSize = this.pathPageSize(tabs.length);
+				const maxOffset = Math.max(0, paths.length - pageSize);
 				this.fileOffset = Math.min(this.fileOffset, maxOffset);
-				const files = this.current.files.slice(this.fileOffset, this.fileOffset + pageSize);
+				const visible = paths.slice(this.fileOffset, this.fileOffset + pageSize);
 				const range =
-					this.current.files.length > pageSize
+					paths.length > pageSize
 						? this.theme.fg(
 								"dim",
-								`${this.fileOffset + 1}-${this.fileOffset + files.length} of ${this.current.files.length} files`,
+								`${this.fileOffset + 1}-${this.fileOffset + visible.length} of ${paths.length} paths`,
 							)
 						: undefined;
 				return [
 					...tabs,
 					"",
 					...(range ? [truncateToWidth(range, width, "…")] : []),
-					...files.map((file) => truncateToWidth(this.theme.fg("muted", `• ${file}`), width, "…")),
+					...visible.map(({ kind, path }) =>
+						truncateToWidth(
+							this.theme.fg(
+								kind === "read" ? "muted" : "dim",
+								`${kind === "read" ? "read" : "anchor"} • ${path}`,
+							),
+							width,
+							"…",
+						),
+					),
 				];
 			},
 			invalidate: () => this.tabs.invalidate(),
 		};
 	}
-	private filePageSize(tabLines = this.tabs.render(this.tui.terminal.columns).length): number {
+	private currentPaths(): Array<{ kind: "read" | "anchor"; path: string }> {
+		return [
+			...this.current.files.map((path) => ({ kind: "read" as const, path })),
+			...this.current.anchors.map((path) => ({ kind: "anchor" as const, path })),
+		];
+	}
+	private pathPageSize(tabLines = this.tabs.render(this.tui.terminal.columns).length): number {
 		const overlayHeight = Math.floor(this.tui.terminal.rows * 0.8);
 		const available = Math.max(1, overlayHeight - tabLines - 7);
 		const pageSize = Math.min(8, available);
-		return this.current.files.length > pageSize ? Math.max(1, pageSize - 1) : pageSize;
+		return this.currentPaths().length > pageSize ? Math.max(1, pageSize - 1) : pageSize;
 	}
 	private secondary(): string {
-		return `${[...this.selected.values()].reduce((sum, items) => sum + items.length, 0)} selected`;
+		return `${[...this.selected.values()].reduce((sum, items) => sum + items.length, 0)} selected · ${this.current.files.length} read · ${this.current.anchors.length} anchors`;
 	}
 	private hints() {
 		const list = this.activeList();
@@ -158,7 +175,7 @@ export class ContextPanel implements Component {
 			? list.getKeyHints()
 			: [
 					...this.tabs.getKeyHints(),
-					...(this.current.files.length > this.filePageSize() ? [rawHint("option+↑/↓", "scroll files")] : []),
+					...(this.currentPaths().length > this.pathPageSize() ? [rawHint("option+↑/↓", "scroll paths")] : []),
 					rawHint("ctrl+c", "clear all"),
 					bindingHint("tui.select.confirm", "inject"),
 					bindingHint("tui.select.cancel", "cancel"),

package/extensions/context/sync.ts

@@ -10,6 +10,7 @@ import { loadTauExtensionSettings } from "../../shared/settings/load.ts";
 import { truncAt } from "../../shared/text.ts";
 import { XAI_CHAT_MODEL, XAI_PROVIDER } from "../xai/constants.ts";
 import {
+	contextEntryPaths,
 	isContextEligiblePath,
 	isSensitiveContextPath,
 	loadContextEntries,
@@ -216,13 +217,14 @@ async function collectSyncEvidence(
 	for (const path of dependencies) if (!isContextEligiblePath(path, ignoreGlobs)) dependencies.delete(path);
 	const missingPaths = new Set<string>();
 	for (const entry of entries)
-		for (const path of entry.files)
+		for (const path of contextEntryPaths(entry))
 			if (isContextEligiblePath(path, ignoreGlobs) && !(await isFile(join(root, path)))) missingPaths.add(path);
 	const affectedIds = new Set<string>();
 	for (const entry of entries) {
+		const paths = contextEntryPaths(entry);
 		if (
-			entry.files.some((path) => missingPaths.has(path)) ||
-			entry.files.some(
+			paths.some((path) => missingPaths.has(path)) ||
+			paths.some(
 				(path) => files.some((file) => file.path === path || file.oldPath === path) || dependencies.has(path),
 			)
 		)
@@ -231,7 +233,7 @@ async function collectSyncEvidence(
 	const affectedConcepts = new Set([...affectedIds].map((id) => id.split("/").slice(0, 2).join("/")));
 	const siblingEntries = entries.filter((entry) => affectedConcepts.has(`${entry.tab}/${entry.concept}`));
 	const siblingFiles = siblingEntries
-		.flatMap((entry) => entry.files)
+		.flatMap((entry) => contextEntryPaths(entry))
 		.filter((path) => !missingPaths.has(path) && isContextEligiblePath(path, ignoreGlobs));
 	const eligibleFiles = new Set([...dirtyExisting, ...dependencies, ...siblingFiles]);
 	const structuralPreviews = new Map<string, string>();
@@ -327,9 +329,13 @@ async function collectDirtyFiles(
 				sorted.slice(offset, offset + EVIDENCE_CONCURRENCY).map(async (file, inner) => ({
 					...file,
 					id: offset + inner + 1,
-					memberships: entries.filter((entry) => entry.files.includes(file.path)).map((entry) => entry.id),
+					memberships: entries
+						.filter((entry) => contextEntryPaths(entry).includes(file.path))
+						.map((entry) => entry.id),
 					oldMemberships: file.oldPath
-						? entries.filter((entry) => entry.files.includes(file.oldPath ?? "")).map((entry) => entry.id)
+						? entries
+								.filter((entry) => contextEntryPaths(entry).includes(file.oldPath ?? ""))
+								.map((entry) => entry.id)
 						: [],
 					evidence: await dirtyEvidence(git, root, file),
 				})),
@@ -431,7 +437,9 @@ async function isFile(path: string): Promise<boolean> {
 
 function buildContextSyncPrompt(evidence: SyncEvidence): string {
 	const stale = evidence.entries.flatMap((entry) =>
-		entry.files.filter((path) => evidence.missingPaths.has(path)).map((path) => `${entry.id}: ${path}`),
+		contextEntryPaths(entry)
+			.filter((path) => evidence.missingPaths.has(path))
+			.map((path) => `${entry.id}: ${path}`),
 	);
 	const affected = evidence.entries.filter((entry) => evidence.affectedIds.has(entry.id));
 	const previews = [...evidence.structuralPreviews].map(([path, preview]) => `${path}\n${preview}`);
@@ -441,6 +449,7 @@ function buildContextSyncPrompt(evidence: SyncEvidence): string {
 			"Call submit_context_sync exactly once and produce no prose response.",
 			"Return no-change only when every eligible changed file has context membership and no stale catalog paths remain.",
 			"Context entries are reusable work scopes, not inventories of every touched file. Prefer updating an existing entry over creating a near-duplicate. Do not create one entry per file.",
+			"The files field in your changes is desired membership, including eager files and lazy anchors. Paths already classified anywhere in the catalog preserve their loading class; new paths become eager files. Do not change loading policy.",
 			"Follow direct local dependency candidates only when needed. Do not add package dependencies, generated files, incidental imports, or recursive dependencies.",
 			"Reconsider granularity only inside affected concepts. Preserve broad entries when splitting would duplicate files without improving future work.",
 			"Every eligible changed file must belong to at least one entry. Remove every stale catalog path. Use only supplied candidate paths.",
@@ -457,8 +466,9 @@ function buildContextSyncPrompt(evidence: SyncEvidence): string {
 					conceptName: entry.conceptName,
 					conceptDescription: entry.conceptDescription,
 					description: entry.description,
-					files: entry.files,
-					missingFiles: entry.files.filter((path) => evidence.missingPaths.has(path)),
+					eagerFiles: entry.files,
+					anchors: entry.anchors,
+					missingFiles: contextEntryPaths(entry).filter((path) => evidence.missingPaths.has(path)),
 				})),
 			),
 			"Changed files with no membership:",
@@ -540,7 +550,7 @@ export function normalizeContextSyncPlan(input: unknown, evidence: SyncEvidence)
 				throw new Error(`Entry is unrelated: ${id}`);
 			if (conceptName !== existing.conceptName || conceptDescription !== existing.conceptDescription)
 				throw new Error(`Existing concept metadata cannot change: ${conceptId}`);
-			if (description === existing.description && files.join("\0") === existing.files.join("\0"))
+			if (description === existing.description && files.join("\0") === contextEntryPaths(existing).join("\0"))
 				throw new Error(`Set-entry is identical: ${id}`);
 		} else {
 			const existingConcept = evidence.entries.find((item) => item.tab === tab && item.concept === concept);
@@ -560,7 +570,7 @@ export function normalizeContextSyncPlan(input: unknown, evidence: SyncEvidence)
 		}
 		changes.push({ action: "set-entry", tab, concept, conceptName, conceptDescription, entry, description, files });
 	}
-	const final = new Map(evidence.entries.map((entry) => [entry.id, [...entry.files]]));
+	const final = new Map(evidence.entries.map((entry) => [entry.id, contextEntryPaths(entry)]));
 	for (const change of changes) {
 		const id = `${change.tab}/${change.concept}/${change.entry}`;
 		if (change.action === "delete-entry") final.delete(id);
@@ -571,7 +581,7 @@ export function normalizeContextSyncPlan(input: unknown, evidence: SyncEvidence)
 	)) {
 		const old = current.get(`${change.tab}/${change.concept}/${change.entry}`);
 		if (!old) continue;
-		for (const path of old.files)
+		for (const path of contextEntryPaths(old))
 			if (evidence.eligibleFiles.has(path) && ![...final.values()].some((files) => files.includes(path)))
 				throw new Error(`Deleting entry would orphan surviving file: ${path}`);
 	}
@@ -640,6 +650,8 @@ export async function applyContextSyncPlan(
 ): Promise<ContextSyncDetails> {
 	for (const change of plan.changes) if (change.action === "set-entry") await requireFiles(root, change.files);
 	const concepts = [...new Set(plan.changes.map((change) => `${change.tab}/${change.concept}`))].sort();
+	const eagerPaths = new Set(entries.flatMap((entry) => entry.files));
+	const anchorPaths = new Set(entries.flatMap((entry) => entry.anchors).filter((path) => !eagerPaths.has(path)));
 	const outputs = new Map<string, string | undefined>();
 	for (const key of concepts) {
 		const [tab, concept] = key.split("/");
@@ -653,7 +665,12 @@ export async function applyContextSyncPlan(
 			else {
 				if (raw.name === undefined) raw.name = change.conceptName;
 				if (raw.description === undefined) raw.description = change.conceptDescription;
-				raw[change.entry] = { description: change.description, files: change.files };
+				const anchors = change.files.filter((path) => anchorPaths.has(path));
+				raw[change.entry] = {
+					description: change.description,
+					files: change.files.filter((path) => !anchors.includes(path)),
+					...(anchors.length ? { anchors } : {}),
+				};
 			}
 		}
 		outputs.set(

package/extensions/context/validation.ts

@@ -1,7 +1,7 @@
 import { stat } from "node:fs/promises";
 import { join } from "node:path";
 import type { GitRunner } from "../../shared/git.ts";
-import { isContextEligiblePath, isSensitiveContextPath, loadContextEntries } from "./definitions.ts";
+import { contextEntryPaths, isContextEligiblePath, isSensitiveContextPath, loadContextEntries } from "./definitions.ts";
 
 export interface ContextValidationResult {
 	stale: Array<{ path: string; ids: string[] }>;
@@ -16,7 +16,7 @@ export async function validateContextCatalog(
 	const entries = await loadContextEntries(root);
 	const memberships = new Map<string, string[]>();
 	for (const entry of entries)
-		for (const file of entry.files) memberships.set(file, [...(memberships.get(file) ?? []), entry.id]);
+		for (const file of contextEntryPaths(entry)) memberships.set(file, [...(memberships.get(file) ?? []), entry.id]);
 
 	const stale: Array<{ path: string; ids: string[] }> = [];
 	for (const [path, ids] of memberships) {

package/extensions/subagent/README.md

@@ -12,6 +12,8 @@ Tau includes three built-in agents:
 
 Ask Tau to delegate a task, or let it call `subagent` with an agent name and task. Children use the parent's current working directory and inherit its model and thinking level unless their definition overrides either value. They do not receive the parent conversation. Tau loads only the extensions that own a child's declared tools, so unrelated extension hooks do not run in child sessions. When a child must inspect another repository, put its exact absolute path in the delegated task.
 
+Fresh calls return a thread ID. Tau can send feedback or follow-up work to that thread, preserving the child's conversation, prior reads, and tool results. It starts a fresh thread for unrelated work or when retained context is stale or oversized. Threads live for the current parent session. Tau retains up to 16 and evicts the least recently used idle thread when needed. Calls to one thread run sequentially.
+
 ## Agent definitions
 
 Add Markdown definitions at `~/.pi/agent/tau/agents/*.md` or, in a trusted project, the nearest `.pi/tau/agents/*.md`. Project definitions override user definitions, which override built-ins. Duplicate names in one scope are invalid.

package/extensions/subagent/index.ts

@@ -1,20 +1,66 @@
 import { defineTool, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { createToolRowStateStore } from "../../shared/tool-row-state.js";
-import { discoverAgents, type AgentDiscovery } from "./agents.ts";
+import { discoverAgents, type AgentDefinition, type AgentDiscovery } from "./agents.ts";
 import { renderSubagentCall, renderSubagentResult } from "./render.ts";
-import { extensionPathsForTools, FifoGate, runSubagent, type SubagentDetails } from "./run.ts";
+import {
+	createSubagentThread,
+	disposeSubagentThread,
+	extensionPathsForTools,
+	FifoGate,
+	runSubagentTurn,
+	type SubagentDetails,
+	type SubagentThread,
+} from "./run.ts";
 
-const params = Type.Object(
-	{ agent: Type.String({ minLength: 1 }), task: Type.String({ minLength: 1 }) },
-	{ additionalProperties: false },
-);
+const params = Type.Union([
+	Type.Object(
+		{ agent: Type.String({ minLength: 1 }), task: Type.String({ minLength: 1 }) },
+		{ additionalProperties: false },
+	),
+	Type.Object(
+		{ thread: Type.String({ minLength: 1 }), task: Type.String({ minLength: 1 }) },
+		{ additionalProperties: false },
+	),
+]);
+
+const MAX_RETAINED_THREADS = 16;
+
+function emptyDetails(
+	agent: string,
+	task: string,
+	status: "waiting" | "failed" | "aborted",
+	phase: "discovery" | "queue" | "startup",
+	model: string,
+	thinkingLevel: string,
+	threadId: string | undefined,
+	error: string | undefined,
+): SubagentDetails {
+	return {
+		agent,
+		...(threadId === undefined ? {} : { threadId }),
+		status,
+		phase,
+		task,
+		model,
+		thinkingLevel,
+		toolCalls: 0,
+		actions: [],
+		omittedActions: 0,
+		omittedErrors: 0,
+		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+		durationMs: 0,
+		...(error === undefined ? {} : { error }),
+	};
+}
 
 export default function subagentExtension(pi: ExtensionAPI): void {
 	const gate = new FifoGate(4);
 	const controllers = new Set<AbortController>();
+	const threads = new Map<string, SubagentThread>();
 	const fingerprints = new Map<string, string>();
 	const runtimeWarnings = new Set<string>();
+	let nextThreadId = 1;
 	const rowState = createToolRowStateStore(pi, "subagent.tool-row-state");
 	const warn = (discovery: AgentDiscovery, ctx: ExtensionContext) => {
 		const current = new Set<string>();
@@ -33,6 +79,11 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		}
 		for (const path of fingerprints.keys()) if (!current.has(path)) fingerprints.delete(path);
 	};
+	const disposeThreads = async () => {
+		const retained = [...threads.values()];
+		threads.clear();
+		await Promise.all(retained.map((thread) => disposeSubagentThread(thread)));
+	};
 	pi.on("before_agent_start", async (event, ctx) => {
 		if (!pi.getActiveTools().includes("subagent")) return undefined;
 		const discovery = await discoverAgents(ctx.cwd, ctx.isProjectTrusted());
@@ -40,7 +91,23 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		const lines = [...discovery.agents.values()]
 			.sort((a, b) => a.name.localeCompare(b.name))
 			.map((agent) => `- ${agent.name}: ${agent.description}`);
-		const prompt = `## Subagents\nUse \`subagent\` when an available agent matches a focused part of the task.\n\nAvailable agents for this turn:\n${lines.join("\n")}\n\nDelegate one focused task per call. Children do not inherit parent messages. Include exact absolute reference paths when a child must inspect a repository outside the current working directory.`;
+		const activeThreads = [...threads.values()]
+			.filter((thread) => thread.cwd === ctx.cwd)
+			.sort((a, b) => a.id.localeCompare(b.id))
+			.map((thread) => {
+				const task = thread.initialTask.replace(/\s+/g, " ").trim();
+				return `- ${thread.id} (${thread.definition.name}): ${task.length <= 160 ? task : `${task.slice(0, 159)}…`}`;
+			});
+		const threadSection = activeThreads.length ? `\n\nActive reusable threads:\n${activeThreads.join("\n")}` : "";
+		const prompt = `## Subagents
+Use \`subagent\` when an available agent matches a focused part of the task.
+
+Available agents for this turn:
+${lines.join("\n")}
+
+Start a fresh thread with \`agent\` and \`task\`. Continue an existing thread with \`thread\` and \`task\`. Reuse a thread when feedback or follow-up work depends on its prior reads and reasoning. Start fresh for unrelated work or when its context is stale or oversized.${threadSection}
+
+Delegate one focused task per call. Children do not inherit parent messages. Include exact absolute reference paths when a child must inspect a repository outside the current working directory.`;
 		return { systemPrompt: `${event.systemPrompt}\n\n${prompt}` };
 	});
 	pi.registerTool(
@@ -48,116 +115,142 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 			name: "subagent",
 			label: "Subagent",
 			description:
-				"Delegate one focused task to a named isolated child agent. Output is limited to 50KB or 2,000 lines.",
-			promptSnippet: "Delegate one focused task to a named isolated child agent",
+				"Start a focused isolated child agent or continue a retained child thread. Output is limited to 50KB or 2,000 lines.",
+			promptSnippet: "Start a focused child agent or continue a retained child thread",
 			parameters: params,
 			executionMode: "parallel",
 			async execute(_id, raw, signal, onUpdate, ctx) {
-				const agent = raw.agent.trim();
 				const task = raw.task.trim();
-				const thinkingLevel = pi.getThinkingLevel();
-				if (!agent || !task)
-					return {
-						content: [{ type: "text", text: "Subagent input requires non-empty agent and task" }],
-						details: {
-							agent,
-							task,
-							status: "failed",
-							phase: "queue",
-							model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "unavailable",
-							thinkingLevel,
-							toolCalls: 0,
-							actions: [],
-							omittedActions: 0,
-							omittedErrors: 0,
-							usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-							durationMs: 0,
-							error: "Invalid input",
-						},
-					};
-				const discovery = await discoverAgents(ctx.cwd, ctx.isProjectTrusted());
-				warn(discovery, ctx);
-				const definition = discovery.agents.get(agent);
-				const invalid = discovery.invalid.get(agent);
-				if (!definition) {
-					const reason = invalid?.map((item) => item.reason).join("; ") ?? "unknown agent";
-					const names = [...discovery.agents.keys()].sort().join(", ") || "none";
-					const error = `Agent ${agent} discovery failed: ${reason}. Runnable agents: ${names}`;
+				const continuing = "thread" in raw;
+				const parentModel = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "unavailable";
+				const parentThinking = pi.getThinkingLevel();
+				let thread: SubagentThread | undefined;
+				let definition: AgentDefinition | undefined;
+				let agent = continuing ? raw.thread.trim() : raw.agent.trim();
+				let threadId = continuing ? raw.thread.trim() : undefined;
+				if (!task || !agent) {
+					const error = continuing
+						? "Subagent continuation requires non-empty thread and task"
+						: "Subagent input requires non-empty agent and task";
 					return {
 						content: [{ type: "text", text: error }],
-						details: {
-							agent,
-							task,
-							status: "failed",
-							phase: "discovery",
-							model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "unavailable",
-							thinkingLevel,
-							toolCalls: 0,
-							actions: [],
-							omittedActions: 0,
-							omittedErrors: 0,
-							usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-							durationMs: 0,
-							error,
-						},
+						details: emptyDetails(agent, task, "failed", "queue", parentModel, parentThinking, threadId, error),
 					};
 				}
+				if (continuing) {
+					thread = threads.get(agent);
+					if (!thread || thread.cwd !== ctx.cwd) {
+						const names =
+							[...threads.values()]
+								.filter((item) => item.cwd === ctx.cwd)
+								.map((item) => item.id)
+								.sort()
+								.join(", ") || "none";
+						const error = `Subagent thread ${agent} is unavailable. Active threads: ${names}`;
+						return {
+							content: [{ type: "text", text: error }],
+							details: emptyDetails(
+								agent,
+								task,
+								"failed",
+								"discovery",
+								parentModel,
+								parentThinking,
+								agent,
+								error,
+							),
+						};
+					}
+					agent = thread.definition.name;
+					threadId = thread.id;
+					definition = thread.definition;
+				} else {
+					const discovery = await discoverAgents(ctx.cwd, ctx.isProjectTrusted());
+					warn(discovery, ctx);
+					definition = discovery.agents.get(agent);
+					const invalid = discovery.invalid.get(agent);
+					if (!definition) {
+						const reason = invalid?.map((item) => item.reason).join("; ") ?? "unknown agent";
+						const names = [...discovery.agents.keys()].sort().join(", ") || "none";
+						const error = `Agent ${agent} discovery failed: ${reason}. Runnable agents: ${names}`;
+						return {
+							content: [{ type: "text", text: error }],
+							details: emptyDetails(
+								agent,
+								task,
+								"failed",
+								"discovery",
+								parentModel,
+								parentThinking,
+								undefined,
+								error,
+							),
+						};
+					}
+					threadId = `thread-${nextThreadId++}`;
+				}
 				const controller = new AbortController();
 				controllers.add(controller);
 				const combined = AbortSignal.any([controller.signal, ...(signal ? [signal] : [])]);
-				let release: (() => void) | undefined;
+				let releaseThread: (() => void) | undefined;
+				let releaseGlobal: (() => void) | undefined;
+				let reservedThread: SubagentThread | undefined;
+				let phase: "queue" | "startup" = "queue";
 				try {
-					await onUpdate?.({
-						content: [{ type: "text", text: `${agent}: waiting` }],
-						details: {
-							agent,
-							task,
-							status: "waiting",
-							phase: "queue",
-							model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "unavailable",
-							thinkingLevel,
-							toolCalls: 0,
-							actions: [],
-							omittedActions: 0,
-							omittedErrors: 0,
-							usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-							durationMs: 0,
-						},
-					});
-					try {
-						release = await gate.acquire(combined);
-					} catch (error) {
-						const message = error instanceof Error ? error.message : `Agent ${agent} queue failed`;
-						const details: SubagentDetails = {
-							agent,
-							task,
-							status: combined.aborted ? "aborted" : "failed",
-							phase: "queue",
-							model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "unavailable",
-							thinkingLevel,
-							toolCalls: 0,
-							actions: [],
-							omittedActions: 0,
-							omittedErrors: 0,
-							usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-							durationMs: 0,
-							error: message,
-						};
-						return { content: [{ type: "text", text: message }], details };
+					const waiting = emptyDetails(
+						agent,
+						task,
+						"waiting",
+						"queue",
+						thread?.model ?? parentModel,
+						thread?.thinkingLevel ?? parentThinking,
+						threadId,
+						undefined,
+					);
+					await onUpdate?.({ content: [{ type: "text", text: `${agent}: waiting` }], details: waiting });
+					if (thread) {
+						reservedThread = thread;
+						thread.pendingTurns += 1;
+						releaseThread = await thread.turnGate.acquire(combined);
 					}
-					const result = await runSubagent({
-						definition,
-						extensionPaths: extensionPathsForTools(pi, definition.tools),
+					releaseGlobal = await gate.acquire(combined);
+					if (!thread) {
+						phase = "startup";
+						if (!threadId || !definition) throw new Error("Subagent startup state is incomplete");
+						const selectedDefinition = definition;
+						if (threads.size >= MAX_RETAINED_THREADS) {
+							const evicted = [...threads.values()]
+								.filter((item) => item.pendingTurns === 0)
+								.sort((a, b) => a.lastUsedAt - b.lastUsedAt)[0];
+							if (!evicted) throw new Error("Subagent thread limit reached while all retained threads are busy");
+							threads.delete(evicted.id);
+							await disposeSubagentThread(evicted);
+						}
+						thread = await createSubagentThread({
+							id: threadId,
+							definition: selectedDefinition,
+							extensionPaths: extensionPathsForTools(pi, selectedDefinition.tools),
+							initialTask: task,
+							ctx,
+							thinkingLevel: parentThinking,
+							signal: combined,
+							onWarning: (warning) => {
+								const message = `Subagent definition ${selectedDefinition.path}: ${warning}`;
+								if (runtimeWarnings.has(message)) return;
+								runtimeWarnings.add(message);
+								ctx.ui.notify(message, "warning");
+							},
+						});
+						threads.set(thread.id, thread);
+						reservedThread = thread;
+						thread.pendingTurns += 1;
+					}
+					if (!thread) throw new Error("Subagent thread startup failed");
+					const result = await runSubagentTurn({
+						thread,
 						task,
-						ctx,
-						thinkingLevel,
+						initial: thread.turns === 0,
 						signal: combined,
-						onWarning: (warning) => {
-							const message = `Subagent definition ${definition.path}: ${warning}`;
-							if (runtimeWarnings.has(message)) return;
-							runtimeWarnings.add(message);
-							ctx.ui.notify(message, "warning");
-						},
 						onUpdate: (details) =>
 							onUpdate?.({
 								content: [
@@ -169,9 +262,33 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 								details,
 							}),
 					});
-					return { content: [{ type: "text", text: result.content }], details: result.details };
+					return {
+						content: [
+							{
+								type: "text",
+								text: `Thread: ${thread.id}\nReuse with subagent({ thread: "${thread.id}", task: "..." })\n\n${result.content}`,
+							},
+						],
+						details: result.details,
+					};
+				} catch (error) {
+					const message = error instanceof Error ? error.message : `Agent ${agent} ${phase} failed`;
+					const status = combined.aborted ? "aborted" : "failed";
+					const details = emptyDetails(
+						agent,
+						task,
+						status,
+						phase,
+						thread?.model ?? parentModel,
+						thread?.thinkingLevel ?? parentThinking,
+						thread?.id ?? threadId,
+						message,
+					);
+					return { content: [{ type: "text", text: message }], details };
 				} finally {
-					release?.();
+					if (reservedThread) reservedThread.pendingTurns -= 1;
+					releaseGlobal?.();
+					releaseThread?.();
 					controllers.delete(controller);
 				}
 			},
@@ -200,12 +317,17 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		const details = event.details as SubagentDetails | undefined;
 		if (details?.status === "failed" || details?.status === "aborted") return { isError: true };
 	});
-	pi.on("session_start", () => {
+	pi.on("session_start", async () => {
+		for (const controller of controllers) controller.abort();
+		controllers.clear();
+		await disposeThreads();
+		nextThreadId = 1;
 		rowState.clear();
 		runtimeWarnings.clear();
 	});
-	pi.on("session_shutdown", () => {
+	pi.on("session_shutdown", async () => {
 		for (const controller of controllers) controller.abort();
 		controllers.clear();
+		await disposeThreads();
 	});
 }

package/extensions/subagent/render.ts

@@ -12,7 +12,7 @@ const title = (theme: Theme, rowState: ToolRowStateStore, rowId: string, invalid
 };
 
 export function renderSubagentCall(
-	args: { agent?: string; task?: string },
+	args: { agent?: string; thread?: string; task?: string },
 	theme: Theme,
 	context: {
 		executionStarted: boolean;
@@ -29,7 +29,7 @@ export function renderSubagentCall(
 		return text;
 	}
 	const prefix =
-		`${title(theme, context.rowState, context.rowId, context.invalidate)}  ${theme.fg("accent", args.agent ?? "")}`.trimEnd();
+		`${title(theme, context.rowState, context.rowId, context.invalidate)}  ${theme.fg("accent", args.agent ?? args.thread ?? "")}`.trimEnd();
 	const task = args.task?.replace(/\s+/g, " ").trim();
 	text.setText(task ? `${prefix}  ${theme.fg("muted", task)}` : prefix);
 	return text;
@@ -47,7 +47,8 @@ export function renderSubagentResult(
 		text.setText("");
 		return text;
 	}
-	const header = `${title(theme, context.rowState, context.rowId, context.invalidate)}  ${theme.fg("accent", details.agent)}  ${theme.fg("muted", `$${details.usage.cost.toFixed(4)} · ${(details.durationMs / 1000).toFixed(1)}s · ${details.toolCalls} tools`)}`;
+	const identity = details.threadId ? `${details.agent} · ${details.threadId}` : details.agent;
+	const header = `${title(theme, context.rowState, context.rowId, context.invalidate)}  ${theme.fg("accent", identity)}  ${theme.fg("muted", `$${details.usage.cost.toFixed(4)} · ${(details.durationMs / 1000).toFixed(1)}s · ${details.toolCalls} tools`)}`;
 	if (!expanded) {
 		text.setText(`${header}  ${theme.fg("muted", details.task.replace(/\s+/g, " ").trim())}`);
 		return text;

package/extensions/subagent/run.ts

@@ -55,6 +55,7 @@ export interface SubagentUsage {
 }
 export interface SubagentDetails {
 	agent: string;
+	threadId?: string;
 	status: "waiting" | "running" | "completed" | "failed" | "aborted";
 	phase: "discovery" | "queue" | "startup" | "run" | "output";
 	completionState?: string;
@@ -80,6 +81,20 @@ export interface SubagentDetails {
 	};
 }
 
+export interface SubagentThread {
+	id: string;
+	definition: AgentDefinition;
+	session: AgentSession;
+	cwd: string;
+	model: string;
+	thinkingLevel: string;
+	initialTask: string;
+	turns: number;
+	turnGate: FifoGate;
+	pendingTurns: number;
+	lastUsedAt: number;
+}
+
 export function extensionPathsForTools(pi: ExtensionAPI, tools: readonly string[]): string[] {
 	const selected = new Set(tools);
 	return [
@@ -154,31 +169,26 @@ function textOf(message: AssistantMessage): string {
 		.join("");
 }
 
-function assistants(session: AgentSession): AssistantMessage[] {
-	return session.messages.filter((message): message is AssistantMessage => message.role === "assistant");
-}
-
-export async function runSubagent(options: {
+export async function createSubagentThread(options: {
+	id: string;
 	definition: AgentDefinition;
 	extensionPaths: readonly string[];
-	task: string;
+	initialTask: string;
 	ctx: ExtensionContext;
 	thinkingLevel: string;
 	signal: AbortSignal;
-	onUpdate?: (details: SubagentDetails) => void | Promise<void>;
 	onWarning?: (warning: string) => void;
-}): Promise<{ content: string; details: SubagentDetails }> {
+}): Promise<SubagentThread> {
 	const {
+		id,
 		definition,
 		extensionPaths,
-		task,
+		initialTask,
 		ctx,
 		thinkingLevel: parentThinkingLevel,
 		signal,
-		onUpdate,
 		onWarning,
 	} = options;
-	const started = Date.now();
 	let model = ctx.model;
 	let thinkingLevel = parentThinkingLevel;
 	if (definition.model) {
@@ -205,34 +215,7 @@ export async function runSubagent(options: {
 		else thinkingLevel = definition.thinking;
 	}
 	const modelName = model ? `${model.provider}/${model.id}` : "unavailable";
-	const usage: SubagentUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-	const details: SubagentDetails = {
-		agent: definition.name,
-		status: "running",
-		phase: "startup",
-		task,
-		model: modelName,
-		thinkingLevel,
-		toolCalls: 0,
-		actions: [],
-		omittedActions: 0,
-		omittedErrors: 0,
-		usage,
-		durationMs: 0,
-	};
 	let session: AgentSession | undefined;
-	let unsubscribe: (() => void) | undefined;
-	let updateChain = Promise.resolve();
-	let lastTextUpdate = 0;
-	const publish = (force = false) => {
-		const now = Date.now();
-		if (!force && now - lastTextUpdate < 100) return;
-		lastTextUpdate = now;
-		details.durationMs = now - started;
-		const snapshot = structuredClone(details);
-		snapshot.actions = snapshot.actions.slice(-5);
-		updateChain = updateChain.then(() => onUpdate?.(snapshot)).catch(() => undefined);
-	};
 	try {
 		if (!model) throw new Error(`Agent ${definition.name} startup failed: parent has no model`);
 		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
@@ -267,12 +250,78 @@ export async function runSubagent(options: {
 				`Agent ${definition.name} startup failed: unavailable tools: ${missing.join(", ") || "active tool mismatch"}`,
 			);
 		}
-		details.phase = "run";
+		return {
+			id,
+			definition,
+			session,
+			cwd: ctx.cwd,
+			model: modelName,
+			thinkingLevel,
+			initialTask,
+			turns: 0,
+			turnGate: new FifoGate(1),
+			pendingTurns: 0,
+			lastUsedAt: Date.now(),
+		};
+	} catch (error) {
+		if (session?.isStreaming) await session.abort().catch(() => undefined);
+		session?.dispose();
+		throw error;
+	}
+}
+
+export async function disposeSubagentThread(thread: SubagentThread): Promise<void> {
+	if (thread.session.isStreaming) await thread.session.abort().catch(() => undefined);
+	thread.session.dispose();
+}
+
+export async function runSubagentTurn(options: {
+	thread: SubagentThread;
+	task: string;
+	initial: boolean;
+	signal: AbortSignal;
+	onUpdate?: (details: SubagentDetails) => void | Promise<void>;
+}): Promise<{ content: string; details: SubagentDetails }> {
+	const { thread, task, initial, signal, onUpdate } = options;
+	const { definition, session } = thread;
+	const started = Date.now();
+	const usage: SubagentUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+	const details: SubagentDetails = {
+		agent: definition.name,
+		threadId: thread.id,
+		status: "running",
+		phase: "run",
+		task,
+		model: thread.model,
+		thinkingLevel: thread.thinkingLevel,
+		toolCalls: 0,
+		actions: [],
+		omittedActions: 0,
+		omittedErrors: 0,
+		usage,
+		durationMs: 0,
+	};
+	let unsubscribe: (() => void) | undefined;
+	let updateChain = Promise.resolve();
+	let lastTextUpdate = 0;
+	const turnMessages: AssistantMessage[] = [];
+	const publish = (force = false) => {
+		const now = Date.now();
+		if (!force && now - lastTextUpdate < 100) return;
+		lastTextUpdate = now;
+		details.durationMs = now - started;
+		const snapshot = structuredClone(details);
+		snapshot.actions = snapshot.actions.slice(-5);
+		updateChain = updateChain.then(() => onUpdate?.(snapshot)).catch(() => undefined);
+	};
+	try {
 		const actionById = new Map<string, string>();
 		unsubscribe = session.subscribe((event: AgentSessionEvent) => {
 			if (event.type === "message_update" && event.message.role === "assistant") {
 				details.response = capped(textOf(event.message), PREVIEW_LIMIT);
 				publish();
+			} else if (event.type === "message_end" && event.message.role === "assistant") {
+				turnMessages.push(event.message);
 			} else if (event.type === "tool_execution_start") {
 				details.toolCalls += 1;
 				const summary = `${event.toolName} ${capped(event.args)}`.trim();
@@ -302,14 +351,15 @@ export async function runSubagent(options: {
 		signal.addEventListener("abort", abort, { once: true });
 		try {
 			await session.prompt(
-				`You are an isolated delegated child agent. Stay within the delegated task and return only the requested result.\n\n## Agent instructions\n${definition.prompt}\n\n## Delegated task\n${task}`,
+				initial
+					? `You are an isolated delegated child agent. Stay within the delegated task and return only the requested result.\n\n## Agent instructions\n${definition.prompt}\n\n## Delegated task\n${task}`
+					: `Continue the existing delegated work using the context already in this thread. Return only the requested result.\n\n## Parent follow-up\n${task}`,
 				{ expandPromptTemplates: false },
 			);
 		} finally {
 			signal.removeEventListener("abort", abort);
 		}
-		const messages = assistants(session);
-		for (const message of messages) {
+		for (const message of turnMessages) {
 			usage.input += message.usage.input;
 			usage.output += message.usage.output;
 			usage.cacheRead += message.usage.cacheRead;
@@ -317,7 +367,7 @@ export async function runSubagent(options: {
 			usage.cost += message.usage.cost.total;
 			usage.turns += 1;
 		}
-		const terminal = messages.at(-1);
+		const terminal = turnMessages.at(-1);
 		if (!terminal) throw new Error(`Agent ${definition.name} run failed: no terminal assistant response`);
 		const response = textOf(terminal);
 		if (terminal.stopReason === "aborted") {
@@ -374,7 +424,8 @@ export async function runSubagent(options: {
 		return { content: details.error, details };
 	} finally {
 		unsubscribe?.();
-		if (session?.isStreaming) await session.abort().catch(() => undefined);
-		session?.dispose();
+		thread.turns += 1;
+		thread.lastUsedAt = Date.now();
+		if (session.isStreaming) await session.abort().catch(() => undefined);
 	}
 }

package/extensions/tau-help/help.md

@@ -28,7 +28,7 @@ Adds `/commit` for semantic commit grouping, review, and committing selected rep
 
 ## context
 
-Adds `/context` to select reusable repository work scopes from `.pi/contexts`, and `/context-sync` to reconcile affected scopes from current Git changes. Context validation is disabled by default; when enabled, Tau checks changed-file membership and stale references after agent turns. Folder names are tabs, TOML files are concepts, and TOML sections are selectable entries.
+Adds `/context` to select reusable repository work scopes from `.pi/contexts`, and `/context-sync` to reconcile affected scopes from current Git changes. Entry `files` are autoread; entry `anchors` are unloaded navigation paths the agent can inspect when needed. Context validation is disabled by default; when enabled, Tau checks both classes for changed-file membership and stale references after agent turns. Folder names are tabs, TOML files are concepts, and TOML sections are selectable entries.
 
 ## explore
 
@@ -92,7 +92,7 @@ Adds `Alt+S` to stash the current prompt draft and `/pop` to browse stashed draf
 
 ## subagent
 
-Gives Tau a subagent delegation tool for isolated, focused work. You can also create your own subagents in the supported subagent directories. Ask Tau how to do it and have it consult the extension’s own documentation; the built-in `scout` and `web-research` subagents show the pattern. Each subagent can register its own model and the tools it is allowed to use.
+Gives Tau a subagent delegation tool for isolated, focused work. Tau can continue a retained child thread when follow-up work depends on its prior reads and reasoning. You can also create your own subagents in the supported subagent directories. Ask Tau how to do it and have it consult the extension’s own documentation; the built-in agents show the pattern. Each subagent can register its own model and the tools it is allowed to use.
 
 ## tau-help
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.12.0",
+	"version": "0.14.0",
 	"description": "Tau is a custom agentic harness built with pi extensions",
 	"type": "module",
 	"license": "MIT",
@@ -28,7 +28,7 @@
 		"README.md"
 	],
 	"dependencies": {
-		"@shanepadgett/tau-tui": "0.12.0",
+		"@shanepadgett/tau-tui": "0.14.0",
 		"@toon-format/toon": "2.3.0",
 		"smol-toml": "1.7.0"
 	},