@f5-sales-demo/xcsh 21.0.0 → 21.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/xcsh",
-	"version": "21.0.0",
+	"version": "21.1.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -61,13 +61,13 @@
 	},
 	"dependencies": {
 		"@agentclientprotocol/sdk": "1.3.0",
-		"@f5-sales-demo/pi-agent-core": "21.0.0",
-		"@f5-sales-demo/pi-ai": "21.0.0",
-		"@f5-sales-demo/pi-natives": "21.0.0",
-		"@f5-sales-demo/pi-resource-management": "21.0.0",
-		"@f5-sales-demo/pi-tui": "21.0.0",
-		"@f5-sales-demo/pi-utils": "21.0.0",
-		"@f5-sales-demo/xcsh-stats": "21.0.0",
+		"@f5-sales-demo/pi-agent-core": "21.1.0",
+		"@f5-sales-demo/pi-ai": "21.1.0",
+		"@f5-sales-demo/pi-natives": "21.1.0",
+		"@f5-sales-demo/pi-resource-management": "21.1.0",
+		"@f5-sales-demo/pi-tui": "21.1.0",
+		"@f5-sales-demo/pi-utils": "21.1.0",
+		"@f5-sales-demo/xcsh-stats": "21.1.0",
 		"@mozilla/readability": "^0.6",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",

package/src/cli/args.ts

@@ -17,6 +17,8 @@ import {
 
 export type Mode = "text" | "json" | "rpc" | "acp";
 
+export type ExtensionFlagRegistry = ReadonlyMap<string, { type: "boolean" | "string" }>;
+
 export interface Args {
 	cwd?: string;
 	allowHome?: boolean;
@@ -224,7 +226,97 @@ function isValueToken(token: string | undefined): token is string {
 	return token !== undefined && !token.startsWith("-") && !token.startsWith("@");
 }
 
-export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "boolean" | "string" }>): Args {
+export interface LaunchBootstrapArgs {
+	allowHome?: boolean;
+	cwd?: string;
+	noSandbox?: boolean;
+	allowPath: string[];
+	noMemories?: boolean;
+	hooks: string[];
+	extensions: string[];
+	noExtensions?: boolean;
+	pluginDirs: string[];
+	preExtensionExit: boolean;
+}
+
+const BOOTSTRAP_VALUE_FLAGS = new Set(["allow-path", "hook", "extension", "plugin-dir"]);
+const PRE_EXTENSION_EXITS = new Set(["version", "list-models", "export"]);
+
+/**
+ * Read only the built-in controls needed to load extensions.
+ *
+ * This is deliberately not an argument parse: it never classifies positional input, files, or
+ * extension flags. It only follows the known built-in grammar far enough to avoid mistaking a
+ * built-in value for a discovery control. The authoritative parse happens after this scan.
+ */
+export function scanLaunchBootstrapArgs(args: readonly string[]): LaunchBootstrapArgs {
+	const result: LaunchBootstrapArgs = {
+		allowPath: [],
+		hooks: [],
+		extensions: [],
+		pluginDirs: [],
+		preExtensionExit: false,
+	};
+	const tokens = normalizeFlagTokens(args);
+
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === "--") break;
+		if (!token.startsWith("-") || token === "-") continue;
+
+		const name = token.startsWith("--") ? token.slice(2) : flagNameForChar(token.slice(1));
+		if (name === undefined) continue;
+		const spec = flagSpec(name);
+		if (!spec) continue;
+
+		let value: string | true = true;
+		if (spec.arity === "optional-value") {
+			if (isValueToken(tokens[i + 1])) value = tokens[++i];
+		} else if (takesValue(spec)) {
+			if (tokens[i + 1] === undefined) continue;
+			value = tokens[++i];
+		}
+
+		if (PRE_EXTENSION_EXITS.has(name)) result.preExtensionExit = true;
+		if (name === "allow-home") result.allowHome = true;
+		if (name === "no-sandbox") result.noSandbox = true;
+		if (name === "no-memories") result.noMemories = true;
+		if (name === "no-extensions") result.noExtensions = true;
+		if (BOOTSTRAP_VALUE_FLAGS.has(name) && value !== true) {
+			if (name === "allow-path") result.allowPath.push(value);
+			if (name === "hook") result.hooks.push(value);
+			if (name === "extension") result.extensions.push(value);
+			if (name === "plugin-dir") result.pluginDirs.push(value);
+		}
+	}
+
+	return result;
+}
+
+export interface ResolvedLaunchArgs {
+	bootstrap: LaunchBootstrapArgs;
+	parsed: Args;
+	extensionFlags?: ExtensionFlagRegistry;
+}
+
+/**
+ * Resolve extension registrations before the one parse whose result drives launch behavior.
+ * Version/model-list/export retain their pre-extension fast path.
+ */
+export async function resolveLaunchArgs(
+	args: readonly string[],
+	loadExtensionFlags: (bootstrap: LaunchBootstrapArgs) => Promise<ExtensionFlagRegistry>,
+): Promise<ResolvedLaunchArgs> {
+	const bootstrap = scanLaunchBootstrapArgs(args);
+	const extensionFlags = bootstrap.preExtensionExit ? undefined : await loadExtensionFlags(bootstrap);
+	return {
+		bootstrap,
+		parsed: parseArgs([...args], extensionFlags),
+		...(extensionFlags ? { extensionFlags } : {}),
+	};
+}
+
+export function parseArgs(args: string[], extensionFlags?: ExtensionFlagRegistry): Args {
 	const result: Args = {
 		messages: [],
 		fileArgs: [],
@@ -282,23 +374,20 @@ export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "
 			continue;
 		}
 
-		// Extension flags are only known on the second parse, once extensions have loaded.
+		// Extension registrations are loaded before this authoritative parse.
 		const extFlag = name === undefined ? undefined : extensionFlags?.get(name);
 		if (extFlag && name !== undefined) {
 			if (extFlag.type === "boolean") {
-				result.unknownFlags.set(name, true);
+				const inlineValue = token.startsWith("--") ? token.split("=", 2)[1] : undefined;
+				result.unknownFlags.set(name, inlineValue === undefined ? true : inlineValue === "true");
 			} else if (i + 1 < tokens.length) {
 				result.unknownFlags.set(name, tokens[++i]);
 			}
 			continue;
 		}
 
-		// Record the flag, but do NOT consume the token after it. The bootstrap parse runs before
-		// extensions load, so it cannot know whether an unrecognized flag takes a value: swallowing
-		// the next token silently discards the user's prompt whenever the flag turns out to be
-		// boolean (`xcsh -p --verbose "do work"`). Leaving it means a string extension flag's value
-		// still reaches `messages`, which is the pre-existing behaviour and the lesser harm — the
-		// real fix is to load extensions before the first parse, which is out of scope here.
+		// Do not consume a following token for a genuine unknown flag: it may be prompt content.
+		// Registered extension flags never reach this path because launch discovers them first.
 		result.unrecognizedFlags.push({ token, name: name ?? token.replace(/^-+/, "") });
 	}
 

package/src/cli/flag-spec.ts

@@ -175,20 +175,23 @@ export function validateInlineFlagSyntax(args: readonly string[], extensionFlags
 		if (!inline) continue;
 
 		const spec = flagSpec(inline.name);
-		const isBoolean = spec?.arity === "boolean" || extensionFlags?.get(inline.name)?.type === "boolean";
-		if (isBoolean) {
+		if (spec?.arity === "boolean") {
 			throw new CliUsageError(`--${inline.name} is a boolean flag and does not take a value`);
 		}
+		if (extensionFlags?.get(inline.name)?.type === "boolean" && inline.value !== "true" && inline.value !== "false") {
+			throw new CliUsageError(`--${inline.name} is a boolean flag and expects true or false`);
+		}
 	}
 }
 
 /**
  * Rewrite `--name=value` into `["--name", "value"]` for every flag that takes a value.
  *
- * A boolean flag with `=` is an error rather than a guess: accepting `--no-sandbox=true` invites
+ * A built-in boolean flag with `=` is an error rather than a guess: accepting `--no-sandbox=true` invites
  * `--no-sandbox=false`, which the parser has no way to express, and quietly reading it as "on" would
  * be exactly the class of bug #2469 reports. Unknown names are left intact so the unknown-flag path
  * can report the token as the user wrote it.
+ * Extension boolean flags accept explicit true or false values through their runtime map.
  *
  * Short forms are untouched: no shell convention makes `-p=x` mean `-p x`.
  */
@@ -223,7 +226,11 @@ export function normalizeFlagTokens(args: readonly string[], extensionFlags?: Ex
 
 		const extension = extensionFlags?.get(name);
 		if (extension) {
-			normalized.push(`--${name}`, value);
+			if (extension.type === "boolean") {
+				normalized.push(arg);
+			} else {
+				normalized.push(`--${name}`, value);
+			}
 			continue;
 		}
 

package/src/cli/plugin-cli.ts

@@ -425,6 +425,17 @@ async function handleInstall(
 		}
 
 		if (target.type === "marketplace") {
+			if (flags.dryRun) {
+				const preview = {
+					action: "install",
+					target: `${target.name}@${target.marketplace}`,
+					scope: flags.scope ?? "user",
+					dryRun: true,
+				};
+				if (flags.json) console.log(JSON.stringify(preview, null, 2));
+				else console.log(chalk.dim(`[dry-run] Would install ${preview.target} (${preview.scope})`));
+				continue;
+			}
 			try {
 				const entry = await mktMgr.installPlugin(target.name, target.marketplace, {
 					force: flags.force,

package/src/cli/sandbox-check.ts

@@ -6,10 +6,17 @@ import { executeShell, fencePermits } from "@f5-sales-demo/pi-natives";
 import { isEnoent } from "@f5-sales-demo/pi-utils";
 import { Settings } from "../config/settings";
 import { fenceForNative } from "../exec/bash-executor";
-import { buildContainmentFence, type ContainmentFence, containmentStatus, fenceVerdict } from "../sandbox/containment";
+import {
+	buildContainmentFence,
+	type ContainmentFence,
+	containmentStatus,
+	fenceVerdict,
+	seatbeltFenceVerdict,
+} from "../sandbox/containment";
 import { evaluateToolCall } from "../sandbox/enforce";
 import {
 	SANDBOX_CHECK_NAMED_SIBLING_ENV,
+	SANDBOX_CHECK_NAMED_SIBLING_EXPECTATION_ENV,
 	SANDBOX_OPERATOR_HOME_ENV,
 	SANDBOX_SESSION_ROOT_ENV,
 	sandboxCheckSiblingRoot,
@@ -74,6 +81,13 @@ function sanitizeDetail(value: string, redactions: readonly Redaction[]): string
 	return sanitized.length > 500 ? `${sanitized.slice(0, 497)}...` : sanitized;
 }
 
+function inheritedNamedSiblingDenied(value: string | undefined): boolean | undefined {
+	if (value === undefined) return undefined;
+	if (value === "denied") return true;
+	if (value === "allowed") return false;
+	throw new Error(`invalid ${SANDBOX_CHECK_NAMED_SIBLING_EXPECTATION_ENV}: expected "allowed" or "denied"`);
+}
+
 function errnoFromOutput(output: string): string {
 	if (/operation not permitted/iu.test(output)) return "EPERM";
 	if (/permission denied/iu.test(output)) return "EACCES";
@@ -210,6 +224,10 @@ export async function runSandboxCheck(options: SandboxCheckOptions = {}): Promis
 		const inheritedHome = process.env[SANDBOX_OPERATOR_HOME_ENV];
 		const inheritedSibling = process.env[SANDBOX_CHECK_NAMED_SIBLING_ENV];
 		const inheritedProfile = inheritedWorkspace !== undefined;
+		const inheritedSiblingDenied =
+			inheritedProfile && inheritedSibling !== undefined
+				? inheritedNamedSiblingDenied(process.env[SANDBOX_CHECK_NAMED_SIBLING_EXPECTATION_ENV])
+				: undefined;
 		const workspaceInput = inheritedWorkspace ?? process.cwd();
 		const homeInput = inheritedHome ?? os.homedir();
 		redactions.push([workspaceInput, "<workspace>"], [homeInput, "<operator-home>"]);
@@ -462,7 +480,7 @@ export async function runSandboxCheck(options: SandboxCheckOptions = {}): Promis
 			);
 		});
 
-		await check("named sibling remains reachable", async () => {
+		await check("named sibling follows the active boundary", async () => {
 			const displayPath = "<session-parent>/<synthetic-sibling>";
 			let liveSibling = inheritedSibling;
 			if (liveSibling === undefined) {
@@ -480,13 +498,24 @@ export async function runSandboxCheck(options: SandboxCheckOptions = {}): Promis
 					return exceptionOutcome("create named sibling fixture", displayPath, error, redactions);
 				}
 			}
+			const seatbeltDeniesSibling =
+				inheritedSiblingDenied ??
+				(backend.backend === "seatbelt" && seatbeltFenceVerdict(liveFence, liveSibling, "read") === "deny");
 			const result = await shellProbe(
-				'test "$(cat named.txt)" = sibling',
-				liveSibling,
-				undefined,
+				`cd ${quote(liveSibling)} && test "$(cat named.txt)" = sibling`,
+				liveWorkspace,
+				inheritedProfile ? undefined : liveFence,
 				abortController.signal,
 			);
-			return shellOutcome(result, true, "live profile must allow a named sibling read", displayPath, redactions);
+			return shellOutcome(
+				result,
+				!seatbeltDeniesSibling,
+				seatbeltDeniesSibling
+					? "Seatbelt must deny a named sibling outside the workspace"
+					: "live profile must allow a named sibling read",
+				displayPath,
+				redactions,
+			);
 		});
 
 		if (backend.osEnforced) {

package/src/commands/launch.ts

@@ -4,7 +4,6 @@
 
 import { APP_NAME } from "@f5-sales-demo/pi-utils";
 import { Args, Command } from "@f5-sales-demo/pi-utils/cli";
-import { parseArgs } from "../cli/args";
 import { buildCliFlags } from "../cli/flag-spec";
 import { runRootCommand } from "../main";
 
@@ -36,7 +35,6 @@ export default class Index extends Command {
 	static strict = false;
 
 	async run(): Promise<void> {
-		const parsed = parseArgs(this.argv);
-		await runRootCommand(parsed, this.argv);
+		await runRootCommand(this.argv);
 	}
 }

package/src/config/model-registry.ts

@@ -187,6 +187,8 @@ const ThinkingControlModeSchema = Type.Union([
 const ModelThinkingSchema = Type.Object({
 	minLevel: EffortSchema,
 	maxLevel: EffortSchema,
+	defaultLevel: Type.Optional(EffortSchema),
+	canDisable: Type.Optional(Type.Boolean()),
 	mode: ThinkingControlModeSchema,
 });
 

package/src/discovery/helpers.ts

@@ -843,12 +843,13 @@ export async function listXcshPluginRoots(
 		roots.push(...projectRoots, ...deduped);
 	}
 
-	// Merge --plugin-dir roots (highest precedence) on every fresh load
+	// Merge --plugin-dir roots (highest precedence) on every fresh load. Local roots use
+	// an artificial marketplace ID, so identity must be matched by manifest plugin name;
+	// comparing full IDs would leave the installed copy active beside the candidate.
 	if (injectedPluginDirRoots.length > 0) {
-		const injectedIds = new Set(injectedPluginDirRoots.map(r => r.id));
-		const filtered = roots.filter(r => !injectedIds.has(r.id));
+		const merged = prioritizeInjectedPluginRoots(roots, injectedPluginDirRoots);
 		roots.length = 0;
-		roots.push(...injectedPluginDirRoots, ...filtered);
+		roots.push(...merged);
 	}
 
 	const result = { roots, warnings };
@@ -856,6 +857,19 @@ export async function listXcshPluginRoots(
 	return result;
 }
 
+export function prioritizeInjectedPluginRoots(
+	installed: XcshPluginRoot[],
+	injected: XcshPluginRoot[],
+): XcshPluginRoot[] {
+	const seen = new Set<string>();
+	const winners = injected.filter(root => {
+		if (seen.has(root.plugin)) return false;
+		seen.add(root.plugin);
+		return true;
+	});
+	return [...winners, ...installed.filter(root => !seen.has(root.plugin))];
+}
+
 export interface XcshPluginSummary {
 	/** Registry id (root.plugin) — the key the `xcsh://plugin/<id>` resolver matches on. */
 	id: string;

package/src/exec/bash-executor.ts

@@ -24,6 +24,7 @@ export function fenceForNative(fence: ContainmentFence | undefined) {
 		allowReadOnly: [...fence.allowReadOnly],
 		allowWriteOnly: [...fence.allowWriteOnly],
 		deny: [...fence.deny],
+		denyOnSeatbelt: [...fence.denyOnSeatbelt],
 		denyEnumerate: [...fence.denyEnumerate],
 	};
 }

package/src/internal-urls/build-info-runtime.ts

@@ -171,7 +171,7 @@ function renderContainment(containment: ContainmentStatus | null): string {
 	if (!containment) return "";
 	// `landlock` is derived rather than another field on the status, because the template needs a
 	// boolean and Handlebars cannot compare strings. It gates the Linux-only costs — unlistable split
-	// directories, no setuid, no interactive terminal — which are true of that backend and no other.
+	// directories and no setuid — which are true of that backend and no other.
 	return prompt.render(containmentTemplate, {
 		containment: { ...containment, landlock: containment.backend === "landlock" },
 	});

package/src/internal-urls/build-info.generated.ts

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "21.0.0",
-	"commit": "7402d0fe1d43a25000908463ed254d54c71d0b6b",
-	"shortCommit": "7402d0f",
+	"version": "21.1.0",
+	"commit": "5c6e84a195bcf81ba561bf85c5ecf7a47d8c62c1",
+	"shortCommit": "5c6e84a",
 	"branch": "main",
-	"tag": "v21.0.0",
-	"commitDate": "2026-08-28T10:34:07+00:00",
-	"buildDate": "2026-08-28T11:01:38.586Z",
+	"tag": "v21.1.0",
+	"commitDate": "2026-08-28T19:03:09+00:00",
+	"buildDate": "2026-08-28T19:42:43.325Z",
 	"dirty": true,
 	"prNumber": "",
 	"repoUrl": "https://github.com/f5-sales-demo/xcsh",
 	"repoSlug": "f5-sales-demo/xcsh",
-	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/7402d0fe1d43a25000908463ed254d54c71d0b6b",
-	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v21.0.0"
+	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/5c6e84a195bcf81ba561bf85c5ecf7a47d8c62c1",
+	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v21.1.0"
 };

package/src/internal-urls/console-resolve.ts

@@ -121,10 +121,10 @@ function renderResource(resource: string, catalog: ConsoleCatalogData, fieldMeta
 	const doc = (parseYaml(raw) ?? {}) as Record<string, unknown>;
 	const console_ = (doc.console ?? {}) as Record<string, unknown>;
 	const lines = [`# ${(doc.label as string | undefined) ?? key}`, ""];
-	if (console_.route_pattern) {
-		const fullRoute = console_.route_prefix
-			? `${console_.route_prefix}${console_.route_pattern}`
-			: console_.route_pattern;
+	const routePattern = typeof console_.route_pattern === "string" ? console_.route_pattern : undefined;
+	if (routePattern) {
+		const routePrefix = typeof console_.route_prefix === "string" ? console_.route_prefix : undefined;
+		const fullRoute = routePrefix ? `${routePrefix}${routePattern}` : routePattern;
 		lines.push(`**Route:** \`${fullRoute}\``, "");
 	}
 	if (Array.isArray(console_.menu_path)) lines.push(`**Menu:** ${(console_.menu_path as string[]).join(" › ")}`, "");
@@ -155,8 +155,9 @@ function renderWorkflow(resource: string, operation: string, catalog: ConsoleCat
 	for (const s of steps) {
 		const sel = s.selector ? ` \`${s.selector}\`` : "";
 		const val = s.value != null ? ` = ${JSON.stringify(s.value)}` : "";
+		const action = typeof s.action === "string" ? s.action : "unknown";
 		lines.push(
-			`1. **${s.action}**${sel}${val} — ${(s.description as string | undefined) ?? (s.id as string | undefined) ?? ""}`,
+			`1. **${action}**${sel}${val} — ${(s.description as string | undefined) ?? (s.id as string | undefined) ?? ""}`,
 		);
 	}
 	return `${lines.join("\n")}\n`;

package/src/main.ts

@@ -28,7 +28,7 @@ import { ChatHandler } from "./browser/chat-handler";
 import { type BridgeServer, startBridgeServer } from "./browser/extension-bridge";
 import { setSharedBridgeServer } from "./browser/provider";
 import { invalidate as invalidateFsCache } from "./capability/fs";
-import { type Args, parseArgs } from "./cli/args";
+import { type Args, resolveLaunchArgs } from "./cli/args";
 import { processFileArguments } from "./cli/file-processor";
 import { LAUNCH_FLAGS } from "./cli/flag-spec";
 import { buildInitialMessage } from "./cli/initial-message";
@@ -46,7 +46,8 @@ import {
 	resolveActiveProjectRegistryPath,
 } from "./discovery/helpers";
 import { exportFromFile } from "./export/html";
-import type { ExtensionUIContext } from "./extensibility/extensions/types";
+import { discoverAndLoadExtensions, loadExtensions } from "./extensibility/extensions";
+import type { ExtensionFlag, ExtensionUIContext, LoadExtensionsResult } from "./extensibility/extensions/types";
 import {
 	getInstalledPluginsRegistryPath,
 	getMarketplacesCacheDir,
@@ -66,7 +67,7 @@ import { resolveResumableSession, type SessionInfo, SessionManager } from "./ses
 import { profileDump, profileMark } from "./startup-profile";
 import { resolvePromptInput } from "./system-prompt";
 import type { LspStartupServerInfo } from "./tools";
-import type { EventBus } from "./utils/event-bus";
+import { EventBus } from "./utils/event-bus";
 import { fuzzyFilter } from "./utils/fuzzy";
 
 async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
@@ -314,7 +315,7 @@ async function createSessionManager(parsed: Args, cwd: string): Promise<SessionM
 	return undefined;
 }
 
-async function maybeAutoChdir(parsed: Args): Promise<void> {
+async function maybeAutoChdir(parsed: Pick<Args, "allowHome" | "cwd">): Promise<void> {
 	if (parsed.allowHome || parsed.cwd) {
 		return;
 	}
@@ -597,7 +598,23 @@ function reportUnrecognizedFlags(
 	process.exit(1);
 }
 
-export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<void> {
+function collectExtensionFlags(result: LoadExtensionsResult): {
+	flags: Map<string, ExtensionFlag>;
+	registeredNames: Map<string, string>;
+} {
+	const flags = new Map<string, ExtensionFlag>();
+	const registeredNames = new Map<string, string>();
+	for (const extension of result.extensions) {
+		for (const [registeredName, flag] of extension.flags) {
+			const cliName = registeredName.replace(/^--/, "");
+			flags.set(cliName, flag);
+			registeredNames.set(cliName, registeredName);
+		}
+	}
+	return { flags, registeredNames };
+}
+
+export async function runRootCommand(rawArgs: string[]): Promise<void> {
 	logger.startTiming();
 	profileMark("entry: runtime + module-graph loaded (pre-main)");
 
@@ -605,8 +622,60 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	// Will be re-initialized with user preferences later
 	await logger.time("initTheme:initial", initTheme);
 
-	const parsedArgs = parsed;
-	await logger.time("maybeAutoChdir", maybeAutoChdir, parsedArgs);
+	let preloadedExtensions: LoadExtensionsResult | undefined;
+	let extensionEventBus: EventBus | undefined;
+	let registeredFlagNames = new Map<string, string>();
+	const resolved = await resolveLaunchArgs(rawArgs, async bootstrap => {
+		await logger.time("maybeAutoChdir", maybeAutoChdir, bootstrap);
+		const cwd = getProjectDir();
+		const sandboxOverrides: Partial<Record<SettingPath, unknown>> = {};
+		if (bootstrap.noSandbox) sandboxOverrides["sandbox.enabled"] = false;
+		if (bootstrap.noMemories) sandboxOverrides["memories.enabled"] = false;
+		if (bootstrap.allowPath.length > 0) {
+			sandboxOverrides["sandbox.allowRead"] = bootstrap.allowPath;
+			sandboxOverrides["sandbox.allowWrite"] = bootstrap.allowPath;
+		}
+		await logger.time("settings:init", Settings.init, {
+			cwd,
+			overrides: Object.keys(sandboxOverrides).length > 0 ? sandboxOverrides : undefined,
+		});
+		initializeWithSettings(settings);
+
+		const home = os.homedir();
+		if (bootstrap.pluginDirs.length > 0) {
+			await logger.time("injectPluginDirRoots", injectPluginDirRoots, home, bootstrap.pluginDirs, cwd);
+		} else {
+			await logger.time("preloadPluginRoots", preloadPluginRoots, home, cwd);
+		}
+
+		const configuredPaths = [...bootstrap.extensions, ...bootstrap.hooks];
+		extensionEventBus = new EventBus();
+		preloadedExtensions = bootstrap.noExtensions
+			? await logger.time("loadExtensions", loadExtensions, configuredPaths, cwd, extensionEventBus)
+			: await logger.time(
+					"discoverAndLoadExtensions",
+					discoverAndLoadExtensions,
+					[...configuredPaths, ...(settings.get("extensions") ?? [])],
+					cwd,
+					extensionEventBus,
+					settings.get("disabledExtensions") ?? [],
+				);
+		for (const { path: extensionPath, error } of preloadedExtensions.errors) {
+			logger.error("Failed to load extension", { path: extensionPath, error });
+		}
+		const collected = collectExtensionFlags(preloadedExtensions);
+		registeredFlagNames = collected.registeredNames;
+		return collected.flags;
+	});
+	const parsedArgs = resolved.parsed;
+	if (resolved.bootstrap.preExtensionExit) {
+		await logger.time("maybeAutoChdir", maybeAutoChdir, parsedArgs);
+	} else {
+		reportUnrecognizedFlags(parsedArgs, resolved.extensionFlags);
+		for (const [flagName, value] of parsedArgs.unknownFlags) {
+			preloadedExtensions?.runtime.flagValues.set(registeredFlagNames.get(flagName) ?? flagName, value);
+		}
+	}
 
 	const notifs: (InteractiveModeNotify | null)[] = [];
 
@@ -655,17 +724,6 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	}
 
 	const cwd = getProjectDir();
-	const sandboxOverrides: Partial<Record<SettingPath, unknown>> = {};
-	if (parsedArgs.noSandbox) sandboxOverrides["sandbox.enabled"] = false;
-	if (parsedArgs.noMemories) sandboxOverrides["memories.enabled"] = false;
-	if (parsedArgs.allowPath?.length) {
-		sandboxOverrides["sandbox.allowRead"] = parsedArgs.allowPath;
-		sandboxOverrides["sandbox.allowWrite"] = parsedArgs.allowPath;
-	}
-	await logger.time("settings:init", Settings.init, {
-		cwd,
-		overrides: Object.keys(sandboxOverrides).length > 0 ? sandboxOverrides : undefined,
-	});
 
 	// F5 XC context is session-scoped: nothing loads at startup. We still init the
 	// ContextService singleton so /context commands and the session bootstrap work.
@@ -712,9 +770,6 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	const isInteractive = !parsedArgs.print && !autoPrint && parsedArgs.mode === undefined;
 	const mode = parsedArgs.mode || "text";
 
-	// Initialize discovery system with settings for provider persistence
-	logger.time("initializeWithSettings");
-	initializeWithSettings(settings);
 	modelRegistry.refreshInBackground();
 
 	// Apply model role overrides from CLI args or env vars (ephemeral, not persisted)
@@ -807,14 +862,6 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		})();
 	}
 
-	// Wire --plugin-dir and preload plugin roots for sync consumers (LSP config)
-	const home = os.homedir();
-	if (parsedArgs.pluginDirs && parsedArgs.pluginDirs.length > 0) {
-		await logger.time("injectPluginDirRoots", injectPluginDirRoots, home, parsedArgs.pluginDirs!, getProjectDir());
-	} else {
-		await logger.time("preloadPluginRoots", preloadPluginRoots, home, getProjectDir());
-	}
-
 	// Background marketplace update notification (non-blocking).
 	if (autoUpdate === "notify") {
 		void (async () => {
@@ -853,6 +900,10 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	sessionOptions.authStorage = authStorage;
 	sessionOptions.modelRegistry = modelRegistry;
 	sessionOptions.hasUI = isInteractive;
+	if (preloadedExtensions && extensionEventBus) {
+		sessionOptions.preloadedExtensions = preloadedExtensions;
+		sessionOptions.eventBus = extensionEventBus;
+	}
 
 	// Handle CLI --api-key as runtime override (not persisted)
 	if (parsedArgs.apiKey) {
@@ -980,18 +1031,6 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		notifs.push({ kind: "error", message: modelRegistryError.message });
 	}
 
-	// Re-parse CLI args now that extension flags are known, and apply their values. The bootstrap
-	// parse recorded each unclaimed flag with any value it consumed, so this only has to hand those
-	// values over — and whatever no extension claims is a genuine unknown flag.
-	{
-		const extFlags = session.extensionRunner?.getFlags();
-		const claimed = parseArgs(rawArgs, extFlags).unknownFlags;
-		for (const [flagName, value] of claimed) {
-			session.extensionRunner?.setFlagValue(flagName, value);
-		}
-		reportUnrecognizedFlags(parsedArgs, extFlags);
-	}
-
 	if (!isInteractive && !session.model) {
 		if (modelFallbackMessage) {
 			process.stderr.write(`${chalk.red(modelFallbackMessage)}\n`);
@@ -1008,8 +1047,11 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	const createAcpSession = async (cwd: string) => {
 		const nextSettings = await session.settings.cloneForCwd(cwd);
 		const nextSessionManager = SessionManager.create(cwd, parsedArgs.sessionDir);
+		const nextSessionOptions = { ...sessionOptions };
+		delete nextSessionOptions.preloadedExtensions;
+		delete nextSessionOptions.eventBus;
 		const { session: nextSession } = await createAgentSession({
-			...sessionOptions,
+			...nextSessionOptions,
 			cwd,
 			sessionManager: nextSessionManager,
 			settings: nextSettings,

package/src/modes/acp/acp-agent.ts

@@ -674,7 +674,7 @@ export class AcpAgent implements Agent {
 
 	#buildThinkingOptions(session: AgentSession): Array<{ value: string; name: string; description?: string }> {
 		return [
-			{ value: THINKING_OFF, name: "Off" },
+			...(session.model?.thinking?.canDisable === false ? [] : [{ value: THINKING_OFF, name: "Off" }]),
 			...session.getAvailableThinkingLevels().map(level => ({
 				value: level,
 				name: level,