pi-cohort 4.0.0 → 5.0.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [5.0.0] - 2026-08-06
+
+### Changed
+- **BREAKING:** Programmatic chains now launch directly when `clarify` is omitted. Pass `clarify: true` to keep the foreground preview/edit flow.
+
+## [4.1.0] - 2026-07-19
+
+### Added
+- **Forward parent pi CLI flags into children.** Extension flags the parent `pi` was launched with (e.g. pi-lens's `--no-autofix`) are now auto-forwarded into spawned children - foreground, sync-background, and detached-async, at any nesting depth - derived universally from the parent's argv. Pi core flags are never forwarded. Opt out with `forwardParentFlags: false`. ([#2](https://github.com/jjuraszek/pi-cohort/issues/2))
+
 ## [4.0.0] - 2026-07-16
 
 ### Changed

package/README.md

@@ -117,6 +117,8 @@ Full reference: agent/chain authoring in [doc/agents-and-chains.md](doc/agents-a
 
 Most installs need zero configuration. Full env/JSON reference: [doc/configuration.md](doc/configuration.md).
 
+Parent extension CLI flags (e.g. pi-lens's `--no-autofix`) are forwarded into spawned children by default, so subagents inherit the same tooling behavior you launched with; toggle with [`forwardParentFlags`](doc/configuration.md#forwardparentflags).
+
 Optional companions:
 
 - [pi-intercom](https://github.com/jjuraszek/pi-intercom) - lets a blocked child ask the parent a question instead of guessing. [doc/skills-and-companions.md](doc/skills-and-companions.md#optional-pi-intercom-companion)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cohort",
-  "version": "4.0.0",
+  "version": "5.0.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/skills/pi-cohort/SKILL.md

@@ -400,8 +400,8 @@ subagent({
 })
 ```
 
-Chains default to clarify mode; set `clarify: false` to skip it. Clarify edits affect only the next run; use management actions, settings, or markdown files for persistent changes.
-For programmatic background launches, use `async: true`. Set `clarify: false` when you want to bypass chain clarification explicitly; `clarify: true` keeps the run foreground for the clarify UI.
+Programmatic chains launch directly by default. Set `clarify: true` to preview or edit a sequential chain before launch; chains containing parallel steps skip the UI. Clarify edits affect only the next run; use management actions, settings, or markdown files for persistent changes.
+For programmatic background launches, use `async: true`. Explicit `clarify: true` keeps the run foreground for the clarify UI.
 
 
 ## Worktree Isolation

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

@@ -289,7 +289,7 @@ export const SubagentParams = Type.Object({
 		Type.String({ description: "Directory to store session logs (default: temp; enables sessions even if share=false)" }),
 	),
 	// Clarification TUI
-	clarify: Type.Optional(Type.Boolean({ description: "Show TUI to preview/edit before execution. Explicit clarify: true keeps the run foreground for the clarify UI; omitted clarify can still run in the background when async: true is set." })),
+	clarify: Type.Optional(Type.Boolean({ description: "Show TUI to preview/edit before execution. Omitted or false launches directly. Explicit clarify: true keeps the run foreground for the clarify UI when supported; chains containing parallel steps skip the UI." })),
 	control: Type.Optional(ControlOverrides),
 	// Solo agent overrides
 	output: Type.Optional(Type.Unsafe({

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-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 {
@@ -490,7 +493,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 	const chainDir = createChainDir(runId, chainDirBase);
 	const hasParallelSteps = chainSteps.some((step) => isParallelStep(step) || isDynamicParallelStep(step));
 	let templates: ResolvedTemplates = resolveChainTemplates(chainSteps);
-	const shouldClarify = clarify !== false && ctx.hasUI && !hasParallelSteps;
+	const shouldClarify = clarify === true && ctx.hasUI && !hasParallelSteps;
 	let tuiBehaviorOverrides: (BehaviorOverride | undefined)[] | undefined;
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
 	const availableSkills = discoverAvailableSkills(cwd ?? ctx.cwd);
@@ -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

@@ -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;
 
@@ -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,
 		});
 	}
 
@@ -1205,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,
 		});
 	}
 
@@ -1264,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) {
@@ -1304,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,
 		});
 	}
 
@@ -1363,6 +1370,7 @@ interface ForegroundParallelRunInput {
 	liveProgress: (AgentProgress | undefined)[];
 	onUpdate?: (r: AgentToolResult<Details>) => void;
 	worktreeSetup?: WorktreeSetup;
+	forwardedFlags?: string[];
 }
 
 function buildParallelModeError(message: string): AgentToolResult<Details> {
@@ -1523,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 || [];
@@ -1735,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,
 			});
 		}
 	}
@@ -1818,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));
@@ -2013,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,
 			});
 		}
 	}
@@ -2101,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/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;
 }
 
 // ============================================================================