taskplane 0.28.2 → 0.28.4

package/extensions/taskplane/agent-bridge-extension.ts

@@ -27,6 +27,7 @@ import { writeFileSync, readFileSync, existsSync, mkdirSync, renameSync, unlinkS
 import { join, dirname } from "path";
 import { spawn as nodeSpawn } from "child_process";
 import { resolvePiCliPath, resolveTaskplaneAgentTemplate } from "./path-resolver.ts";
+import { loadPiSettingsPackages, filterExcludedExtensions } from "./settings-loader.ts";
 import { randomBytes } from "crypto";
 import { buildExpansionRequestId, type SegmentExpansionRequest } from "./types.ts";
 
@@ -445,6 +446,27 @@ export default function (pi: ExtensionAPI) {
 			];
 			if (reviewerModel) args.push("--model", reviewerModel);
 			if (reviewerThinking) args.push("--thinking", reviewerThinking);
+
+			// TP-180: Forward user-installed extensions to reviewer agent
+			// Use TASKPLANE_STATE_ROOT (canonical project root) for settings resolution,
+			// falling back to cwd (which may be a worktree without .pi/settings.json).
+			const settingsRoot = process.env.TASKPLANE_STATE_ROOT || cwd;
+			const reviewerPackages = loadPiSettingsPackages(settingsRoot);
+			// Apply reviewer-specific exclusions from config (JSON array via env)
+			let reviewerExclusions: string[] = [];
+			try {
+				const rawExclude = process.env.TASKPLANE_REVIEWER_EXCLUDE_EXTENSIONS;
+				if (rawExclude) {
+					const parsed = JSON.parse(rawExclude);
+					if (Array.isArray(parsed)) {
+						reviewerExclusions = parsed.filter((v: unknown): v is string => typeof v === "string");
+					}
+				}
+			} catch { /* ignore malformed */ }
+			const filteredReviewerPackages = filterExcludedExtensions(reviewerPackages, reviewerExclusions);
+			for (const pkg of filteredReviewerPackages) {
+				args.push("-e", pkg);
+			}
 			const proc = nodeSpawn(process.execPath, args, {
 				shell: false,
 				cwd,

package/extensions/taskplane/config-loader.ts

@@ -1125,6 +1125,7 @@ export function toOrchestratorConfig(config: TaskplaneConfig): import("./types.t
 			verify: [...o.merge.verify],
 			order: o.merge.order,
 			timeout_minutes: o.merge.timeoutMinutes ?? 90,
+			exclude_extensions: [...(o.merge.excludeExtensions ?? [])],
 		},
 		failure: {
 			on_task_failure: o.failure.onTaskFailure,
@@ -1183,7 +1184,9 @@ export function toTaskRunnerConfig(config: TaskplaneConfig): import("./types.ts"
 			model: config.taskRunner.reviewer.model,
 			thinking: config.taskRunner.reviewer.thinking,
 			tools: config.taskRunner.reviewer.tools,
+			excludeExtensions: [...(config.taskRunner.reviewer.excludeExtensions ?? [])],
 		},
+		workerExcludeExtensions: [...(config.taskRunner.worker.excludeExtensions ?? [])],
 	};
 }
 

package/extensions/taskplane/config-schema.ts

@@ -111,6 +111,8 @@ export interface WorkerConfig {
 	thinking: string;
 	/** Optional spawn mode override for task-runner (Runtime V2 subprocess-only). */
 	spawnMode?: "subprocess";
+	/** Package specifiers to exclude from extension forwarding for worker agents (exact match). @since TP-180 */
+	excludeExtensions?: string[];
 }
 
 /** Reviewer agent configuration */
@@ -121,6 +123,8 @@ export interface ReviewerConfig {
 	tools: string;
 	/** Thinking mode for reviewer */
 	thinking: string;
+	/** Package specifiers to exclude from extension forwarding for reviewer agents (exact match). @since TP-180 */
+	excludeExtensions?: string[];
 }
 
 /** Context/resource limits for task execution */
@@ -310,6 +314,8 @@ export interface MergeConfig {
 	order: "fewest-files-first" | "sequential";
 	/** Merge-agent timeout in minutes */
 	timeoutMinutes?: number;
+	/** Package specifiers to exclude from extension forwarding for merge agents (exact match). @since TP-180 */
+	excludeExtensions?: string[];
 }
 
 /** Failure policy settings */
@@ -588,8 +594,8 @@ export const DEFAULT_TASK_RUNNER_SECTION: TaskRunnerSection = {
 	testing: { commands: {} },
 	standards: { docs: [], rules: [] },
 	standardsOverrides: {},
-	worker: { model: "", tools: "read,write,edit,bash,grep,find,ls", thinking: "" },
-	reviewer: { model: "", tools: "read,bash,grep,find,ls", thinking: "on" },
+	worker: { model: "", tools: "read,write,edit,bash,grep,find,ls", thinking: "", excludeExtensions: [] },
+	reviewer: { model: "", tools: "read,bash,grep,find,ls", thinking: "on", excludeExtensions: [] },
 	context: {
 		workerContextWindow: 0,
 		warnPercent: 85,
@@ -645,6 +651,7 @@ export const DEFAULT_ORCHESTRATOR_SECTION: OrchestratorSection = {
 		verify: [],
 		order: "fewest-files-first",
 		timeoutMinutes: 90,
+		excludeExtensions: [],
 	},
 	failure: {
 		onTaskFailure: "skip-dependents",

package/extensions/taskplane/engine.ts

@@ -6,7 +6,7 @@ import { existsSync, readdirSync, readFileSync, renameSync, unlinkSync } from "f
 import { join, resolve } from "path";
 
 import { formatDiscoveryResults, runDiscovery } from "./discovery.ts";
-import { buildReviewerEnv, computeTransitiveDependents, execLog, executeLaneV2, executeWave, killV2LaneAgents, resolveCanonicalTaskPaths } from "./execution.ts";
+import { buildReviewerEnv, buildWorkerExcludeEnv, computeTransitiveDependents, execLog, executeLaneV2, executeWave, killV2LaneAgents, resolveCanonicalTaskPaths } from "./execution.ts";
 import type { RuntimeBackend } from "./execution.ts";
 import type { MonitorUpdateCallback } from "./execution.ts";
 // classifyExit no longer called directly — Tier 0 uses exitDiagnostic.classification
@@ -1381,7 +1381,7 @@ async function attemptWorkerCrashRetry(
 				retryPauseSignal,
 				wsRoot,
 				isWsMode,
-				{ ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig?.reviewer) }, // TP-089: ensure mailbox works for retries
+				{ ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig?.reviewer), ...buildWorkerExcludeEnv(runnerConfig?.workerExcludeExtensions) }, // TP-089: ensure mailbox works for retries
 			);
 
 			const retryOutcome = retryResult.tasks[0];
@@ -1640,7 +1640,7 @@ async function attemptModelFallbackRetry(
 			// Pass TASKPLANE_MODEL_FALLBACK=1 as extra env var to signal
 			// the task-runner to use the session model instead of configured model.
 			// TP-089: Also include ORCH_BATCH_ID so mailbox steering works for retries.
-			const modelFallbackEnv = { TASKPLANE_MODEL_FALLBACK: "1", ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig?.reviewer) };
+			const modelFallbackEnv = { TASKPLANE_MODEL_FALLBACK: "1", ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig?.reviewer), ...buildWorkerExcludeEnv(runnerConfig?.workerExcludeExtensions) };
 			const retryResult = await executeLaneV2(
 				retryLane,
 				orchConfig,
@@ -1887,7 +1887,9 @@ async function attemptStaleWorktreeRecovery(
 			model: runnerConfig?.reviewer?.model || "",
 			thinking: runnerConfig?.reviewer?.thinking || "",
 			tools: runnerConfig?.reviewer?.tools || "",
+			excludeExtensions: runnerConfig?.reviewer?.excludeExtensions ?? [],
 		},
+		runnerConfig?.workerExcludeExtensions ?? [],
 	);
 
 	return retryResult;
@@ -2490,7 +2492,9 @@ export async function executeOrchBatch(
 				model: runnerConfig?.reviewer?.model || "",
 				thinking: runnerConfig?.reviewer?.thinking || "",
 				tools: runnerConfig?.reviewer?.tools || "",
+				excludeExtensions: runnerConfig?.reviewer?.excludeExtensions ?? [],
 			},
+			runnerConfig?.workerExcludeExtensions ?? [],
 		);
 
 		// ── TP-039: Tier 0 — Stale worktree recovery ────────────

package/extensions/taskplane/execution.ts

@@ -1754,7 +1754,8 @@ export async function executeWave(
 	runtimeBackend?: RuntimeBackend,
 	onSupervisorAlert?: SupervisorAlertCallback,
 	supervisorAutonomy: "interactive" | "supervised" | "autonomous" = "autonomous",
-	reviewerConfig?: { model?: string; thinking?: string; tools?: string },
+	reviewerConfig?: { model?: string; thinking?: string; tools?: string; excludeExtensions?: string[] },
+	workerExcludeExtensions?: string[],
 ): Promise<WaveExecutionResult> {
 	const startedAt = Date.now();
 	const policy = config.failure.on_task_failure;
@@ -1862,6 +1863,7 @@ export async function executeWave(
 			ORCH_BATCH_ID: batchId,
 			TASKPLANE_SUPERVISOR_AUTONOMY: supervisorAutonomy,
 			...buildReviewerEnv(reviewerConfig),
+			...buildWorkerExcludeEnv(workerExcludeExtensions),
 		}, onSupervisorAlert),
 	);
 
@@ -2503,13 +2505,44 @@ import { executeTaskV2, type LaneRunnerConfig, type LaneRunnerTaskResult } from
  *
  * @since TP-160
  */
+/**
+ * Parse a JSON string array from an env var value, returning empty array on failure.
+ * @since TP-180
+ */
+function parseJsonArrayEnv(value?: string): string[] {
+	if (!value) return [];
+	try {
+		const parsed = JSON.parse(value);
+		if (Array.isArray(parsed)) return parsed.filter((v: unknown): v is string => typeof v === "string");
+	} catch { /* ignore malformed */ }
+	return [];
+}
+
 export function buildReviewerEnv(
-	reviewerConfig?: { model?: string; thinking?: string; tools?: string } | null,
+	reviewerConfig?: { model?: string; thinking?: string; tools?: string; excludeExtensions?: string[] } | null,
 ): Record<string, string> {
 	const env: Record<string, string> = {};
 	if (reviewerConfig?.model) env.TASKPLANE_REVIEWER_MODEL = reviewerConfig.model;
 	if (reviewerConfig?.thinking) env.TASKPLANE_REVIEWER_THINKING = reviewerConfig.thinking;
 	if (reviewerConfig?.tools) env.TASKPLANE_REVIEWER_TOOLS = reviewerConfig.tools;
+	// TP-180: Forward reviewer extension exclusions as JSON array
+	if (reviewerConfig?.excludeExtensions && reviewerConfig.excludeExtensions.length > 0) {
+		env.TASKPLANE_REVIEWER_EXCLUDE_EXTENSIONS = JSON.stringify(reviewerConfig.excludeExtensions);
+	}
+	return env;
+}
+
+/**
+ * Build worker extension exclusion env vars from config.
+ * @since TP-180
+ */
+export function buildWorkerExcludeEnv(
+	workerExcludeExtensions?: string[] | null,
+): Record<string, string> {
+	const env: Record<string, string> = {};
+	if (workerExcludeExtensions && workerExcludeExtensions.length > 0) {
+		env.TASKPLANE_WORKER_EXCLUDE_EXTENSIONS = JSON.stringify(workerExcludeExtensions);
+	}
 	return env;
 }
 
@@ -2606,6 +2639,9 @@ export async function executeLaneV2(
 			reviewerModel: extraEnvVars?.TASKPLANE_REVIEWER_MODEL || "",
 			reviewerThinking: extraEnvVars?.TASKPLANE_REVIEWER_THINKING || "",
 			reviewerTools: extraEnvVars?.TASKPLANE_REVIEWER_TOOLS || "",
+			// TP-180: Extension exclusion lists from config
+			workerExcludeExtensions: parseJsonArrayEnv(extraEnvVars?.TASKPLANE_WORKER_EXCLUDE_EXTENSIONS),
+			reviewerExcludeExtensions: parseJsonArrayEnv(extraEnvVars?.TASKPLANE_REVIEWER_EXCLUDE_EXTENSIONS),
 			supervisorAutonomy,
 			projectName: config.project?.name || "project",
 			maxIterations: 20,

package/extensions/taskplane/lane-runner.ts

@@ -33,6 +33,7 @@ import {
 } from "./task-executor-core.ts";
 
 import { spawnAgent, type AgentHostOptions, type AgentHostResult } from "./agent-host.ts";
+import { loadPiSettingsPackages, filterExcludedExtensions } from "./settings-loader.ts";
 
 import {
 	appendAgentEvent,
@@ -222,6 +223,10 @@ export interface LaneRunnerConfig {
 	supervisorAutonomy?: "interactive" | "supervised" | "autonomous";
 	/** Project name (for review request context) */
 	projectName?: string;
+	/** Package specifiers to exclude from worker extension forwarding (exact match). @since TP-180 */
+	workerExcludeExtensions?: string[];
+	/** Package specifiers to exclude from reviewer extension forwarding (exact match). @since TP-180 */
+	reviewerExcludeExtensions?: string[];
 	/** Max worker iterations before giving up */
 	maxIterations: number;
 	/** No-progress stall limit */
@@ -555,6 +560,10 @@ export async function executeTaskV2(
 		const outboxDir = join(config.stateRoot, ".pi", "mailbox", config.batchId, workerAgentId, "outbox");
 		const bridgeExtensionPath = join(LANE_RUNNER_DIR, "agent-bridge-extension.ts");
 
+		// TP-180: Forward user-installed extensions to worker agent
+		const allPackages = loadPiSettingsPackages(config.stateRoot);
+		const workerPackages = filterExcludedExtensions(allPackages, config.workerExcludeExtensions ?? []);
+
 		const hostOpts: AgentHostOptions = {
 			agentId: workerAgentId,
 			role: "worker",
@@ -577,7 +586,7 @@ export async function executeTaskV2(
 			timeoutMs: config.maxWorkerMinutes * 60_000,
 			stateRoot: config.stateRoot,
 			packet: unit.packet,
-			extensions: [bridgeExtensionPath],
+			extensions: [bridgeExtensionPath, ...workerPackages],
 			env: {
 				TASKPLANE_OUTBOX_DIR: outboxDir,
 				TASKPLANE_AGENT_ID: workerAgentId,
@@ -597,6 +606,11 @@ export async function executeTaskV2(
 				...(config.reviewerModel ? { TASKPLANE_REVIEWER_MODEL: config.reviewerModel } : {}),
 				...(config.reviewerThinking ? { TASKPLANE_REVIEWER_THINKING: config.reviewerThinking } : {}),
 				...(config.reviewerTools ? { TASKPLANE_REVIEWER_TOOLS: config.reviewerTools } : {}),
+				// TP-180: Pass state root and reviewer exclusions for extension forwarding
+				TASKPLANE_STATE_ROOT: config.stateRoot,
+				...(config.reviewerExcludeExtensions && config.reviewerExcludeExtensions.length > 0
+					? { TASKPLANE_REVIEWER_EXCLUDE_EXTENSIONS: JSON.stringify(config.reviewerExcludeExtensions) }
+					: {}),
 			},
 			// TP-172: Exit interception callback — escalate to supervisor when worker
 			// exits without making visible progress (no checkboxes, no blocker logged).

package/extensions/taskplane/merge.ts

@@ -21,6 +21,7 @@ import { loadOrchestratorConfig } from "./config.ts";
 import { captureBaseline, diffFingerprints, runVerificationCommands, parseTestOutput, deduplicateFingerprints } from "./verification.ts";
 import { spawnAgent } from "./agent-host.ts";
 import type { AgentHostOptions, AgentHostResult, AgentTelemetryCallback } from "./agent-host.ts";
+import { loadPiSettingsPackages, filterExcludedExtensions } from "./settings-loader.ts";
 import type { RuntimeBackend } from "./execution.ts";
 import type { VerificationBaseline, FingerprintDiff, TestFingerprint } from "./verification.ts";
 
@@ -716,6 +717,12 @@ export async function spawnMergeAgentV2(
 		mkdirSync(join(mailboxDir, "inbox"), { recursive: true });
 	}
 
+	// TP-180: Forward user-installed extensions to merge agent
+	const mergeStateRoot = stateRoot ?? repoRoot;
+	const allMergePackages = loadPiSettingsPackages(mergeStateRoot);
+	const mergeExclusions = config.merge.exclude_extensions ?? [];
+	const mergePackages = filterExcludedExtensions(allMergePackages, mergeExclusions);
+
 	const opts: AgentHostOptions = {
 		agentId: sessionName,
 		role: "merger",
@@ -733,8 +740,9 @@ export async function spawnMergeAgentV2(
 		eventsPath,
 		exitSummaryPath,
 		timeoutMs: (config.merge.timeout_minutes ?? 10) * 60 * 1000,
-		stateRoot: stateRoot ?? repoRoot,
+		stateRoot: mergeStateRoot,
 		packet: null,
+		...(mergePackages.length > 0 ? { extensions: mergePackages } : {}),
 		env: {
 			ORCH_BATCH_ID: bid,
 		},
@@ -748,7 +756,6 @@ export async function spawnMergeAgentV2(
 	}
 	const mergeNumber = mergeNumberMatch ? parseInt(mergeNumberMatch[1], 10) : 1;
 	const mergeStartedAt = Date.now();
-	const mergeStateRoot = stateRoot ?? repoRoot;
 
 	// Helper: build a RuntimeAgentTelemetrySnapshot from a partial AgentHostResult.
 	const buildAgentSnap = (tel: Partial<AgentHostResult>, status: RuntimeAgentTelemetrySnapshot["status"]): RuntimeAgentTelemetrySnapshot => ({

package/extensions/taskplane/resume.ts

@@ -8,7 +8,7 @@ import { join } from "path";
 import { assembleDiagnosticInput, emitDiagnosticReports } from "./diagnostic-reports.ts";
 import { runDiscovery } from "./discovery.ts";
 import { executeOrchBatch, resolveDisplayWaveNumber } from "./engine.ts";
-import { buildReviewerEnv, computeTransitiveDependents, execLog, executeLaneV2, executeWave, resolveCanonicalTaskPaths } from "./execution.ts";
+import { buildReviewerEnv, buildWorkerExcludeEnv, computeTransitiveDependents, execLog, executeLaneV2, executeWave, resolveCanonicalTaskPaths } from "./execution.ts";
 import type { MonitorUpdateCallback, RuntimeBackend } from "./execution.ts";
 import { selectRuntimeBackend } from "./engine.ts";
 import { readRegistrySnapshot, isTerminalStatus, isProcessAlive } from "./process-registry.ts";
@@ -1506,7 +1506,7 @@ export async function resumeOrchBatch(
 				const laneResult = await executeLaneV2(
 					lane, orchConfig, laneRepoRoot, batchState.pauseSignal,
 					workspaceRoot, !!workspaceConfig,
-					{ ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig.reviewer) },
+					{ ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig.reviewer), ...buildWorkerExcludeEnv(runnerConfig.workerExcludeExtensions) },
 					emitAlert,
 				);
 				const taskResult = laneResult.tasks.find(t => t.taskId === task.taskId);
@@ -1588,7 +1588,7 @@ export async function resumeOrchBatch(
 				const laneResult = await executeLaneV2(
 					lane, orchConfig, reExecRepoRoot, batchState.pauseSignal,
 					workspaceRoot, !!workspaceConfig,
-					{ ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig.reviewer) },
+					{ ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig.reviewer), ...buildWorkerExcludeEnv(runnerConfig.workerExcludeExtensions) },
 					emitAlert,
 				);
 				const taskResult = laneResult.tasks.find(t => t.taskId === task.taskId);
@@ -2048,6 +2048,7 @@ export async function resumeOrchBatch(
 			emitAlert,
 			supervisorAutonomy,
 			runnerConfig.reviewer,
+			runnerConfig.workerExcludeExtensions ?? [],
 		);
 
 		batchState.waveResults.push(waveResult);

package/extensions/taskplane/settings-loader.ts

@@ -0,0 +1,136 @@
+/**
+ * Settings Loader — Read and merge Pi extension packages from settings files
+ *
+ * Reads `.pi/settings.json` from both project-level and global locations,
+ * extracts the `packages` arrays, merges them (project entries first,
+ * deduplicated), and filters out taskplane itself.
+ *
+ * Used by spawn points (worker, reviewer, merge agent) to forward
+ * user-installed extensions as explicit `-e` flags alongside `--no-extensions`.
+ *
+ * @module taskplane/settings-loader
+ * @since TP-180
+ */
+
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// ── Constants ────────────────────────────────────────────────────────
+
+/** Subpath under a project root for the project-level Pi settings file. */
+const PROJECT_SETTINGS_SUBPATH = join(".pi", "settings.json");
+
+/** Subpath under the global agent dir for the global Pi settings file. */
+const GLOBAL_SETTINGS_SUBPATH = join(".pi", "agent", "settings.json");
+
+// ── Internal Helpers ─────────────────────────────────────────────────
+
+/**
+ * Safely read and parse a JSON file, returning null on any failure.
+ */
+function readJsonSafe(filePath: string): Record<string, unknown> | null {
+	try {
+		const raw = readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+			return parsed as Record<string, unknown>;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Extract the `packages` array from a parsed settings object.
+ * Returns an empty array if the key is missing or not an array of strings.
+ */
+function extractPackages(settings: Record<string, unknown> | null): string[] {
+	if (!settings) return [];
+	const packages = settings.packages;
+	if (!Array.isArray(packages)) return [];
+	// Filter to strings only, skip non-string entries gracefully
+	return packages.filter((p): p is string => typeof p === "string" && p.length > 0);
+}
+
+/**
+ * Resolve the global Pi agent settings path.
+ *
+ * Resolution order:
+ *   1. `PI_CODING_AGENT_DIR` env → `<value>/settings.json`
+ *   2. `os.homedir()/.pi/agent/settings.json`
+ */
+function resolveGlobalSettingsPath(): string {
+	const agentDir = process.env.PI_CODING_AGENT_DIR;
+	if (agentDir) {
+		return join(agentDir, "settings.json");
+	}
+	return join(homedir(), GLOBAL_SETTINGS_SUBPATH);
+}
+
+// ── Public API ───────────────────────────────────────────────────────
+
+/**
+ * Load Pi extension packages from project and global settings files.
+ *
+ * Reads `.pi/settings.json` from the project root (stateRoot) and from
+ * the global agent directory, merges the package lists (project first,
+ * deduplicated), and filters out any package containing "taskplane"
+ * (which is already loaded as the bridge extension).
+ *
+ * @param stateRoot - Project root directory (used to locate `.pi/settings.json`)
+ * @returns Array of package specifiers (e.g., `["npm:pi-sage"]`) or empty array
+ */
+export function loadPiSettingsPackages(stateRoot: string): string[] {
+	// Read project-level packages
+	const projectSettingsPath = join(stateRoot, PROJECT_SETTINGS_SUBPATH);
+	const projectSettings = readJsonSafe(projectSettingsPath);
+	const projectPackages = extractPackages(projectSettings);
+
+	// Read global packages
+	const globalSettingsPath = resolveGlobalSettingsPath();
+	const globalSettings = readJsonSafe(globalSettingsPath);
+	const globalPackages = extractPackages(globalSettings);
+
+	// Merge: project entries first, then global, deduplicated
+	const seen = new Set<string>();
+	const merged: string[] = [];
+
+	for (const pkg of projectPackages) {
+		if (!seen.has(pkg)) {
+			seen.add(pkg);
+			merged.push(pkg);
+		}
+	}
+	for (const pkg of globalPackages) {
+		if (!seen.has(pkg)) {
+			seen.add(pkg);
+			merged.push(pkg);
+		}
+	}
+
+	// Filter out taskplane itself (already loaded as bridge extension).
+	// Match known specifier patterns: "npm:taskplane", "taskplane", or scoped
+	// variants like "npm:@scope/taskplane". Avoid substring matching to prevent
+	// false positives on unrelated packages containing "taskplane" in their name.
+	return merged.filter((pkg) => {
+		// Strip npm:/git: prefix to get the bare package name
+		const bare = pkg.replace(/^(?:npm:|git:(?:github\.com\/[^/]+\/)?)/, "").toLowerCase();
+		// Exact match on bare name, or scoped exact match (@scope/taskplane)
+		return bare !== "taskplane" && !bare.endsWith("/taskplane");
+	});
+}
+
+/**
+ * Filter out excluded extensions from a package list.
+ *
+ * @param packages - Full list of package specifiers
+ * @param exclusions - Package specifiers to exclude (exact match)
+ * @returns Filtered list with excluded packages removed
+ */
+export function filterExcludedExtensions(packages: string[], exclusions: string[]): string[] {
+	if (!exclusions || exclusions.length === 0) return packages;
+	const excludeSet = new Set(exclusions);
+	return packages.filter((pkg) => !excludeSet.has(pkg));
+}

package/extensions/taskplane/settings-tui.ts

@@ -2,7 +2,7 @@
  * Settings TUI — interactive configuration viewer and editor.
  *
  * Provides a `/taskplane-settings` command that renders a two-level navigation:
- *   1. Section selector (13 sections)
+ *   1. Section selector (14 sections)
  *   2. Per-section SettingsList with field display, source badges,
  *      and inline editing for enum/boolean/string/number fields
  *
@@ -38,6 +38,7 @@ import {
 	resolveConfigRoot,
 	resolveGlobalPreferencesPath,
 } from "./config-loader.ts";
+import { loadPiSettingsPackages } from "./settings-loader.ts";
 
 
 // ── Types ────────────────────────────────────────────────────────────
@@ -87,7 +88,7 @@ export interface SectionDef {
 // ── Section & Field Definitions ──────────────────────────────────────
 
 /**
- * Canonical navigation map — 13 sections.
+ * Canonical navigation map — 14 sections.
  * Order matches the Step 1 design in STATUS.md.
  */
 export const SECTIONS: SectionDef[] = [
@@ -136,6 +137,11 @@ export const SECTIONS: SectionDef[] = [
 			{ configPath: "orchestrator.merge.timeoutMinutes", label: "Merge Timeout (minutes)", control: "input", layer: "L1", fieldType: "number", description: "Max time for merge agent to complete. Increase for large batches (default: 10)" },
 		],
 	},
+	{
+		name: "Agent Extensions",
+		readOnly: true,  // Dynamically handled — no fixed fields
+		fields: [],
+	},
 	{
 		name: "Context Limits",
 		fields: [
@@ -1205,9 +1211,11 @@ async function showSectionSelectorLoop(
 		const sectionItems: SelectItem[] = SECTIONS.map((section, i) => ({
 			value: String(i),
 			label: section.name,
-			description: section.readOnly
-				? "Read-only collection/record fields"
-				: `${section.fields.length} setting${section.fields.length === 1 ? "" : "s"}`,
+			description: section.name === "Agent Extensions"
+				? "Toggle extensions per agent type"
+				: section.readOnly
+					? "Read-only collection/record fields"
+					: `${section.fields.length} setting${section.fields.length === 1 ? "" : "s"}`,
 		}));
 
 		const selectedSection = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
@@ -1252,7 +1260,9 @@ async function showSectionSelectorLoop(
 		const sectionIndex = parseInt(selectedSection, 10);
 		const section = SECTIONS[sectionIndex];
 
-		if (section.readOnly) {
+		if (section.name === "Agent Extensions") {
+			await showExtensionsSection(ctx, configRoot, pointerConfigRoot, onConfigChanged);
+		} else if (section.readOnly) {
 			await showAdvancedSection(ctx, state.mergedConfig);
 		} else {
 			await showSectionSettingsLoop(ctx, section, configRoot, pointerConfigRoot, onConfigChanged);
@@ -1312,6 +1322,142 @@ async function showAdvancedSection(
 	});
 }
 
+/**
+ * TP-180: Agent Extensions section — toggle extensions per agent type.
+ *
+ * Discovers all installed Pi extension packages from project + global settings,
+ * shows per-agent-type toggles (Worker, Reviewer, Merger), and saves
+ * exclusion changes to project taskplane-config.json.
+ */
+async function showExtensionsSection(
+	ctx: ExtensionContext,
+	configRoot: string,
+	pointerConfigRoot?: string,
+	onConfigChanged?: () => void,
+): Promise<void> {
+	while (true) {
+		const resolvedRoot = resolveConfigRoot(configRoot, pointerConfigRoot);
+		const mergedConfig = loadProjectConfig(configRoot, pointerConfigRoot);
+
+		// Discover installed packages (excluding taskplane itself)
+		// Use configRoot (project/state root) for consistency with runtime forwarding,
+		// not resolvedRoot (pointer-resolved config path).
+		const packages = loadPiSettingsPackages(configRoot);
+
+		if (packages.length === 0) {
+			await ctx.ui.custom((_tui, theme, _kb, done) => {
+				const container = new Container();
+				container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+				container.addChild(new Text(theme.fg("accent", theme.bold("Agent Extensions")), 1, 0));
+				container.addChild(new Text("", 0, 0));
+				container.addChild(new Text(theme.fg("dim", "No third-party extensions found."), 1, 0));
+				container.addChild(new Text(theme.fg("dim", "Install extensions via pi settings to see them here."), 1, 0));
+				container.addChild(new Text("", 0, 0));
+				container.addChild(new Text(theme.fg("dim", "esc back"), 1, 0));
+				container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+				return {
+					render: (w: number) => container.render(w),
+					invalidate: () => container.invalidate(),
+					handleInput: (data: string) => { if (data === "\x1b" || data === "\x1b\x1b") done(undefined); },
+				};
+			});
+			return;
+		}
+
+		// Read current exclusion lists
+		const workerExclude = new Set(mergedConfig.taskRunner.worker.excludeExtensions ?? []);
+		const reviewerExclude = new Set(mergedConfig.taskRunner.reviewer.excludeExtensions ?? []);
+		const mergeExclude = new Set(mergedConfig.orchestrator.merge.excludeExtensions ?? []);
+
+		const agentTypes = [
+			{ name: "Worker", exclude: workerExclude, configPath: "taskRunner.worker.excludeExtensions" },
+			{ name: "Reviewer", exclude: reviewerExclude, configPath: "taskRunner.reviewer.excludeExtensions" },
+			{ name: "Merger", exclude: mergeExclude, configPath: "orchestrator.merge.excludeExtensions" },
+		];
+
+		// Build toggle items: one per package per agent type
+		const settingsItems: SettingItem[] = [];
+		for (const pkg of packages) {
+			for (const agentType of agentTypes) {
+				const isExcluded = agentType.exclude.has(pkg);
+				const enabled = !isExcluded;
+				settingsItems.push({
+					id: `${agentType.configPath}::${pkg}`,
+					label: `${pkg}`,
+					currentValue: enabled ? "✅ enabled" : "❌ disabled",
+					description: agentType.name,
+					values: [enabled ? "❌ disabled" : "✅ enabled"],
+				});
+			}
+		}
+
+		const result = await ctx.ui.custom<{ id: string; value: string } | null>((tui, theme, _kb, done) => {
+			const container = new Container();
+			container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+			container.addChild(new Text(theme.fg("accent", theme.bold("Agent Extensions")), 1, 0));
+			container.addChild(new Text(theme.fg("dim", "Toggle extensions on/off per agent type"), 1, 0));
+			container.addChild(new Text("", 0, 0));
+
+			const settingsList = new SettingsList(
+				settingsItems,
+				Math.min(settingsItems.length + 2, 20),
+				getSettingsListTheme(),
+				(id, newValue) => done({ id, value: newValue }),
+				() => done(null),
+			);
+			container.addChild(settingsList);
+
+			container.addChild(new Text("", 0, 0));
+			container.addChild(new Text(theme.fg("dim", "↑↓ navigate • space toggle • esc back"), 1, 0));
+			container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+
+			return {
+				render: (w: number) => container.render(w),
+				invalidate: () => container.invalidate(),
+				handleInput: (data: string) => { settingsList.handleInput?.(data); tui.requestRender(); },
+			};
+		});
+
+		if (!result) return; // User pressed Esc
+
+		// Parse the toggle result
+		const [configPath, pkg] = result.id.split("::", 2);
+		if (!configPath || !pkg) continue;
+
+		const enabling = result.value.includes("enabled");
+
+		// Read current exclusion array from merged effective config (handles YAML+JSON)
+		const freshConfig = loadProjectConfig(configRoot, pointerConfigRoot);
+		const currentExcludeList: string[] = (getNestedValue(freshConfig, configPath) as string[] | undefined) ?? [];
+
+		let newExcludeList: string[];
+		if (enabling) {
+			// Remove from exclusions → enable
+			newExcludeList = currentExcludeList.filter((e: string) => e !== pkg);
+		} else {
+			// Add to exclusions → disable
+			newExcludeList = currentExcludeList.includes(pkg)
+				? currentExcludeList
+				: [...currentExcludeList, pkg];
+		}
+
+		try {
+			writeProjectConfigField(configRoot, configPath, newExcludeList, pointerConfigRoot);
+			if (onConfigChanged) {
+				try { onConfigChanged(); } catch { /* non-fatal */ }
+			}
+			ctx.ui.notify(
+				`${enabling ? "✅ Enabled" : "❌ Disabled"} ${pkg} for ${configPath.includes("worker") ? "Worker" : configPath.includes("reviewer") ? "Reviewer" : "Merger"}`,
+				"info",
+			);
+		} catch (err: any) {
+			ctx.ui.notify(`❌ Failed to save: ${err.message}`, "error");
+		}
+
+		// Loop continues → re-render with fresh state
+	}
+}
+
 /**
  * Format a source badge for display.
  */

package/extensions/taskplane/types.ts

@@ -43,6 +43,8 @@ export interface OrchestratorConfig {
 		order: "fewest-files-first" | "sequential";
 		/** Merge agent timeout in minutes. Default: 10. Increase for large batches. */
 		timeout_minutes: number;
+		/** Package specifiers to exclude from extension forwarding (exact match). @since TP-180 */
+		exclude_extensions?: string[];
 	};
 	failure: {
 		on_task_failure: "skip-dependents" | "stop-wave" | "stop-all";
@@ -323,7 +325,11 @@ export interface TaskRunnerConfig {
 		thinking: string;
 		/** Comma-separated tool allowlist */
 		tools: string;
+		/** Package specifiers to exclude from extension forwarding (exact match). @since TP-180 */
+		excludeExtensions?: string[];
 	};
+	/** Worker agent extension exclusion list. @since TP-180 */
+	workerExcludeExtensions?: string[];
 }
 
 /** Result of a preflight check */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskplane",
-  "version": "0.28.2",
+  "version": "0.28.4",
   "description": "AI agent orchestration for pi — parallel task execution with checkpoint discipline",
   "keywords": [
     "pi-package",