@shanepadgett/tau-agent 0.42.2 → 0.43.0

package/extensions/tool-loader/index.ts

@@ -1,6 +1,9 @@
-import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { defineTool, type ExtensionAPI, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
 import { registeredDeferredToolGroups, type DeferredToolGroupInfo } from "../../src/tool-loading/index.ts";
+import { emitTauEvent } from "../../shared/events.ts";
+import { BoundedTextResultBuilder } from "../../shared/bounded-text-result.ts";
+import { createTemporaryOutputStore } from "../../shared/temporary-output-store.ts";
 
 const loadToolsSchema = Type.Object(
 	{
@@ -21,14 +24,25 @@ interface LoadToolsDetails {
 	addedToolNames: string[];
 }
 
+const PENDING_TYPE = "tau.tool-loader.pending";
+const APPLIED_TYPE = "tau.tool-loader.applied";
+
+interface AppliedLoad {
+	pendingId: string;
+	names: string[];
+}
+
 export default function toolLoaderExtension(pi: ExtensionAPI): void {
+	let temporaryOutput = createTemporaryOutputStore();
 	let managed = false;
 	let allowedToolNames = new Map<string, ReadonlySet<string>>();
 	let managedToolNames = new Set<string>();
 
 	pi.registerTool(createLoadToolsTool(pi, []));
 
-	pi.on("session_start", (_event, ctx) => {
+	pi.on("session_start", async (_event, ctx) => {
+		temporaryOutput = createTemporaryOutputStore();
+		await temporaryOutput.start();
 		const groups = registeredDeferredToolGroups(pi);
 		pi.registerTool(createLoadToolsTool(pi, groups));
 
@@ -39,20 +53,43 @@ export default function toolLoaderExtension(pi: ExtensionAPI): void {
 		);
 		managedToolNames = new Set(groups.flatMap((group) => group.toolNames));
 		managed = initialSet.has("load_tools") && groups.length > 0;
-		if (managed) restoreActiveTools(pi, initial, loadedCapabilities(ctx.sessionManager.getBranch()), groups);
+		if (managed) restoreActiveTools(pi, initial, loadedCapabilities(ctx.sessionManager.getBranch(), groups), groups);
 	});
+	pi.on("session_shutdown", () => temporaryOutput.shutdown());
 
 	pi.on("session_tree", (_event, ctx) => {
 		if (managed) {
 			restoreActiveTools(
 				pi,
 				pi.getActiveTools(),
-				loadedCapabilities(ctx.sessionManager.getBranch()),
+				loadedCapabilities(ctx.sessionManager.getBranch(), registeredDeferredToolGroups(pi)),
 				registeredDeferredToolGroups(pi),
 			);
 		}
 	});
 
+	pi.on("session_compact", (_event, ctx) => {
+		const branch = ctx.sessionManager.getBranch();
+		const applied = new Set(
+			branch.flatMap((entry) =>
+				entry.type === "custom" && entry.customType === APPLIED_TYPE ? [(entry.data as AppliedLoad).pendingId] : [],
+			),
+		);
+		for (const entry of branch) {
+			if (
+				entry.type !== "custom" ||
+				entry.customType !== PENDING_TYPE ||
+				applied.has(entry.id) ||
+				!Array.isArray(entry.data)
+			)
+				continue;
+			const names = entry.data.filter((name): name is string => typeof name === "string");
+			const allowed = new Set([...allowedToolNames.values()].flatMap((group) => [...group]));
+			pi.setActiveTools([...new Set([...pi.getActiveTools(), ...names.filter((name) => allowed.has(name))])]);
+			pi.appendEntry(APPLIED_TYPE, { pendingId: entry.id, names });
+		}
+	});
+
 	function createLoadToolsTool(pi: ExtensionAPI, groups: readonly DeferredToolGroupInfo[]) {
 		return defineTool<typeof loadToolsSchema, LoadToolsDetails>({
 			name: "load_tools",
@@ -63,7 +100,7 @@ export default function toolLoaderExtension(pi: ExtensionAPI): void {
 				"Use load_tools before attempting a registered specialist capability whose tools are not currently available.",
 			],
 			parameters: loadToolsSchema,
-			async execute(_toolCallId, params: LoadToolsParams) {
+			async execute(_toolCallId, params: LoadToolsParams, signal, _onUpdate, ctx) {
 				const group = registeredDeferredToolGroups(pi).find((candidate) => candidate.id === params.capability);
 				if (group === undefined) {
 					throw new Error(
@@ -81,7 +118,25 @@ export default function toolLoaderExtension(pi: ExtensionAPI): void {
 				}
 
 				const beforeSet = new Set(before);
-				pi.setActiveTools([...before, ...loadable.filter((name) => !beforeSet.has(name))]);
+				const next = [...before, ...loadable.filter((name) => !beforeSet.has(name))];
+				const nextSet = new Set(next);
+				let blocked: string | null = null;
+				emitTauEvent(pi, "tau:prompt.tools.check", {
+					ctx,
+					tools: pi.getAllTools().filter((tool) => nextSet.has(tool.name)),
+					reject(reason) {
+						blocked = reason;
+					},
+				});
+				if (blocked) {
+					pi.appendEntry(PENDING_TYPE, loadable);
+					return boundedResult(
+						`${blocked} ${params.capability} is queued for activation after successful compaction.`,
+						{ version: 1, capability: params.capability, requestedToolNames: requested, addedToolNames: [] },
+						signal,
+					);
+				}
+				pi.setActiveTools(next);
 				const after = pi.getActiveTools();
 				const addedToolNames = requested.filter((name) => !beforeSet.has(name) && after.includes(name));
 				const available = requested.filter((name) => after.includes(name));
@@ -91,24 +146,36 @@ export default function toolLoaderExtension(pi: ExtensionAPI): void {
 						? `Loaded ${params.capability} tools: ${addedToolNames.join(", ")}.`
 						: `${params.capability} tools are already loaded: ${available.join(", ")}.`;
 
-				return {
-					content: [
-						{
-							type: "text" as const,
-							text: unavailable.length ? `${text} Unavailable: ${unavailable.join(", ")}.` : text,
-						},
-					],
-					details: {
+				return boundedResult(
+					unavailable.length ? `${text} Unavailable: ${unavailable.join(", ")}.` : text,
+					{
 						version: 1,
 						capability: params.capability,
 						requestedToolNames: requested,
 						addedToolNames,
 					},
-				};
+					signal,
+				);
 			},
 		});
 	}
 
+	async function boundedResult(text: string, details: LoadToolsDetails, signal: AbortSignal | undefined) {
+		const builder = new BoundedTextResultBuilder(temporaryOutput, "head");
+		try {
+			await builder.append(text);
+			signal?.throwIfAborted();
+			const result = await builder.finish();
+			return {
+				content: [{ type: "text" as const, text: result.content }],
+				details: { ...details, overflow: result.overflow },
+			};
+		} catch (error) {
+			await builder.abort();
+			throw error;
+		}
+	}
+
 	function restoreActiveTools(
 		pi: ExtensionAPI,
 		current: readonly string[],
@@ -131,16 +198,18 @@ function formatGroupCatalog(groups: readonly DeferredToolGroupInfo[]): string {
 	return ` Registered groups: ${catalog}.`;
 }
 
-function loadedCapabilities(entries: readonly unknown[]): Set<string> {
+function loadedCapabilities(entries: readonly SessionEntry[], groups: readonly DeferredToolGroupInfo[]): Set<string> {
 	const loaded = new Set<string>();
-	for (const value of entries) {
-		if (!value || typeof value !== "object") continue;
-		const entry = value as Record<string, unknown>;
-		if (entry.type !== "message" || !entry.message || typeof entry.message !== "object") continue;
-		const message = entry.message as Record<string, unknown>;
+	for (const entry of entries) {
+		if (entry.type === "custom" && entry.customType === APPLIED_TYPE) {
+			const { names } = entry.data as AppliedLoad;
+			for (const group of groups) if (group.toolNames.some((name) => names.includes(name))) loaded.add(group.id);
+		}
+		if (entry.type !== "message") continue;
+		const message = entry.message;
 		if (message.role !== "toolResult" || message.toolName !== "load_tools" || message.isError === true) continue;
 		if (!isLoadToolsDetails(message.details)) continue;
-		loaded.add(message.details.capability);
+		if (message.details.addedToolNames.length > 0) loaded.add(message.details.capability);
 	}
 	return loaded;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.42.2",
+	"version": "0.43.0",
 	"description": "Tau is a custom agentic harness built with pi extensions",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -35,7 +35,7 @@
 	],
 	"dependencies": {
 		"@ast-grep/wasm": "0.45.3",
-		"@shanepadgett/tau-tui": "0.42.2",
+		"@shanepadgett/tau-tui": "0.43.0",
 		"@vscode/tree-sitter-wasm": "0.3.1",
 		"image-size": "2.0.4",
 		"smol-toml": "1.8.0",

package/schemas/tau.schema.json

@@ -12,64 +12,6 @@
 		"extensions": {
 			"type": "object",
 			"properties": {
-				"autoCompact": {
-					"type": "object",
-					"properties": {
-						"enabled": {
-							"type": "boolean",
-							"default": true,
-							"description": "Enable automatic compaction when context reaches the token limit."
-						},
-						"tokenLimit": {
-							"type": "integer",
-							"minimum": 1,
-							"default": 175000,
-							"description": "Absolute context-token count that triggers compaction before the next model turn."
-						}
-					},
-					"additionalProperties": false
-				},
-				"context": {
-					"type": "object",
-					"properties": {
-						"sync": {
-							"type": "object",
-							"properties": {
-								"enabled": {
-									"type": "boolean",
-									"default": true,
-									"description": "Master switch for context-sync. When false: no /context-sync, parent cannot call the agent, validation does not auto-run sync."
-								},
-								"automation": {
-									"type": "boolean",
-									"default": true,
-									"description": "When true with sync.enabled, the coding agent may call context-sync. When false, only manual /context-sync (validation auto-run still allowed if validation.enabled)."
-								}
-							},
-							"additionalProperties": false
-						},
-						"validation": {
-							"type": "object",
-							"properties": {
-								"enabled": {
-									"type": "boolean",
-									"default": false,
-									"description": "Validate context membership after agent turns and auto-run context-sync on failure (requires sync.enabled)."
-								},
-								"ignoreGlobs": {
-									"type": "array",
-									"items": {
-										"type": "string"
-									},
-									"default": [],
-									"description": "Project-relative files excluded from context membership validation and sync."
-								}
-							},
-							"additionalProperties": false
-						}
-					},
-					"additionalProperties": false
-				},
 				"explore": {
 					"type": "object",
 					"properties": {
@@ -249,52 +191,6 @@
 					},
 					"additionalProperties": false
 				},
-				"soul": {
-					"type": "object",
-					"required": [
-						"overseer"
-					],
-					"properties": {
-						"overseer": {
-							"type": "object",
-							"required": [
-								"enabled",
-								"toolCallInterval"
-							],
-							"properties": {
-								"enabled": {
-									"type": "boolean",
-									"default": true,
-									"description": "Run hidden primary-directive reviews during long tool-using work."
-								},
-								"toolCallInterval": {
-									"type": "integer",
-									"minimum": 1,
-									"maximum": 100,
-									"default": 20,
-									"description": "Unreviewed tool calls required before the next primary-directive review."
-								}
-							},
-							"additionalProperties": false
-						}
-					},
-					"additionalProperties": false
-				},
-				"subagent": {
-					"type": "object",
-					"properties": {
-						"disabled": {
-							"type": "array",
-							"items": {
-								"type": "string",
-								"minLength": 1
-							},
-							"default": [],
-							"description": "Agent names unavailable for delegation."
-						}
-					},
-					"additionalProperties": false
-				},
 				"toolApproval": {
 					"type": "object",
 					"properties": {

package/shared/bounded-text-result.ts

@@ -63,7 +63,6 @@ export class BoundedTextResultBuilder {
 		this.strategy = strategy;
 	}
 
-	// fallow-ignore-next-line unused-class-member -- head/tail strategy API; callers use completeBlocks today
 	async append(text: string): Promise<void> {
 		if (this.strategy === "completeBlocks") throw new Error("Complete-block results require appendBlock");
 		this.requireOpen();

package/shared/events.ts

@@ -1,9 +1,26 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { ModelEffort } from "./model-effort.ts";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Tool } from "@earendil-works/pi-ai";
 import type { ToolRowVisualState } from "./tool-row-state.js";
 import type { FileInjectionRequest, PreparedFileInjection } from "../src/file-injection/index.ts";
 
 export type TauAgentEvents = {
+	/** @internal Soul's runtime-scoped prompt contributors. */
+	"tau:prompt.sources": {
+		accept(source: {
+			key: string;
+			section: string;
+			refresh: "compaction" | "append";
+			read(ctx: ExtensionContext): Promise<string>;
+		}): void;
+	};
+	/** @internal Check a tool loadout before activation. */
+	"tau:prompt.tools.check": {
+		ctx: ExtensionContext;
+		tools: Tool[];
+		reject(reason: string): void;
+	};
+	/** @internal Exact projected Soul instructions, for prompt viewers. */
+	"tau:prompt.snapshot": { text: string };
 	"tau:agent.blocked": {
 		title?: string;
 		body?: string;
@@ -16,15 +33,6 @@ export type TauAgentEvents = {
 		id: string;
 		disposition: "notify" | "discard";
 	};
-	/** Pause silent post-edit checks across a compact that will resume the same work chain. */
-	"tau:silent-command-runner.pause": {
-		id: string;
-	};
-	/** End a silent-check pause. continue keeps the chain open; settle finalizes a deferred settle. */
-	"tau:silent-command-runner.resume": {
-		id: string;
-		disposition: "continue" | "settle";
-	};
 	"tau:file-mutation.applied": {
 		source: "patch";
 		toolCallId: string;
@@ -54,10 +62,6 @@ export type TauAgentEvents = {
 		text?: string;
 		priority?: number;
 	};
-	"tau:model-effort.changed": {
-		effort: ModelEffort | undefined;
-	};
-	"tau:model-effort.snapshot.requested": Record<string, never>;
 	"tau:tool-row-state.set": {
 		rowId: string;
 		state?: ToolRowVisualState;

package/shared/isolated-session.ts

@@ -158,7 +158,6 @@ export async function createIsolatedSessionResource(
 			modelRuntime,
 			thinkingLevel: inputs.thinkingLevel,
 			tools: [...inputs.tools],
-			excludeTools: ["subagent"],
 			resourceLoader,
 			customTools: [...inputs.customTools],
 			sessionManager: SessionManager.inMemory(inputs.cwd),
@@ -169,7 +168,7 @@ export async function createIsolatedSessionResource(
 		if (signal.aborted) throw new Error(`${inputs.label} startup aborted`);
 		const active = session.getActiveToolNames().sort();
 		const expected = [...inputs.tools].sort();
-		if (active.join("\0") !== expected.join("\0") || active.includes("subagent")) {
+		if (active.join("\0") !== expected.join("\0")) {
 			const missing = expected.filter((tool) => !active.includes(tool));
 			throw new Error(
 				`${inputs.label} startup failed: unavailable tools: ${missing.join(", ") || "active tool mismatch"}`,

package/shared/model-effort.ts

@@ -33,47 +33,41 @@ const MODEL_PREFERENCES: Record<ModelEffort, readonly ProviderPreference[]> = {
 	quick: [
 		{
 			provider: "openai-codex",
-			models: [{ model: "gpt-5.6-luna", reasoning: "medium" }],
+			models: [
+				{ model: "gpt-6-luna", reasoning: "medium" },
+				{ model: "gpt-5.6-luna", reasoning: "medium" },
+			],
 		},
-		{ provider: "xai", models: [{ model: "grok-4.5", reasoning: "medium" }] },
-		{ provider: "anthropic", models: [{ model: "claude-haiku-4-5", reasoning: "high" }] },
+		{ provider: "xai", models: [{ model: "grok-4.7", reasoning: "medium" }] },
+		{ provider: "anthropic", models: [{ model: "claude-sonnet-5", reasoning: "medium" }] },
 	],
 	standard: [
 		{
 			provider: "openai-codex",
-			models: [{ model: "gpt-5.6-luna", reasoning: "max" }],
+			models: [
+				{ model: "gpt-6-sol", reasoning: "high" },
+				{ model: "gpt-6-luna", reasoning: "max" },
+				{ model: "gpt-5.6-luna", reasoning: "max" },
+			],
 		},
-		{ provider: "xai", models: [{ model: "grok-4.5", reasoning: "high" }] },
+		{ provider: "xai", models: [{ model: "grok-4.7", reasoning: "high" }] },
 		{ provider: "anthropic", models: [{ model: "claude-sonnet-5", reasoning: "high" }] },
 	],
 	deep: [
 		{
 			provider: "openai-codex",
-			models: [{ model: "gpt-5.6-sol", reasoning: "high" }],
+			models: [{ model: "gpt-6-astra", reasoning: "medium" }],
 		},
 		{
 			provider: "anthropic",
 			models: [
-				{ model: "claude-opus-5", reasoning: "high" },
-				{ model: "claude-fable-5", reasoning: "low" },
+				{ model: "claude-opus-5.5", reasoning: "medium" },
+				{ model: "claude-fable-5.1", reasoning: "low" },
 			],
 		},
 	],
 };
 
-export function effortForSelection(
-	provider: string | undefined,
-	model: string | undefined,
-	reasoning: string | undefined,
-): ModelEffort | undefined {
-	if (!provider || !model || !reasoning) return undefined;
-	for (const effort of ["deep", "standard", "quick"] as const) {
-		const preference = MODEL_PREFERENCES[effort].find((item) => item.provider === provider);
-		if (preference?.models.some((item) => item.model === model && item.reasoning === reasoning)) return effort;
-	}
-	return undefined;
-}
-
 export function resolveEffortProviders(
 	ctx: Pick<ExtensionContext, "modelRegistry">,
 	effort: ModelEffort,

package/shared/prompt-contributions.ts

@@ -0,0 +1,24 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { emitTauEvent, onTauEventImmediately, type TauAgentEvents } from "./events.ts";
+
+type PromptSource = Parameters<TauAgentEvents["tau:prompt.sources"]["accept"]>[0];
+
+export type PromptValue = Pick<PromptSource, "key" | "section" | "refresh"> & { text: string };
+
+export function collectPromptSources(pi: ExtensionAPI): PromptSource[] {
+	const sources: PromptSource[] = [];
+	emitTauEvent(pi, "tau:prompt.sources", { accept: (source) => sources.push(source) });
+	const keys = new Set<string>();
+	for (const source of sources) {
+		if (keys.has(source.key)) throw new Error(`Duplicate prompt source: ${source.key}`);
+		keys.add(source.key);
+	}
+	return sources.sort((a, b) => a.key.localeCompare(b.key, "en"));
+}
+
+export function registerPromptSource(pi: ExtensionAPI, source: PromptSource): void {
+	if (!/^[a-z][a-z0-9/-]*$/.test(source.key) || !/^[a-z][a-z0-9-]*$/.test(source.section)) {
+		throw new Error(`Invalid prompt source: ${source.key}`);
+	}
+	onTauEventImmediately(pi, `prompt.${source.key}`, "tau:prompt.sources", ({ accept }) => accept(source));
+}

package/src/index.ts

@@ -5,5 +5,5 @@ export {
 	type ImageGenerationContext,
 	type ImageProvider,
 } from "./image-generation/index.ts";
-export { FILE_INJECTION_TYPE, prepareFileInjection } from "./file-injection/index.ts";
+export { prepareFileInjection } from "./file-injection/index.ts";
 export { registerDeferredToolGroup, type DeferredToolGroup } from "./tool-loading/index.ts";

package/docs/subagents.md

@@ -1,92 +0,0 @@
-# Custom subagents
-
-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 complete child conversation for five minutes after the latest child response. A later follow-up keeps the same thread, agent, model, thinking level, tools, and cwd, but starts a clean child session. Tau supplies prior tasks, exact terminal results, and paths passed through `files`; it does not run a summarization request. Old source, tool history, intermediate responses, and thinking are absent, so the child reads current source before relying on a retained path. Start fresh for unrelated work. Tau keeps up to 16 threads and evicts the least recently used idle thread when needed.
-
-If the relevant files are already known, autoread them into a fresh or retained child turn:
-
-```text
-subagent({ agent: "scout", task: "Trace the runtime change", files: ["src/runtime.ts", "test/runtime.test.ts"] })
-```
-
-Paths may be relative to the parent's current working directory or absolute. Tau reads current, line-numbered snapshots when the turn starts. Unreadable files produce failed context entries without stopping the child. Keep the list focused because complete snapshots consume the child's context window.
-
-## Where definitions live
-
-| Scope | Path | Use when |
-| --- | --- | --- |
-| **User (global)** | `~/.pi/agent/tau/agents/*.md` | You want the agent in every project |
-| **Project** | nearest trusted `.pi/tau/agents/*.md` | Repo-specific helpers |
-
-Precedence: **project overrides user**, which overrides Tau's built-ins (`scout`, `web-research`). Duplicate names in one scope are invalid.
-
-## Definition format
-
-Markdown with frontmatter:
-
-```markdown
----
-name: api-reader
-description: Inspect API declarations and usage
-tools:
-  - read
-  - grep
-names:
-  - Ledger
-  - Quill
-  - Beacon
-model: openai-codex/gpt-5.4-mini
-thinking: medium
----
-
-Stay within the delegated task. Return exact paths and symbols.
-```
-
-Required:
-
-- `name`
-- `description`
-- `tools` (unique tool names; `subagent` cannot be delegated)
-
-Optional:
-
-- `names`: a non-empty list of unique display names
-- `model` as `provider/model`
-- `thinking`: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, or `max`
-
-Named tools and configured models must exist in the normally loaded child Pi environment (including tools from installed packages such as Tau).
-
-Tau assigns one display name to each fresh child and keeps it for follow-up turns on that thread. It cycles through the list in order. When the list wraps, reused names get numeric suffixes such as `Ledger-2`, so any number of concurrent children can still have distinct names. Without `names`, the agent name is used as a one-item pool.
-
-## Runtime rules
-
-- Run `/agents` to enable or disable agents for the current session branch. Press Space to stage each toggle, then Enter to apply the changes. Session choices do not change Tau settings.
-- Set `extensions.subagent.disabled` to an array of agent names for persistent global or project-level disabling. Agents disabled this way appear as `disabled by Tau settings` in `/agents` and cannot be enabled there.
-- Disabled agents are omitted from the parent's available-agent list and cannot start or continue a retained thread.
-- Children use the parent's cwd and inherit model/thinking unless the definition overrides them.
-- Children do not receive the parent conversation.
-- Calls can include `files` to autoread line-numbered snapshots into that child turn.
-- Follow-up calls within five minutes reuse the complete child conversation. Colder calls resume from exact prior results and relevant paths in a clean session.
-- Cold resume keeps the selected model, thinking level, tools, cwd, definition, display name, and thread ID.
-- 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.
-- Display names identify children in Tau's tool rows and cmux dashboard; thread IDs remain the identifiers used for continuation calls.
-- Returned text is capped (50 KB / 2,000 lines); full truncated output is saved to a private temp file.
-- Interactive cmux sessions get one temporary Markdown dashboard for waiting and running invocations. It is observational only: cmux latency or failure cannot delay, fail, or reorder children. The dashboard closes shortly after the active cohort finishes. Print mode never opens it.
-
-## Built-ins
-
-- `scout` — substantial multi-hop local code lookup that would chew parent context; paths, declarations, imports, references, call edges; facts only. Skip small digs
-- `web-research` — `websearch`, `codesearch`, `webfetch`
-- `context-sync` — maps meaningful uncommitted work into `.pi/contexts`. Offered to the coding agent when `extensions.context.sync.enabled` and `sync.automation` are true. Manual `/context-sync` remains when sync is enabled with `automation` false. Validation can auto-run it when `validation.enabled` and `sync.enabled`
-
-Ask Tau to delegate, or let it call `subagent` with an agent name and task.

package/extensions/auto-compact/README.md

@@ -1,9 +0,0 @@
-# Auto Compact
-
-Compacts long conversations before the next model turn when their context reaches an absolute token limit. Active work resumes through a hidden continuation message after Pi's native compaction finishes.
-
-Set `extensions.autoCompact.enabled` to `false` to turn automatic compaction off. Set `extensions.autoCompact.tokenLimit` to change the limit. It defaults to 175,000 context tokens for every model. Pi still shows its native collapsed compaction entry in the chat.
-
-After changing this extension, run `/reload` before testing it.
-
-Automatic compaction holds attention notifications while it runs and while the hidden continuation resumes the interrupted work. The notification is released only after that resumed work settles. It also pauses silent post-edit checks across the compact so they do not run on incomplete work.