@oh-my-pi/pi-coding-agent 15.13.0 → 15.13.1

package/src/autolearn/managed-skills.ts

@@ -9,11 +9,9 @@
  */
 import { constants as fsConstants, type Stats } from "node:fs";
 import * as fs from "node:fs/promises";
-import * as os from "node:os";
 import * as path from "node:path";
-import { isEnoent } from "@oh-my-pi/pi-utils";
+import { getAgentDir, isEnoent } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
-import { SOURCE_PATHS } from "../discovery/helpers";
 
 /** Provider id stamped on discovered managed skills (distinguishes them from authored). */
 export const MANAGED_SKILLS_PROVIDER_ID = "omp-managed";
@@ -24,8 +22,8 @@ export const MAX_MANAGED_SKILL_BYTES = 64_000;
 const SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 
 /** Resolve the isolated managed-skills directory (`~/.omp/agent/managed-skills`). */
-export function getManagedSkillsDir(home: string = os.homedir()): string {
-	return path.join(home, SOURCE_PATHS.native.userAgent, "managed-skills");
+export function getManagedSkillsDir(agentDir: string = getAgentDir()): string {
+	return path.join(agentDir, "managed-skills");
 }
 
 /**

package/src/capability/mcp.ts

@@ -38,13 +38,14 @@ export interface MCPServer {
 		clientSecret?: string;
 		resource?: string;
 	};
-	/** OAuth configuration (clientId, clientSecret, redirectUri, callbackPort, callbackPath) for servers requiring explicit client credentials */
+	/** OAuth configuration (clientId, clientSecret, redirectUri, callbackPort, callbackPath, prompt) for servers requiring explicit client credentials */
 	oauth?: {
 		clientId?: string;
 		clientSecret?: string;
 		redirectUri?: string;
 		callbackPort?: number;
 		callbackPath?: string;
+		prompt?: string;
 	};
 	/** Transport type */
 	transport?: "stdio" | "sse" | "http";

package/src/cli/args.ts

@@ -5,12 +5,22 @@ import { type Effort, THINKING_EFFORTS } from "@oh-my-pi/pi-catalog/effort";
 import { APP_NAME, CONFIG_DIR_NAME, logger } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { parseEffort } from "../thinking";
-import { BUILTIN_TOOLS } from "../tools";
+import { BUILTIN_TOOL_NAMES } from "../tools/builtin-names";
+import {
+	OPTIONAL_FLAGS,
+	OPTIONAL_VALUE_FLAGS,
+	type ParseDeps,
+	PROFILE_BOOTSTRAP_BOUNDARY_ARG,
+	STRING_SETTERS,
+	STRING_VALUE_FLAGS,
+} from "./flag-tables";
 
 export type Mode = "text" | "json" | "rpc" | "acp" | "rpc-ui";
 
 export interface Args {
 	cwd?: string;
+	profile?: string;
+	alias?: string;
 	allowHome?: boolean;
 	provider?: string;
 	model?: string;
@@ -68,6 +78,19 @@ export interface Args {
 	unrecognizedFlags: string[];
 }
 
+/**
+ * Runtime dependencies the data-driven setters need. Constructed once at
+ * module load and passed to every {@link STRING_SETTERS} call so the
+ * setter table itself can stay free of `@oh-my-pi/pi-utils` runtime imports
+ * (which would otherwise trip the profile bootstrap's env-init ordering).
+ */
+const PARSE_DEPS: ParseDeps = {
+	logger,
+	parseEffort,
+	builtinToolNames: BUILTIN_TOOL_NAMES,
+	thinkingEfforts: THINKING_EFFORTS,
+};
+
 export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { type: "boolean" | "string" }>): Args {
 	// Work on a copy: the `--option=value` handling below splices the value
 	// into the array, and callers reuse the same argv (the post-extension
@@ -81,19 +104,19 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 		unrecognizedFlags: [],
 	};
 
+	// `--` ends option parsing (POSIX end-of-options). Everything after it is
+	// literal positional text, so flag-shaped messages are not parsed or rejected.
 	let sawSeparator = false;
 	for (let i = 0; i < args.length; i++) {
 		let arg = args[i];
-		const flagIndex = i;
-
-		// POSIX positional separator: once `--` lands, every remaining token is
-		// a positional regardless of shape. Without this, a flag-looking message
-		// (`omp -p -- --explain-this`) would be re-validated by the loop below
-		// and rejected by the unknown-flag guard (#2461 review).
 		if (sawSeparator) {
 			result.messages.push(arg);
 			continue;
 		}
+		if (arg === PROFILE_BOOTSTRAP_BOUNDARY_ARG) {
+			continue;
+		}
+		const flagIndex = i;
 
 		// Support --flag=value syntax (e.g. --tools=ask,read). The value is
 		// spliced in as the next token so value-consuming flags pick it up via
@@ -120,112 +143,59 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 			if (extFlag.type === "boolean") {
 				result.unknownFlags.set(flagName, true);
 			} else if (extFlag.type === "string" && i + 1 < args.length) {
-				// Consume the value in `--flag=value` form, or when the next token is
-				// not flag-looking. A `-`-prefixed token in space form is left to be
-				// its own flag; pass a flag-looking value as `--flag=value`.
+				// Consume the value in `--flag=value` form or when the next token is not
+				// flag-looking. A standalone `--` remains the end-of-options marker; use
+				// `--flag=--` when an extension needs a literal "--" string value.
 				if (equalsValueIndex !== -1 || !args[i + 1].startsWith("-")) {
 					result.unknownFlags.set(flagName, args[++i]);
 				}
 			}
+		} else if (STRING_VALUE_FLAGS.has(arg)) {
+			// Built-in string flags consume the next token even when it is flag-looking
+			// (`--system-prompt --profile foo` ⇒ the prompt is the literal "--profile").
+			// The one token they must never absorb is the profile bootstrap's internal
+			// boundary sentinel: an extension-shadowable built-in like `--plan` (parsed
+			// here only when its boolean extension is NOT loaded) would otherwise swallow
+			// the marker as its value and drop the user's trailing message.
+			if (i + 1 < args.length && args[i + 1] !== PROFILE_BOOTSTRAP_BOUNDARY_ARG) {
+				STRING_SETTERS[arg](result, args[++i], PARSE_DEPS);
+			}
+		} else if (OPTIONAL_VALUE_FLAGS.has(arg)) {
+			const config = OPTIONAL_FLAGS[arg];
+			const next = args[i + 1];
+			const consume =
+				next !== undefined && !next.startsWith("-") && !(config.rejectEmpty === true && next.length === 0);
+			config.set(result, consume ? args[++i] : undefined);
 		} else if (arg === "--help" || arg === "-h") {
 			result.help = true;
 		} else if (arg === "--version" || arg === "-v") {
 			result.version = true;
 		} else if (arg === "--allow-home") {
 			result.allowHome = true;
-		} else if (arg === "--cwd" && i + 1 < args.length) {
-			result.cwd = args[++i];
-		} else if (arg === "--config" && i + 1 < args.length) {
-			result.config = [...(result.config ?? []), args[++i]];
-		} else if (arg === "--mode" && i + 1 < args.length) {
-			const mode = args[++i];
-			if (mode === "text" || mode === "json" || mode === "rpc" || mode === "acp" || mode === "rpc-ui") {
-				result.mode = mode;
-			}
+		} else if (arg === "--profile" && i + 1 < args.length) {
+			// Normally stripped by `extractProfileFlags` before parseArgs sees it;
+			// kept here as a fallback for direct parseArgs callers.
+			result.profile = args[++i];
+		} else if (arg.startsWith("--profile=")) {
+			result.profile = arg.slice("--profile=".length);
+		} else if (arg === "--alias" && i + 1 < args.length) {
+			result.alias = args[++i];
+		} else if (arg.startsWith("--alias=")) {
+			result.alias = arg.slice("--alias=".length);
 		} else if (arg === "--continue" || arg === "-c") {
 			result.continue = true;
-		} else if (arg === "--resume" || arg === "-r" || arg === "--session") {
-			const next = args[i + 1];
-			if (next && !next.startsWith("-")) {
-				result.resume = args[++i];
-			} else {
-				result.resume = true;
-			}
-		} else if (arg === "--fork" && i + 1 < args.length) {
-			result.fork = args[++i];
-		} else if (arg === "--provider" && i + 1 < args.length) {
-			result.provider = args[++i];
-		} else if (arg === "--model" && i + 1 < args.length) {
-			result.model = args[++i];
-		} else if (arg === "--smol" && i + 1 < args.length) {
-			result.smol = args[++i];
-		} else if (arg === "--slow" && i + 1 < args.length) {
-			result.slow = args[++i];
-		} else if (arg === "--plan" && i + 1 < args.length) {
-			result.plan = args[++i];
-		} else if (arg === "--api-key" && i + 1 < args.length) {
-			result.apiKey = args[++i];
-		} else if (arg === "--system-prompt" && i + 1 < args.length) {
-			result.systemPrompt = args[++i];
-		} else if (arg === "--append-system-prompt" && i + 1 < args.length) {
-			result.appendSystemPrompt = args[++i];
-		} else if (arg === "--provider-session-id" && i + 1 < args.length) {
-			result.providerSessionId = args[++i];
 		} else if (arg === "--no-session") {
 			result.noSession = true;
-		} else if (arg === "--session-dir" && i + 1 < args.length) {
-			result.sessionDir = args[++i];
-		} else if (arg === "--models" && i + 1 < args.length) {
-			result.models = args[++i].split(",").map(s => s.trim());
 		} else if (arg === "--no-tools") {
 			result.noTools = true;
 		} else if (arg === "--no-lsp") {
 			result.noLsp = true;
 		} else if (arg === "--no-pty") {
 			result.noPty = true;
-		} else if (arg === "--tools" && i + 1 < args.length) {
-			const toolNames = args[++i]
-				.split(",")
-				.map(s => s.trim().toLowerCase())
-				.filter(Boolean);
-			const validTools: string[] = [];
-			for (const name of toolNames) {
-				if (name in BUILTIN_TOOLS) {
-					validTools.push(name);
-				} else {
-					logger.warn("Unknown tool passed to --tools", {
-						tool: name,
-						validTools: Object.keys(BUILTIN_TOOLS),
-					});
-				}
-			}
-			result.tools = validTools;
-		} else if (arg === "--thinking" && i + 1 < args.length) {
-			const rawThinking = args[++i];
-			const thinking = parseEffort(rawThinking);
-			if (thinking !== undefined) {
-				result.thinking = thinking;
-			} else {
-				logger.warn("Invalid thinking level passed to --thinking", {
-					level: rawThinking,
-					validThinkingLevels: THINKING_EFFORTS,
-				});
-			}
 		} else if (arg === "--hide-thinking") {
 			result.hideThinking = true;
 		} else if (arg === "--print" || arg === "-p") {
 			result.print = true;
-		} else if (arg === "--export" && i + 1 < args.length) {
-			result.export = args[++i];
-		} else if (arg === "--hook" && i + 1 < args.length) {
-			result.hooks = result.hooks ?? [];
-			result.hooks.push(args[++i]);
-		} else if ((arg === "--extension" || arg === "-e") && i + 1 < args.length) {
-			result.extensions = result.extensions ?? [];
-			result.extensions.push(args[++i]);
-		} else if (arg === "--plugin-dir" && i + 1 < args.length) {
-			result.pluginDirs = result.pluginDirs ?? [];
-			result.pluginDirs.push(args[++i]);
 		} else if (arg === "--no-extensions") {
 			result.noExtensions = true;
 		} else if (arg === "--no-skills") {
@@ -236,19 +206,6 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 			result.noTitle = true;
 		} else if (arg === "--auto-approve" || arg === "--yolo") {
 			result.autoApprove = true;
-		} else if (arg === "--approval-mode" && i + 1 < args.length) {
-			const mode = args[++i];
-			if (mode === "always-ask" || mode === "write" || mode === "yolo") {
-				result.approvalMode = mode;
-			} else {
-				logger.warn("Invalid value passed to --approval-mode", {
-					value: mode,
-					validValues: ["always-ask", "write", "yolo"],
-				});
-			}
-		} else if (arg === "--skills" && i + 1 < args.length) {
-			// Comma-separated glob patterns for skill filtering
-			result.skills = args[++i].split(",").map(s => s.trim());
 		} else if (arg.startsWith("@")) {
 			result.fileArgs.push(arg.slice(1)); // Remove @ prefix
 		} else if (!arg.startsWith("-") || arg === "-") {
@@ -344,13 +301,14 @@ export function getExtraHelpText(): string {
   ANTHROPIC_SEARCH_BASE_URL  - Anthropic web search base URL (override; pairs with ANTHROPIC_SEARCH_API_KEY)
 
   ${chalk.dim("# Configuration")}
+  OMP_PROFILE                 - Named profile for isolated agent state (same as --profile)
+  Use \`omp --profile <name> --alias <command>\` to create a shell shortcut for a profile
   PI_CODING_AGENT_DIR        - Session storage directory (default: ~/${CONFIG_DIR_NAME}/agent)
   PI_PACKAGE_DIR             - Override package directory (for Nix/Guix store paths)
   PI_SMOL_MODEL              - Override smol/fast model (see --smol)
   PI_SLOW_MODEL              - Override slow/reasoning model (see --slow)
   PI_PLAN_MODEL              - Override planning model (see --plan)
   PI_NO_PTY                  - Disable PTY-based interactive bash execution
-
   For complete environment variable reference, see:
   ${chalk.dim("docs/environment-variables.md")}
 ${chalk.bold("Available Tools (default-enabled unless noted):")}

package/src/cli/completion-gen.ts

@@ -15,7 +15,7 @@
  * knob and is keyed by flag name so it stays stable as flags are added.
  */
 import type { ArgDescriptor, CliConfig, CommandCtor, FlagDescriptor } from "@oh-my-pi/pi-utils/cli";
-import { BUILTIN_TOOLS } from "../tools";
+import { BUILTIN_TOOL_NAMES } from "../tools/builtin-names";
 
 export type Shell = "bash" | "zsh" | "fish";
 
@@ -77,7 +77,7 @@ function flagValue(name: string, desc: FlagDescriptor): ValueSource {
 	if (MODEL_FLAGS[name]) return { kind: "models", multiple: false };
 	if (name === "models") return { kind: "models", multiple: true };
 	if (SESSION_FLAGS[name]) return { kind: "sessions" };
-	if (name === "tools") return { kind: "list", values: Object.keys(BUILTIN_TOOLS) };
+	if (name === "tools") return { kind: "list", values: BUILTIN_TOOL_NAMES };
 	if (DIR_FLAGS[name]) return { kind: "dir" };
 	if (desc.kind === "integer") return { kind: "value" };
 	return { kind: "file" };

package/src/cli/flag-tables.ts

@@ -0,0 +1,270 @@
+/**
+ * Single source of truth for argv flag classification, shared by:
+ *   - `parseArgs` in `./args.ts` (the launch-time CLI parser)
+ *   - `extractProfileFlags` in `./profile-bootstrap.ts` (the early
+ *     `--profile` / `--alias` pre-parser)
+ *
+ * `parseArgs` dispatches string-valued flags by looking up their setter in
+ * {@link STRING_SETTERS}. Optional-value flags use {@link OPTIONAL_FLAGS} so
+ * per-flag quirks (currently empty-string rejection for `--resume`) live here
+ * instead of being hard-coded in the dispatch loop.
+ *
+ * The bootstrap doesn't dispatch — it only needs to know which flags consume
+ * a value — so it consults {@link STRING_VALUE_FLAGS} and
+ * {@link OPTIONAL_VALUE_FLAGS}, both derived from `Object.keys(...)` on the
+ * setter/config records below.
+ *
+ * The deliberate consequence: a string-valued flag exists in this CLI surface
+ * iff it has an entry here. Adding a new string-valued flag means adding a
+ * setter/config entry in this file; both `args.ts` and the bootstrap pick it
+ * up automatically, so the two cannot drift out of sync.
+ *
+ * IMPORT RULE: this module MUST NOT import any runtime value from
+ * `@oh-my-pi/pi-utils` (or anything that transitively does). That package's
+ * `env.ts` eagerly loads `.env` files from `getAgentDir()` during module
+ * initialization, which would race the profile bootstrap. Type-only imports
+ * are erased at runtime and are therefore safe.
+ *
+ * If a setter needs runtime dependencies (logging, validators, lookup
+ * tables), they're passed in through {@link ParseDeps} and `args.ts` wires the
+ * real implementations at the dispatch site.
+ */
+
+import type { Effort } from "@oh-my-pi/pi-ai";
+import type { Args } from "./args";
+
+/**
+ * Runtime dependencies injected into setters that need to validate input or
+ * warn about bad values. `args.ts` constructs one object at module load and
+ * passes it to each {@link STRING_SETTERS} call.
+ *
+ * Keeping these out of the setter closures means this module stays free of
+ * runtime imports from `@oh-my-pi/pi-utils`, which is the whole reason it can
+ * be safely imported by `profile-bootstrap.ts` before `setProfile` runs.
+ */
+export interface ParseDeps {
+	logger: { warn: (message: string, meta?: Record<string, unknown>) => void };
+	parseEffort: (value: string | null | undefined) => Effort | undefined;
+	builtinToolNames: readonly string[];
+	thinkingEfforts: readonly string[];
+}
+
+export type StringSetter = (result: Args, value: string, deps: ParseDeps) => void;
+
+/**
+ * Setter for a flag that may or may not consume the next argv token.
+ * Receives `undefined` for the bare form (`--resume` with no value, etc.).
+ */
+export type OptionalSetter = (result: Args, value: string | undefined) => void;
+
+/**
+ * Per-flag optional-value consumption policy.
+ *
+ * Every optional flag always rejects tokens that start with `-` — that shared
+ * rule lives in the dispatch site. These booleans capture the *additional*
+ * per-flag quirks:
+ *
+ * - `rejectEmpty`: treat `""` like “no value provided”. Needed for
+ *   `--resume` / `-r` / `--session`. Without it, an empty string
+ *   gets consumed as the session prefix and downstream resolution can match
+ *   every session.
+ */
+export interface OptionalFlagConfig {
+	set: OptionalSetter;
+	rejectEmpty?: boolean;
+}
+
+// Shared setters for flags that alias the same field.
+const setExtension: StringSetter = (result, value) => {
+	result.extensions = result.extensions ?? [];
+	result.extensions.push(value);
+};
+
+const setResume: OptionalSetter = (result, value) => {
+	result.resume = value !== undefined ? value : true;
+};
+
+/**
+ * Setters for flags with string values. Most built-ins consume the next argv
+ * token even when it starts with `-`; flags listed in
+ * {@link EXTENSION_SHADOWABLE_STRING_FLAGS} use extension-style consumption so
+ * a registered boolean extension can shadow them before profile bootstrap.
+ */
+export const STRING_SETTERS: Record<string, StringSetter> = {
+	"--cwd": (result, value) => {
+		result.cwd = value;
+	},
+	"--config": (result, value) => {
+		result.config = [...(result.config ?? []), value];
+	},
+	"--mode": (result, value) => {
+		if (value === "text" || value === "json" || value === "rpc" || value === "acp" || value === "rpc-ui") {
+			result.mode = value;
+		}
+	},
+	"--fork": (result, value) => {
+		result.fork = value;
+	},
+	"--provider": (result, value) => {
+		result.provider = value;
+	},
+	"--model": (result, value) => {
+		result.model = value;
+	},
+	"--smol": (result, value) => {
+		result.smol = value;
+	},
+	"--slow": (result, value) => {
+		result.slow = value;
+	},
+	"--plan": (result, value) => {
+		result.plan = value;
+	},
+	"--api-key": (result, value) => {
+		result.apiKey = value;
+	},
+	"--system-prompt": (result, value) => {
+		result.systemPrompt = value;
+	},
+	"--append-system-prompt": (result, value) => {
+		result.appendSystemPrompt = value;
+	},
+	"--provider-session-id": (result, value) => {
+		result.providerSessionId = value;
+	},
+	"--session-dir": (result, value) => {
+		result.sessionDir = value;
+	},
+	"--models": (result, value) => {
+		result.models = value.split(",").map(s => s.trim());
+	},
+	"--tools": (result, value, deps) => {
+		const names = value
+			.split(",")
+			.map(s => s.trim().toLowerCase())
+			.filter(Boolean);
+		const valid: string[] = [];
+		for (const name of names) {
+			if (deps.builtinToolNames.includes(name)) {
+				valid.push(name);
+			} else {
+				deps.logger.warn("Unknown tool passed to --tools", {
+					tool: name,
+					validTools: deps.builtinToolNames,
+				});
+			}
+		}
+		result.tools = valid;
+	},
+	"--thinking": (result, value, deps) => {
+		const thinking = deps.parseEffort(value);
+		if (thinking !== undefined) {
+			result.thinking = thinking;
+		} else {
+			deps.logger.warn("Invalid thinking level passed to --thinking", {
+				level: value,
+				validThinkingLevels: deps.thinkingEfforts,
+			});
+		}
+	},
+	"--export": (result, value) => {
+		result.export = value;
+	},
+	"--hook": (result, value) => {
+		result.hooks = result.hooks ?? [];
+		result.hooks.push(value);
+	},
+	"--extension": setExtension,
+	"-e": setExtension,
+	"--plugin-dir": (result, value) => {
+		result.pluginDirs = result.pluginDirs ?? [];
+		result.pluginDirs.push(value);
+	},
+	"--skills": (result, value) => {
+		result.skills = value.split(",").map(s => s.trim());
+	},
+	"--approval-mode": (result, value, deps) => {
+		if (value === "always-ask" || value === "write" || value === "yolo") {
+			result.approvalMode = value;
+		} else {
+			deps.logger.warn("Invalid value passed to --approval-mode", {
+				value,
+				validValues: ["always-ask", "write", "yolo"],
+			});
+		}
+	},
+};
+
+/**
+ * Optional-value flags. Setters receive `undefined` for the bare form.
+ *
+ * The dispatch in `args.ts` applies the shared "doesn't start with `-`"
+ * check for every flag, then consults the per-flag booleans below for the
+ * remaining quirks.
+ */
+export const OPTIONAL_FLAGS: Record<string, OptionalFlagConfig> = {
+	"--resume": { set: setResume, rejectEmpty: true },
+	"-r": { set: setResume, rejectEmpty: true },
+	"--session": { set: setResume, rejectEmpty: true },
+};
+
+/**
+ * Derived from {@link STRING_SETTERS}. A flag is in this set if and only if
+ * it has a setter — by construction, drift between "the bootstrap thinks
+ * this flag accepts a value" and "the launch parser can set one" is
+ * structurally impossible.
+ */
+export const STRING_VALUE_FLAGS: ReadonlySet<string> = new Set(Object.keys(STRING_SETTERS));
+
+/**
+ * Built-in string flags known to be shadowed by bundled/common boolean
+ * extensions before extension metadata is available. They still accept a
+ * value-like successor for the built-in form (`--plan opus`), but a
+ * flag-looking successor remains a fresh flag (`--plan --profile work`).
+ */
+export const EXTENSION_SHADOWABLE_STRING_FLAGS: ReadonlySet<string> = new Set(["--plan"]);
+
+/**
+ * Derived from {@link OPTIONAL_FLAGS}. Same single-source contract as
+ * {@link STRING_VALUE_FLAGS}.
+ */
+export const OPTIONAL_VALUE_FLAGS: ReadonlySet<string> = new Set(Object.keys(OPTIONAL_FLAGS));
+
+/**
+ * Internal marker inserted by the profile bootstrap when removing `--profile`
+ * or `--alias` would otherwise make the following value-like token become the
+ * value of a preceding optional/extension flag. `parseArgs` ignores it, but its
+ * flag-looking shape preserves argv boundaries during the second parse.
+ */
+export const PROFILE_BOOTSTRAP_BOUNDARY_ARG = "--omp-profile-boundary";
+
+/**
+ * Long-form launch flags that take NO value (booleans). The bootstrap pre-parser
+ * needs this to tell a known value-less flag (whose successor is a fresh
+ * argument — `omp --print --profile work` still selects a profile) apart from an
+ * UNKNOWN long option that might be an extension string flag consuming the next
+ * token as its value (so the bootstrap must not steal that token as a global
+ * `--profile`/`--alias`). MUST mirror the value-less flag arms of `parseArgs`
+ * in `./args.ts`: adding a new boolean launch flag there means adding it here,
+ * or `--<newflag> --profile X` stops selecting a profile. Short aliases
+ * (`-h`/`-v`/`-c`/`-p`) are intentionally omitted — the protection rule only
+ * fires for `--`-prefixed tokens.
+ */
+export const VALUELESS_FLAGS: ReadonlySet<string> = new Set([
+	"--help",
+	"--version",
+	"--allow-home",
+	"--continue",
+	"--no-session",
+	"--no-tools",
+	"--no-lsp",
+	"--no-pty",
+	"--hide-thinking",
+	"--print",
+	"--no-extensions",
+	"--no-skills",
+	"--no-rules",
+	"--no-title",
+	"--auto-approve",
+	"--yolo",
+]);