pi-cohort 3.0.2 → 4.1.0

package/agents/reviewer.md

@@ -64,7 +64,7 @@ When asked to review for over-engineering, bloat, or "what can we delete", run a
 
 ## Working rules
 - Read the plan, progress, and relevant files first when available.
-- Repo-local `progress.md` files are allowed scratch/memory files. Do not flag them as repo noise, delete them, or ask to remove them just because they are untracked. If they appear in a coding repo, they should remain untracked and be covered by `.gitignore`.
+- Top-level progress files exist only when the caller explicitly enables them. Do not ask consumer repositories to add cohort scratch files to `.gitignore`.
 - Use `bash` only for read-only inspection (e.g., `git diff`, `git log`, `git show`, test runs).
 - Do not invent issues. Only report problems you can justify from evidence.
 - Prefer small corrective edits over broad rewrites.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cohort",
-  "version": "3.0.2",
+  "version": "4.1.0",
   "description": "Delegate Pi work to focused child agents: code review, scouting, implementation, parallel audits, saved chains, and background jobs.",
   "author": "Jacek Juraszek",
   "license": "MIT",

package/src/extension/fanout-child.ts

@@ -11,7 +11,8 @@ import { deliverSubagentIntercomMessageEvent } from "../intercom/result-intercom
 import { resolveSubagentIntercomTarget } from "../intercom/intercom-bridge.ts";
 import { SubagentParams } from "./schemas.ts";
 import { loadConfig } from "./config.ts";
-import { type Details, type SubagentState } from "../shared/types.ts";
+import { deriveForwardedFlags } from "../runs/shared/forward-flags.ts";
+import type { Details, SubagentState } from "../shared/types.ts";
 
 function getSubagentSessionRoot(parentSessionFile: string | null): string {
 	if (parentSessionFile) {
@@ -148,6 +149,7 @@ export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI):
 		getSubagentSessionRoot,
 		expandTilde,
 		discoverAgents,
+		forwardedFlags: deriveForwardedFlags(process.argv, config),
 		allowMutatingManagementActions: false,
 	});
 

package/src/extension/index.ts

@@ -16,7 +16,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import { type ExtensionAPI, type ExtensionContext, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Box, Container, Spacer, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component } from "@earendil-works/pi-tui";
 import { discoverAgents, discoverAgentsAll } from "../agents/agents.ts";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.ts";
@@ -37,6 +37,7 @@ import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi
 import registerFanoutChildSubagentExtension from "./fanout-child.ts";
 import { formatDuration, shortenPath } from "../shared/formatters.ts";
 import { loadConfig } from "./config.ts";
+import { deriveForwardedFlags } from "../runs/shared/forward-flags.ts";
 import {
 	type Details,
 	type SubagentState,
@@ -315,6 +316,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		getSubagentSessionRoot,
 		expandTilde,
 		discoverAgents,
+		forwardedFlags: deriveForwardedFlags(process.argv, config),
 	});
 
 	pi.registerMessageRenderer<SlashMessageDetails>(SLASH_RESULT_TYPE, (message, options, theme) => {

package/src/extension/schemas.ts

@@ -119,7 +119,7 @@ const TaskItem = Type.Object({
 	output: Type.Optional(OutputOverride),
 	outputMode: Type.Optional(OutputModeOverride),
 	reads: Type.Optional(ReadsOverride),
-	progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking for this task" })),
+	progress: Type.Optional(Type.Boolean({ description: "Omit or set false to disable progress.md tracking for this task; true enables it." })),
 	model: Type.Optional(Type.String({ description: "Override model for this task (e.g. 'google/gemini-3-pro')" })),
 	skill: Type.Optional(SkillOverride),
 	acceptance: Type.Optional(AcceptanceOverride),
@@ -297,7 +297,7 @@ export const SubagentParams = Type.Object({
 			{ type: "string" },
 			{ type: "boolean" },
 		],
-		description: "Output file for single agent (string), or false to disable. Relative paths resolve against cwd.",
+		description: "Omit or set false to disable file output; true uses the agent-configured filename; a string sets the output path. Relative paths resolve against cwd.",
 	})),
 	outputMode: Type.Optional(OutputModeOverride),
 	skill: Type.Optional(SkillOverride),

package/src/runs/background/async-execution.ts

@@ -120,6 +120,7 @@ interface AsyncChainParams {
 	controlIntercomTarget?: string;
 	childIntercomTarget?: (agent: string, index: number) => string | undefined;
 	nestedRoute?: NestedRouteInfo;
+	forwardedFlags?: string[];
 	acceptance?: AcceptanceInput;
 }
 
@@ -147,6 +148,7 @@ interface AsyncSingleParams {
 	controlIntercomTarget?: string;
 	childIntercomTarget?: (agent: string, index: number) => string | undefined;
 	nestedRoute?: NestedRouteInfo;
+	forwardedFlags?: string[];
 	acceptance?: AcceptanceInput;
 }
 
@@ -249,6 +251,7 @@ export function executeAsyncChain(
 		controlIntercomTarget,
 		childIntercomTarget,
 		nestedRoute,
+		forwardedFlags,
 	} = params;
 	const resultMode = params.resultMode ?? "chain";
 	const chainSkills = params.chainSkills ?? [];
@@ -481,6 +484,7 @@ export function executeAsyncChain(
 				sessionId: ctx.currentSessionId,
 				piPackageRoot,
 				piArgv1: process.argv[1],
+				forwardedFlags,
 				worktreeSetupHook,
 				worktreeSetupHookTimeoutMs,
 				controlConfig,
@@ -629,6 +633,7 @@ export function executeAsyncSingle(
 		controlIntercomTarget,
 		childIntercomTarget,
 		nestedRoute,
+		forwardedFlags,
 	} = params;
 	const task = params.task ?? "";
 	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
@@ -716,6 +721,7 @@ export function executeAsyncSingle(
 				sessionId: ctx.currentSessionId,
 				piPackageRoot,
 				piArgv1: process.argv[1],
+				forwardedFlags,
 				worktreeSetupHook,
 				worktreeSetupHookTimeoutMs,
 				controlConfig,

package/src/runs/background/subagent-runner.ts

@@ -97,6 +97,7 @@ interface SubagentRunConfig {
 	sessionId?: string | null;
 	piPackageRoot?: string;
 	piArgv1?: string;
+	forwardedFlags?: string[];
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
 	controlConfig?: ResolvedControlConfig;
@@ -574,6 +575,7 @@ interface SingleStepContext {
 	outputFile: string;
 	piPackageRoot?: string;
 	piArgv1?: string;
+	forwardedFlags?: string[];
 	registerInterrupt?: (interrupt: (() => void) | undefined) => void;
 	childIntercomTarget?: string;
 	orchestratorIntercomTarget?: string;
@@ -677,6 +679,7 @@ async function runSingleStep(
 			parentRootRunId: ctx.nestedRoute?.rootRunId,
 			parentCapabilityToken: ctx.nestedRoute?.capabilityToken,
 			structuredOutput: effectiveStructuredOutput,
+			forwardedFlags: ctx.forwardedFlags,
 		});
 		const run = await runPiStreaming(
 			args,
@@ -1610,6 +1613,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 					outputFile: path.join(asyncDir, `output-${fi}.log`),
 					piPackageRoot: config.piPackageRoot,
 					piArgv1: config.piArgv1,
+					forwardedFlags: config.forwardedFlags,
 					childIntercomTarget: config.childIntercomTargets?.[fi],
 					orchestratorIntercomTarget: config.controlIntercomTarget,
 					nestedRoute: config.nestedRoute,
@@ -1857,6 +1861,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 							outputFile: path.join(asyncDir, `output-${fi}.log`),
 							piPackageRoot: config.piPackageRoot,
 							piArgv1: config.piArgv1,
+							forwardedFlags: config.forwardedFlags,
 							childIntercomTarget: config.childIntercomTargets?.[fi],
 							orchestratorIntercomTarget: config.controlIntercomTarget,
 							nestedRoute: config.nestedRoute,
@@ -2024,6 +2029,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				outputFile: path.join(asyncDir, `output-${flatIndex}.log`),
 				piPackageRoot: config.piPackageRoot,
 				piArgv1: config.piArgv1,
+				forwardedFlags: config.forwardedFlags,
 				childIntercomTarget: config.childIntercomTargets?.[flatIndex],
 				orchestratorIntercomTarget: config.controlIntercomTarget,
 				nestedRoute: config.nestedRoute,

package/src/runs/foreground/chain-clarify.ts

@@ -494,7 +494,7 @@ export class ChainClarifyComponent implements Component {
 			return;
 		}
 
-		if (data === "w" && this.mode !== 'parallel') {
+		if (data === "w") {
 			this.enterEditMode("output");
 			return;
 		}
@@ -504,11 +504,15 @@ export class ChainClarifyComponent implements Component {
 			return;
 		}
 
-		if (data === "p" && this.mode === 'chain') {
-			const anyEnabled = this.agentConfigs.some((_, i) => this.getEffectiveBehavior(i).progress);
-			const newState = !anyEnabled;
-			for (let i = 0; i < this.agentConfigs.length; i++) {
-				this.updateBehavior(i, "progress", newState);
+		if (data === "p" && this.mode !== 'single') {
+			if (this.mode === 'chain') {
+				const anyEnabled = this.agentConfigs.some((_, i) => this.getEffectiveBehavior(i).progress);
+				const newState = !anyEnabled;
+				for (let i = 0; i < this.agentConfigs.length; i++) {
+					this.updateBehavior(i, "progress", newState);
+				}
+			} else {
+				this.updateBehavior(this.selectedStep, "progress", !this.getEffectiveBehavior(this.selectedStep).progress);
 			}
 			this.tui.requestRender();
 			return;
@@ -532,7 +536,9 @@ export class ChainClarifyComponent implements Component {
 			buffer = template.split("\n")[0] ?? "";
 		} else if (mode === "output") {
 			const behavior = this.getEffectiveBehavior(this.selectedStep);
-			buffer = behavior.output === false ? "" : (behavior.output || "");
+			buffer = behavior.output === false
+				? (this.mode === "chain" ? "" : this.agentConfigs[this.selectedStep]?.output ?? "")
+				: (behavior.output || "");
 		} else if (mode === "reads") {
 			const behavior = this.getEffectiveBehavior(this.selectedStep);
 			buffer = behavior.reads === false ? "" : (behavior.reads?.join(", ") || "");
@@ -1108,7 +1114,7 @@ export class ChainClarifyComponent implements Component {
 			case 'single':
 				return ` [Enter] Run • [Esc] Cancel • e m t w s ${bgLabel} `;
 			case 'parallel':
-				return ` [Enter] Run • [Esc] Cancel • e m t s ${bgLabel} • ↑↓ Nav `;
+				return ` [Enter] Run • [Esc] Cancel • e m t w p s ${bgLabel} • ↑↓ Nav `;
 			case 'chain':
 				return ` [Enter] Run • [Esc] Cancel • e m t w r p s ${bgLabel} • ↑↓ Nav `;
 		}
@@ -1207,6 +1213,16 @@ export class ChainClarifyComponent implements Component {
 			lines.push(this.row(`     ${modelLabel}${truncateToWidth(modelValue, innerW - 13)}`));
 
 			const behavior = this.getEffectiveBehavior(i);
+			const writesValue = behavior.output === false
+				? th.fg("dim", "(disabled)")
+				: (behavior.output || th.fg("dim", "(none)"));
+			const writesLabel = th.fg("dim", "writes: ");
+			lines.push(this.row(`     ${writesLabel}${truncateToWidth(writesValue, innerW - 14)}`));
+
+			const progressValue = behavior.progress ? th.fg("success", "on") : th.fg("dim", "off");
+			const progressLabel = th.fg("dim", "progress: ");
+			lines.push(this.row(`     ${progressLabel}${progressValue}`));
+
 			const skillsValue = behavior.skills === false
 				? th.fg("dim", "(disabled)")
 				: (behavior.skills?.length ? behavior.skills.join(", ") : th.fg("dim", "(none)"));

package/src/runs/foreground/chain-execution.ts

@@ -136,6 +136,7 @@ interface ParallelChainRunInput {
 	worktreeSetup?: WorktreeSetup;
 	maxSubagentDepth: number;
 	nestedRoute?: NestedRouteInfo;
+	forwardedFlags?: string[];
 }
 
 function buildChainExecutionDetails(input: ChainExecutionDetailsInput): Details {
@@ -290,6 +291,7 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 				structuredOutput: structuredRuntime,
 				acceptance: task.acceptance,
 				acceptanceContext: { mode: "chain" },
+				forwardedFlags: input.forwardedFlags,
 				onUpdate: input.onUpdate
 					? (progressUpdate) => {
 						const stepResults = progressUpdate.details?.results || [];
@@ -392,6 +394,7 @@ interface ChainExecutionParams {
 	nestedRoute?: NestedRouteInfo;
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
+	forwardedFlags?: string[];
 }
 
 interface ChainExecutionResult {
@@ -644,6 +647,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 					cwd,
 					runId,
 					globalTaskIndex,
+					forwardedFlags: params.forwardedFlags,
 					sessionDirForIndex,
 					sessionFileForIndex,
 					shareEnabled,
@@ -850,6 +854,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				cwd,
 				runId,
 				globalTaskIndex,
+				forwardedFlags: params.forwardedFlags,
 				sessionDirForIndex,
 				sessionFileForIndex,
 				shareEnabled,
@@ -1062,6 +1067,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				artifactConfig,
 				outputPath,
 				outputMode: behavior.outputMode,
+				forwardedFlags: params.forwardedFlags,
 				maxSubagentDepth,
 				controlConfig,
 				onControlEvent,

package/src/runs/foreground/execution.ts

@@ -179,6 +179,7 @@ async function runSingleAttempt(
 			parentRootRunId: options.nestedRoute?.rootRunId,
 			parentCapabilityToken: options.nestedRoute?.capabilityToken,
 			structuredOutput: options.structuredOutput,
+			forwardedFlags: options.forwardedFlags,
 		});
 
 	const result: SingleResult = {

package/src/runs/foreground/subagent-executor.ts

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { type AgentConfig, type AgentScope } from "../../agents/agents.ts";
+import type { AgentConfig, AgentScope } from "../../agents/agents.ts";
 import { getArtifactsDir } from "../../shared/artifacts.ts";
 import { ChainClarifyComponent, type ChainClarifyResult } from "./chain-clarify.ts";
 import { toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
@@ -37,7 +37,7 @@ import { createForkContextResolver } from "../../shared/fork-context.ts";
 import { resolveCurrentSessionId } from "../../shared/session-identity.ts";
 import { applyIntercomBridgeToAgent, INTERCOM_BRIDGE_MARKER, resolveIntercomBridge, resolveIntercomSessionTarget, resolveSubagentIntercomTarget, type IntercomBridgeState } from "../../intercom/intercom-bridge.ts";
 import { formatControlIntercomMessage, formatControlNoticeMessage, resolveControlConfig, shouldNotifyControlEvent } from "../shared/subagent-control.ts";
-import { finalizeSingleOutput, injectSingleOutputInstruction, normalizeSingleOutputOverride, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.ts";
+import { finalizeSingleOutput, injectSingleOutputInstruction, normalizeTopLevelOutput, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.ts";
 import { compactForegroundDetails, getSingleResultOutput, mapConcurrent, readStatus, resolveChildCwd } from "../../shared/utils.ts";
 import {
 	attachNestedChildrenToResultChildren,
@@ -145,6 +145,7 @@ interface ExecutorDeps {
 	pi: ExtensionAPI;
 	state: SubagentState;
 	config: ExtensionConfig;
+	forwardedFlags: string[];
 	asyncByDefault: boolean;
 	tempArtifactsDir: string;
 	getSubagentSessionRoot: (parentSessionFile: string | null) => string;
@@ -665,6 +666,7 @@ async function resumeAsyncRun(input: {
 		controlIntercomTarget: intercomBridge.active ? intercomBridge.orchestratorTarget : undefined,
 		childIntercomTarget: intercomBridge.active ? (agent, index) => resolveSubagentIntercomTarget(runId, agent, index) : undefined,
 		availableModels,
+		forwardedFlags: input.deps.forwardedFlags,
 	});
 	if (result.isError) return result;
 
@@ -1102,10 +1104,10 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 			cwd: task.cwd,
 			...(modelOverrides[index] ? { model: modelOverrides[index] } : {}),
 			...(skillOverrides[index] !== undefined ? { skill: skillOverrides[index] } : {}),
-			...(task.output === true ? (agentConfigs[index]?.output ? { output: agentConfigs[index]!.output } : {}) : task.output !== undefined ? { output: task.output } : {}),
+			output: normalizeTopLevelOutput(task.output, agentConfigs[index]?.output),
 			...(task.outputMode !== undefined ? { outputMode: task.outputMode } : {}),
 			...(task.reads !== undefined && task.reads !== true ? { reads: task.reads } : {}),
-			...(task.progress !== undefined ? { progress: task.progress } : {}),
+			progress: task.progress ?? false,
 			...(task.acceptance !== undefined ? { acceptance: task.acceptance } : {}),
 		}));
 		return executeAsyncChain(id, {
@@ -1133,6 +1135,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 			controlIntercomTarget,
 			childIntercomTarget,
 			nestedRoute,
+			forwardedFlags: deps.forwardedFlags,
 		});
 	}
 
@@ -1162,6 +1165,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 			controlIntercomTarget,
 			childIntercomTarget,
 			nestedRoute,
+			forwardedFlags: deps.forwardedFlags,
 		});
 	}
 
@@ -1174,8 +1178,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 				details: { mode: "single" as const, results: [] },
 			};
 		}
-		const rawOutput = params.output !== undefined ? params.output : a.output;
-		const effectiveOutput = normalizeSingleOutputOverride(rawOutput, a.output);
+		const effectiveOutput = normalizeTopLevelOutput(params.output, a.output);
 		const effectiveOutputMode = params.outputMode ?? "inline";
 		const normalizedSkills = normalizeSkillInput(params.skill);
 		const skills = normalizedSkills === false ? [] : normalizedSkills;
@@ -1206,6 +1209,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 			childIntercomTarget: childIntercomTarget ? (agent, index) => childIntercomTarget(agent, index) : undefined,
 			nestedRoute,
 			acceptance: params.acceptance,
+			forwardedFlags: deps.forwardedFlags,
 		});
 	}
 
@@ -1265,6 +1269,7 @@ async function runChainPath(data: ExecutionContextData, deps: ExecutorDeps): Pro
 		maxSubagentDepth: currentMaxSubagentDepth,
 		worktreeSetupHook: deps.config.worktreeSetupHook,
 		worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
+		forwardedFlags: deps.forwardedFlags,
 	});
 
 	if (chainResult.requestedAsync) {
@@ -1305,6 +1310,7 @@ async function runChainPath(data: ExecutionContextData, deps: ExecutorDeps): Pro
 			controlIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
 			childIntercomTarget: data.intercomBridge.active ? (agent, index) => resolveSubagentIntercomTarget(id, agent, index) : undefined,
 			nestedRoute: data.nestedRoute,
+			forwardedFlags: deps.forwardedFlags,
 		});
 	}
 
@@ -1364,6 +1370,7 @@ interface ForegroundParallelRunInput {
 	liveProgress: (AgentProgress | undefined)[];
 	onUpdate?: (r: AgentToolResult<Details>) => void;
 	worktreeSetup?: WorktreeSetup;
+	forwardedFlags?: string[];
 }
 
 function buildParallelModeError(message: string): AgentToolResult<Details> {
@@ -1524,6 +1531,7 @@ async function runForegroundParallelTasks(input: ForegroundParallelRunInput): Pr
 			skills: effectiveSkills === false ? [] : effectiveSkills,
 			acceptance: task.acceptance,
 			acceptanceContext: { mode: "parallel" },
+			forwardedFlags: input.forwardedFlags,
 				onUpdate: input.onUpdate
 					? (progressUpdate) => {
 						const stepResults = progressUpdate.details?.results || [];
@@ -1630,10 +1638,10 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 		normalizeSkillInput(t.skill),
 	);
 	const behaviorOverrides: StepOverrides[] = tasks.map((task, index) => ({
-		...(task.output !== undefined ? { output: task.output === true ? agentConfigs[index]?.output ?? false : task.output } : {}),
+		output: normalizeTopLevelOutput(task.output, agentConfigs[index]?.output),
 		...(task.outputMode !== undefined ? { outputMode: task.outputMode } : {}),
 		...(task.reads !== undefined && task.reads !== true ? { reads: task.reads } : {}),
-		...(task.progress !== undefined ? { progress: task.progress } : {}),
+		progress: task.progress ?? false,
 		...(skillOverrides[index] !== undefined ? { skills: skillOverrides[index] } : {}),
 		...(task.model ? { model: task.model } : {}),
 	}));
@@ -1736,6 +1744,7 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 				controlConfig,
 				controlIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
 				childIntercomTarget: data.intercomBridge.active ? (agent, index) => resolveSubagentIntercomTarget(id, agent, index) : undefined,
+				forwardedFlags: deps.forwardedFlags,
 			});
 		}
 	}
@@ -1819,6 +1828,7 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 			liveProgress,
 			onUpdate: onUpdateWithCost,
 			worktreeSetup,
+			forwardedFlags: deps.forwardedFlags,
 		});
 		if (foregroundControl) updateForegroundNestedProjection(foregroundControl);
 		recordSyncCost(deps.state.grandTotal, runId, results.reduce((sum, r) => sum + r.usage.cost, 0) + sumNestedCost(foregroundControl?.nestedChildren));
@@ -1939,8 +1949,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 		currentProvider,
 	);
 	let skillOverride: string[] | false | undefined = normalizeSkillInput(params.skill);
-	const rawOutput = params.output !== undefined ? params.output : agentConfig.output;
-	let effectiveOutput = normalizeSingleOutputOverride(rawOutput, agentConfig.output);
+	let effectiveOutput = normalizeTopLevelOutput(params.output, agentConfig.output);
 	const effectiveOutputMode = params.outputMode ?? "inline";
 	const currentMaxSubagentDepth = resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth);
 	const maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, agentConfig.maxSubagentDepth);
@@ -1974,7 +1983,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 		task = result.templates[0]!;
 		const override = result.behaviorOverrides[0];
 		if (override?.model) modelOverride = override.model;
-		if (override?.output !== undefined) effectiveOutput = normalizeSingleOutputOverride(override.output, agentConfig.output);
+		if (override?.output !== undefined) effectiveOutput = normalizeTopLevelOutput(override.output, agentConfig.output);
 		if (override?.skills !== undefined) skillOverride = override.skills;
 
 		if (result.runInBackground) {
@@ -2015,6 +2024,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 				controlConfig,
 				controlIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
 				childIntercomTarget: data.intercomBridge.active ? (agent, index) => resolveSubagentIntercomTarget(id, agent, index) : undefined,
+				forwardedFlags: deps.forwardedFlags,
 			});
 		}
 	}
@@ -2103,6 +2113,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 		skills: effectiveSkills,
 		acceptance: params.acceptance,
 		acceptanceContext: { mode: "single" },
+		forwardedFlags: deps.forwardedFlags,
 	});
 	if (foregroundControl?.currentIndex === 0) {
 		foregroundControl.interrupt = undefined;

package/src/runs/shared/forward-flags.ts

@@ -0,0 +1,82 @@
+export interface ForwardFlagsConfig {
+  forwardParentFlags?: boolean;
+}
+
+// Core pi flag names -> value arity. This is the UNION of recognized core flags
+// across the supported pi range (0.74-0.80), transcribed from
+// @earendil-works/pi-coding-agent dist/cli/args.js. A name present here is never
+// forwarded to children. Direction matters: an entry that is core in a NEWER pi
+// but absent from an OLDER installed pi is safe (worst case we skip forwarding a
+// hypothetical extension flag of the same name); a MISSING entry is the real
+// hazard - it would leak a real core flag into the child. The drift tripwire in
+// test/unit/forward-flags.test.ts asserts installed-core is a subset of this table.
+type Arity = "boolean" | "value" | "value-guarded" | "value-guarded-print";
+export const RECOGNIZED_PI_FLAGS: Record<string, Arity> = {
+  help: "boolean", version: "boolean", continue: "boolean", resume: "boolean",
+  "no-session": "boolean", "no-tools": "boolean", "no-builtin-tools": "boolean",
+  "no-extensions": "boolean", "no-skills": "boolean", "no-prompt-templates": "boolean",
+  "no-themes": "boolean", "no-context-files": "boolean", verbose: "boolean",
+  approve: "boolean", "no-approve": "boolean", offline: "boolean",
+  mode: "value", provider: "value", model: "value", "api-key": "value",
+  "system-prompt": "value", "append-system-prompt": "value", name: "value",
+  session: "value", "session-id": "value", fork: "value", "session-dir": "value",
+  models: "value", tools: "value", "exclude-tools": "value", thinking: "value",
+  export: "value", extension: "value", skill: "value", "prompt-template": "value",
+  theme: "value",
+  print: "value-guarded-print", "list-models": "value-guarded",
+};
+// Short aliases -> long name, so `-p foo` / `-e x` classify correctly.
+const SHORT_ALIASES: Record<string, string> = {
+  h: "help", v: "version", c: "continue", r: "resume", nt: "no-tools",
+  nbt: "no-builtin-tools", ne: "no-extensions", ns: "no-skills",
+  np: "no-prompt-templates", nc: "no-context-files", a: "approve", na: "no-approve",
+  n: "name", t: "tools", xt: "exclude-tools", p: "print", e: "extension",
+};
+const EXTENSION_CUSTOMIZATION = new Set(["--extension", "-e", "--no-extensions", "-ne"]);
+
+function consumesNext(arity: Arity, next: string | undefined): boolean {
+  if (arity === "value") return next !== undefined;
+  if (arity === "value-guarded") return next !== undefined && !next.startsWith("-") && !next.startsWith("@");
+  if (arity === "value-guarded-print") return next !== undefined && !next.startsWith("@") && (!next.startsWith("-") || next.startsWith("---"));
+  return false;
+}
+
+export function deriveForwardedFlags(argv: string[], config: ForwardFlagsConfig): string[] {
+  if (config.forwardParentFlags === false) return [];
+  if (argv.some((tok) => EXTENSION_CUSTOMIZATION.has(tok))) return [];
+
+  const collected: Array<{ name: string; tokens: string[] }> = [];
+  for (let i = 2; i < argv.length; i++) {
+    const tok = argv[i]!;
+    if (tok.startsWith("@") || !tok.startsWith("-")) continue;
+    if (tok.startsWith("-") && !tok.startsWith("--")) {
+      const alias = SHORT_ALIASES[tok.slice(1)];
+      if (alias && consumesNext(RECOGNIZED_PI_FLAGS[alias]!, argv[i + 1])) i++;
+      continue;
+    }
+    const body = tok.slice(2);
+    const eq = body.indexOf("=");
+    const name = eq === -1 ? body : body.slice(0, eq);
+    const arity = RECOGNIZED_PI_FLAGS[name];
+    if (arity) {
+      if (eq === -1 && consumesNext(arity, argv[i + 1])) i++;
+      continue;
+    }
+    if (eq !== -1) {
+      collected.push({ name, tokens: [tok] });
+      continue;
+    }
+    const next = argv[i + 1];
+    if (next !== undefined && !next.startsWith("-") && !next.startsWith("@")) {
+      collected.push({ name, tokens: [tok, next] });
+      i++;
+    } else {
+      collected.push({ name, tokens: [tok] });
+    }
+  }
+
+  // Dedup by name, last value wins; first-occurrence position is preserved.
+  const lastByName = new Map<string, string[]>();
+  for (const { name, tokens } of collected) lastByName.set(name, tokens);
+  return [...lastByName.values()].flat();
+}

package/src/runs/shared/pi-args.ts

@@ -38,6 +38,7 @@ interface BuildPiArgsInput {
 	inheritSkills: boolean;
 	tools?: string[];
 	extensions?: string[];
+	forwardedFlags?: string[];
 	systemPrompt?: string | null;
 	cwd?: string;
 	promptFileStem?: string;
@@ -76,6 +77,11 @@ export function applyThinkingSuffix(model: string | undefined, thinking: string
 
 export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	const args = [...input.baseArgs];
+	// Forwarded flags are already name-deduped by deriveForwardedFlags; append only
+	// when the child inherits full extension discovery (extensions === undefined).
+	if (input.extensions === undefined && input.forwardedFlags?.length) {
+		args.push(...input.forwardedFlags);
+	}
 
 	if (input.sessionFile) {
 		fs.mkdirSync(path.dirname(input.sessionFile), { recursive: true });

package/src/runs/shared/single-output.ts

@@ -18,6 +18,15 @@ export function normalizeSingleOutputOverride(
 	return undefined;
 }
 
+export function normalizeTopLevelOutput(
+	output: string | boolean | undefined,
+	defaultOutput: string | undefined,
+): string | false {
+	if (output === undefined || (typeof output === "string" && output.trim().length === 0)) return false;
+	const normalizedOutput = normalizeSingleOutputOverride(output, defaultOutput);
+	return typeof normalizedOutput === "string" && normalizedOutput.trim().length === 0 ? false : normalizedOutput ?? false;
+}
+
 export function resolveSingleOutputPath(
 	output: string | boolean | undefined,
 	runtimeCwd: string,

package/src/shared/types.ts

@@ -796,6 +796,8 @@ export interface RunSyncOptions {
 	outputMode?: OutputMode;
 	maxSubagentDepth?: number;
 	nestedRoute?: NestedRouteInfo;
+	/** Parent extension flags to forward into the child (already derived; empty = none). */
+	forwardedFlags?: string[];
 	/** Override the agent's default model (format: "provider/id" or just "id") */
 	modelOverride?: string;
 	/** Registry models available for heuristic bare-model resolution */
@@ -849,6 +851,8 @@ export interface ExtensionConfig {
 	intercomBridge?: IntercomBridgeConfig;
 	/** Print a roster of discovered subagents/chains into chat at session start. Default: true. */
 	showRosterOnStart?: boolean;
+	/** Forward the parent pi's extension CLI flags (e.g. --no-autofix) into spawned children. Default: true. */
+	forwardParentFlags?: boolean;
 }
 
 // ============================================================================