fireflyy 4.0.0-alpha.8 → 4.0.0-dev.3098d1f

package/dist/{program-CASpr1JR.js → program-DSsTcwvN.js}

@@ -1,10 +1,12 @@
-import { n as RuntimeEnv, t as logger } from "./main.js";
-import { _ as validationError, a as conflictErrAsync, c as notFoundErrAsync, d as validationErrAsync, f as conflictError, h as notFoundError, i as FireflyOkAsync, l as timeoutErrAsync, m as failedError, n as FireflyErrAsync, r as FireflyOk, s as invalidErr, t as FireflyErr, u as validationErr, v as wrapErrorMessage } from "./result.constructors-C9M1MP3_.js";
-import { i as zipAsync, n as wrapPromise, r as zip3Async, t as ensureNotAsync } from "./result.utilities-oXWCXEvw.js";
-import { n as parseSchema, t as formatZodErrors } from "./schema.utilities-BGd9t1wm.js";
+import { t as RuntimeEnv } from "./main.js";
+import { _ as notFoundError, a as conflictErrAsync, b as wrapErrorMessage, c as invalidErrAsync, d as validationErr, f as validationErrAsync, h as failedError, i as FireflyOkAsync, l as notFoundErrAsync, n as FireflyErrAsync, o as failedErrAsync, p as conflictError, r as FireflyOk, s as invalidErr, t as FireflyErr, u as timeoutErrAsync, y as validationError } from "./result.constructors-D9jmQ0uj.js";
+import { n as wrapPromise, t as ensureNotAsync } from "./result.utilities-DiG1ae54.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
+import { t as Version } from "./version-D6rAEmbf.js";
+import { t as formatZodErrors } from "./schema.utilities-Y2MdlRMu.js";
+import { Command, InvalidArgumentError } from "commander";
 import { LogLevels } from "consola";
 import { colors } from "consola/utils";
-import { Command } from "commander";
 import { loadConfig } from "c12";
 import { Result, ResultAsync, err, ok } from "neverthrow";
 import z$1 from "zod";
@@ -184,6 +186,223 @@ function camelToKebab(str) {
 	return result.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/_/g, "-");
 }
 
+//#endregion
+//#region src/cli/options/options.validation.ts
+/**
+* Extracts enum values from a Zod schema (handles wrapped types like optional, default).
+*
+* @param schema - The Zod schema to extract enum values from
+* @returns Array of string values if it's an enum, or null if not
+*/
+function extractEnumValues(schema) {
+	const unwrapped = unwrapZodSchema(schema);
+	if (unwrapped instanceof z$1.ZodEnum) return getEnumValuesFromZodEnum(unwrapped);
+	if (unwrapped instanceof z$1.ZodUnion) {
+		const unionOptions = getZodDef(unwrapped).options;
+		if (!unionOptions) return null;
+		const values = [];
+		for (const option of unionOptions) {
+			if (typeof option === "string") continue;
+			const innerUnwrapped = unwrapZodSchema(option);
+			if (innerUnwrapped instanceof z$1.ZodEnum) {
+				const enumValues = getEnumValuesFromZodEnum(innerUnwrapped);
+				if (enumValues) values.push(...enumValues);
+			} else if (innerUnwrapped instanceof z$1.ZodLiteral) {
+				const literalValue = getZodDef(innerUnwrapped).value;
+				if (typeof literalValue === "string" && literalValue !== "") values.push(literalValue);
+			}
+		}
+		return values.length > 0 ? values : null;
+	}
+	return null;
+}
+/**
+* Extracts enum values from a ZodEnum type.
+* Handles both Zod v4 (options array or entries object) and legacy (values array) structures.
+*
+* @param enumSchema - The ZodEnum schema
+* @returns Array of string values, or null if not found
+*/
+function getEnumValuesFromZodEnum(enumSchema) {
+	const schemaAsAny = enumSchema;
+	if (Array.isArray(schemaAsAny.options)) return schemaAsAny.options;
+	const def = getZodDef(enumSchema);
+	if (def.entries && typeof def.entries === "object") return Object.values(def.entries);
+	if (def.values && Array.isArray(def.values)) return def.values;
+	return null;
+}
+/**
+* Extracts literal values from a Zod union schema (e.g., z.union([z.literal("0"), z.literal("1")])).
+*
+* @param schema - The Zod schema to extract literal values from
+* @returns Array of literal values if it's a union of literals, or null if not
+*/
+function extractLiteralValues(schema) {
+	const unwrapped = unwrapZodSchema(schema);
+	if (unwrapped instanceof z$1.ZodUnion) {
+		const options = getZodDef(unwrapped).options;
+		if (!options) return null;
+		const values = [];
+		for (const option of options) {
+			if (typeof option === "string" || typeof option === "number") continue;
+			const innerUnwrapped = unwrapZodSchema(option);
+			if (innerUnwrapped instanceof z$1.ZodLiteral) {
+				const value = getZodDef(innerUnwrapped).value;
+				if (typeof value === "string" || typeof value === "number") values.push(value);
+			}
+		}
+		return values.length > 0 ? values : null;
+	}
+	return null;
+}
+/**
+* Creates a CLI option validator for enum fields.
+*
+* Commander.js requires throwing InvalidArgumentError for validation errors.
+* This is a boundary where exceptions are appropriate for the CLI framework.
+*
+* @param schema - The Zod schema for validation
+* @param optionName - The CLI option name (for error messages)
+* @param choices - The valid enum choices
+* @returns A parser function that throws InvalidArgumentError on failure
+*/
+function createEnumValidator(schema, optionName, choices) {
+	return (input) => {
+		const result = schema.safeParse(input);
+		if (!result.success) throw new InvalidArgumentError(`Invalid value for --${optionName}: "${input}". Must be one of: ${choices.join(", ")}`);
+		return result.data;
+	};
+}
+/**
+* Creates a CLI option validator for number fields.
+*
+* Commander.js requires throwing InvalidArgumentError for validation errors.
+* This is a boundary where exceptions are appropriate for the CLI framework.
+*
+* @param schema - The Zod schema for validation
+* @param optionName - The CLI option name (for error messages)
+* @returns A parser function that throws InvalidArgumentError on failure
+*/
+function createNumberValidator(schema, optionName) {
+	return (input) => {
+		const num = Number(input);
+		if (Number.isNaN(num)) throw new InvalidArgumentError(`Invalid number for --${optionName}: "${input}". Expected a valid number.`);
+		const result = schema.safeParse(num);
+		if (!result.success) throw new InvalidArgumentError(`Invalid value for --${optionName}: "${input}". ${formatZodErrorMessage(result.error)}`);
+		return result.data;
+	};
+}
+/**
+* Creates a CLI option validator for string fields.
+*
+* Commander.js requires throwing InvalidArgumentError for validation errors.
+* This is a boundary where exceptions are appropriate for the CLI framework.
+*
+* @param schema - The Zod schema for validation
+* @param optionName - The CLI option name (for error messages)
+* @returns A parser function that throws InvalidArgumentError on failure
+*/
+function createStringValidator(schema, optionName) {
+	return (input) => {
+		const result = schema.safeParse(input);
+		if (!result.success) throw new InvalidArgumentError(`Invalid value for --${optionName}: "${input}". ${formatZodErrorMessage(result.error)}`);
+		return result.data;
+	};
+}
+/**
+* Creates a CLI option validator for union types with literal values.
+*
+* Commander.js requires throwing InvalidArgumentError for validation errors.
+* This is a boundary where exceptions are appropriate for the CLI framework.
+*
+* @param schema - The Zod schema for validation
+* @param optionName - The CLI option name (for error messages)
+* @param values - The valid literal values
+* @returns A parser function that throws InvalidArgumentError on failure
+*/
+function createLiteralUnionValidator(schema, optionName, values) {
+	return (input) => {
+		const numericValues = values.filter((v) => typeof v === "number");
+		let parsedInput = input;
+		if (numericValues.length > 0 && !Number.isNaN(Number(input))) parsedInput = Number(input);
+		const result = schema.safeParse(parsedInput);
+		if (!result.success) throw new InvalidArgumentError(`Invalid value for --${optionName}: "${input}". Must be one of: ${values.map((v) => typeof v === "string" ? `"${v}"` : String(v)).join(", ")}`);
+		return result.data;
+	};
+}
+/**
+* Creates a generic CLI option validator.
+*
+* Commander.js requires throwing InvalidArgumentError for validation errors.
+* This is a boundary where exceptions are appropriate for the CLI framework.
+*
+* @param schema - The Zod schema for validation
+* @param optionName - The CLI option name (for error messages)
+* @returns A parser function that throws InvalidArgumentError on failure
+*/
+function createGenericValidator(schema, optionName) {
+	return (input) => {
+		const result = schema.safeParse(input);
+		if (!result.success) throw new InvalidArgumentError(`Invalid value for --${optionName}: "${input}". ${formatZodErrorMessage(result.error)}`);
+		return result.data;
+	};
+}
+/**
+* Formats a Zod error into a user-friendly message.
+*
+* @param error - The Zod error object
+* @returns A formatted error message
+*/
+function formatZodErrorMessage(error) {
+	const firstIssue = error.issues[0];
+	if (!firstIssue) return "Validation failed.";
+	switch (firstIssue.code) {
+		case "invalid_value": {
+			const issue = firstIssue;
+			if (issue.values) return `Expected one of: ${issue.values.join(", ")}`;
+			return firstIssue.message;
+		}
+		case "invalid_type": return `Expected ${firstIssue.expected}`;
+		case "too_small":
+		case "too_big": return firstIssue.message;
+		default: return firstIssue.message;
+	}
+}
+/**
+* Gets the internal definition object from a Zod type.
+* Handles both modern Zod v4 (_zod.def) and legacy (_def) structures.
+*
+* @param field - The Zod type to get the definition from
+* @returns The internal definition object
+*/
+function getZodDef(field) {
+	const zodContainer = field._zod;
+	if (zodContainer?.def) return zodContainer.def;
+	return field._def ?? {};
+}
+/**
+* Unwraps Zod wrapper types (optional, default, etc.) to get the inner type.
+*
+* @param field - The Zod type to unwrap
+* @returns The unwrapped inner type
+*/
+function unwrapZodSchema(field) {
+	const def = getZodDef(field);
+	if (field instanceof z$1.ZodDefault) {
+		const inner = def.innerType;
+		return inner ? unwrapZodSchema(inner) : field;
+	}
+	if (field instanceof z$1.ZodOptional) {
+		const inner = def.innerType;
+		return inner ? unwrapZodSchema(inner) : field;
+	}
+	if (field instanceof z$1.ZodNullable) {
+		const inner = def.innerType;
+		return inner ? unwrapZodSchema(inner) : field;
+	}
+	return field;
+}
+
 //#endregion
 //#region src/cli/options/options.builder.ts
 /**
@@ -304,15 +523,14 @@ var OptionsBuilder = class {
 		this.registerGenericOption(ctx);
 	}
 	/**
-	* Registers a number option with numeric parsing.
+	* Registers a number option with numeric parsing and validation.
 	*
 	* @param ctx - The option context
 	*/
 	registerNumberOption(ctx) {
 		const { command, rawField, optionFlag, optionName, description, parsedDefault } = ctx;
-		const parser = this.createNumberParser(rawField, optionName);
-		const wrappedParser = this.wrapParser(parser);
-		command.option(`${optionFlag} <${optionName}>`, description, wrappedParser, parsedDefault);
+		const validator = createNumberValidator(rawField, optionName);
+		command.option(`${optionFlag} <${optionName}>`, description, validator, parsedDefault);
 	}
 	/**
 	* Registers an enum option with choice validation.
@@ -320,111 +538,46 @@ var OptionsBuilder = class {
 	* @param ctx - The option context
 	*/
 	registerEnumOption(ctx) {
-		const { command, rawField, field, optionFlag, optionName, description, parsedDefault } = ctx;
-		const choices = this.getEnumChoices(field);
-		const parser = this.createEnumParser(rawField, optionName, choices);
-		const wrappedParser = this.wrapParser(parser);
+		const { command, rawField, optionFlag, optionName, description, parsedDefault } = ctx;
+		const choices = extractEnumValues(rawField) ?? [];
+		const validator = createEnumValidator(rawField, optionName, choices);
 		const fullDescription = `${description}${choices.length ? ` (choices: ${choices.join(", ")})` : ""}`;
-		command.option(`${optionFlag} <${optionName}>`, fullDescription, wrappedParser, parsedDefault);
+		command.option(`${optionFlag} <${optionName}>`, fullDescription, validator, parsedDefault);
 	}
 	/**
-	*  Registers a string option with validation.
+	* Registers a string option with validation.
 	*
 	* @param ctx - The option context
 	*/
 	registerStringOption(ctx) {
 		const { command, rawField, optionFlag, optionName, description, parsedDefault } = ctx;
-		const parser = this.createStringParser(rawField);
-		const wrappedParser = this.wrapParser(parser);
-		command.option(`${optionFlag} <${optionName}>`, description, wrappedParser, parsedDefault);
+		const validator = createStringValidator(rawField, optionName);
+		command.option(`${optionFlag} <${optionName}>`, description, validator, parsedDefault);
 	}
 	/**
 	* Registers a generic option for other Zod types.
+	* Handles union types with literal values specially for better error messages.
 	*
 	* @param ctx - The option context
 	*/
 	registerGenericOption(ctx) {
 		const { command, rawField, optionFlag, optionName, description, parsedDefault } = ctx;
-		const parser = this.createGenericParser(rawField);
-		const wrappedParser = this.wrapParser(parser);
-		command.option(`${optionFlag} <${optionName}>`, description, wrappedParser, parsedDefault);
-	}
-	/**
-	* Wraps a Result-returning parser into a Commander-compatible parser.
-	*
-	* Commander expects parsers to return values directly or throw on error.
-	* This wrapper converts our Result-based parsers to that pattern.
-	*
-	* @param parser - The Result-based parser function
-	* @returns A Commander-compatible parser function
-	*/
-	wrapParser(parser) {
-		return (input) => {
-			const result = parser(input);
-			if (result.isErr()) throw new Error(result.error);
-			return result.value;
-		};
-	}
-	/**
-	* Creates a parser for number options.
-	*
-	* @template T - The expected return type
-	* @param rawField - The raw Zod field
-	* @param optionName - The option name for error messages
-	* @returns A parser function that converts strings to numbers with validation
-	*/
-	createNumberParser(rawField, optionName) {
-		return (input) => {
-			const num = Number(input);
-			if (Number.isNaN(num)) return err(`Invalid number for --${optionName}: ${input}`);
-			const result = parseSchema(rawField, num);
-			if (result.isErr()) return err(result.error.message);
-			return ok(result.value);
-		};
-	}
-	/**
-	* Creates a parser for enum options.
-	*
-	* @template T - The expected return type
-	* @param rawField - The raw Zod field
-	* @param optionName - The option name for error messages
-	* @param choices - The valid enum choices
-	* @returns A parser function that validates input against the enum choices
-	*/
-	createEnumParser(rawField, optionName, choices) {
-		return (input) => {
-			const result = parseSchema(rawField, input);
-			if (result.isErr()) return err(`Invalid value for --${optionName}: ${input}. Allowed: ${choices.join(", ")}`);
-			return ok(result.value);
-		};
-	}
-	/**
-	* Creates a parser for string options.
-	*
-	* @template T - The expected return type
-	* @param rawField - The raw Zod field
-	* @returns A parser function that validates input against the schema
-	*/
-	createStringParser(rawField) {
-		return (input) => {
-			const result = parseSchema(rawField, input);
-			if (result.isErr()) return err(result.error.message);
-			return ok(result.value);
-		};
-	}
-	/**
-	* Creates a generic parser using Zod validation.
-	*
-	* @template T - The expected return type
-	* @param rawField - The raw Zod field
-	* @returns A parser function that validates input against the schema
-	*/
-	createGenericParser(rawField) {
-		return (input) => {
-			const result = parseSchema(rawField, input);
-			if (result.isErr()) return err(result.error.message);
-			return ok(result.value);
-		};
+		const literalValues = extractLiteralValues(rawField);
+		if (literalValues) {
+			const validator$1 = createLiteralUnionValidator(rawField, optionName, literalValues);
+			const fullDescription = `${description} (choices: ${literalValues.map((v) => typeof v === "string" ? v : String(v)).join(", ")})`;
+			command.option(`${optionFlag} <${optionName}>`, fullDescription, validator$1, parsedDefault);
+			return;
+		}
+		const enumValues = extractEnumValues(rawField);
+		if (enumValues) {
+			const validator$1 = createEnumValidator(rawField, optionName, enumValues);
+			const fullDescription = `${description} (choices: ${enumValues.join(", ")})`;
+			command.option(`${optionFlag} <${optionName}>`, fullDescription, validator$1, parsedDefault);
+			return;
+		}
+		const validator = createGenericValidator(rawField, optionName);
+		command.option(`${optionFlag} <${optionName}>`, description, validator, parsedDefault);
 	}
 	/**
 	* Gets the internal definition object from a Zod type.
@@ -469,15 +622,6 @@ var OptionsBuilder = class {
 		const def = this.getInternalDef(rawField);
 		return (def.innerType ?? def.schema) instanceof z$1.ZodBoolean;
 	}
-	/**
-	* Extracts enum choices from a ZodEnum field.
-	*
-	* @param field - The ZodEnum field
-	* @returns The array of valid enum choices
-	*/
-	getEnumChoices(field) {
-		return this.getInternalDef(field).values ?? [];
-	}
 };
 
 //#endregion
@@ -1003,9 +1147,10 @@ function createBumpExecutionGroup() {
 */
 function shouldSkipBumpStrategy(ctx) {
 	const { skipBump, releaseType, bumpStrategy } = ctx.config;
+	const { selectedReleaseType, selectedBumpStrategy } = ctx.data;
 	if (skipBump) return true;
-	if (releaseType) return true;
-	if (!bumpStrategy) return true;
+	if (releaseType || selectedReleaseType) return true;
+	if (!Boolean(bumpStrategy || selectedBumpStrategy)) return true;
 	return false;
 }
 /**
@@ -1013,9 +1158,11 @@ function shouldSkipBumpStrategy(ctx) {
 */
 function getSkipReason(ctx) {
 	const { skipBump, releaseType, bumpStrategy } = ctx.config;
+	const { selectedReleaseType, selectedBumpStrategy } = ctx.data;
 	if (skipBump) return "skipBump is enabled";
-	if (releaseType) return `releaseType already set to '${releaseType}'`;
-	if (!bumpStrategy) return "no bumpStrategy configured";
+	if (releaseType) return `releaseType already set to '${releaseType}' (config)`;
+	if (selectedReleaseType) return `releaseType already set to '${selectedReleaseType}' (data)`;
+	if (!Boolean(bumpStrategy || selectedBumpStrategy)) return "no bumpStrategy configured";
 	return "unknown reason";
 }
 function createDelegateBumpStrategyTask() {
@@ -1034,7 +1181,10 @@ function createDelegateBumpStrategyTask() {
 //#endregion
 //#region src/commands/release/tasks/determine-automatic-bump.task.ts
 function createDetermineAutomaticBump() {
-	return TaskBuilder.create("determine-automatic-bump").description("Automatically determines the version bump from commit messages").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => ctx.config.skipBump || ctx.config.bumpStrategy !== BUMP_STRATEGY_AUTO, "Skipped: skipBump enabled or bumpStrategy is not 'auto'").execute((ctx) => {
+	return TaskBuilder.create("determine-automatic-bump").description("Automatically determines the version bump from commit messages").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => {
+		const bumpStrategy = ctx.data.selectedBumpStrategy ?? ctx.config.bumpStrategy;
+		return ctx.config.skipBump || bumpStrategy !== BUMP_STRATEGY_AUTO;
+	}, "Skipped: skipBump enabled or bumpStrategy is not 'auto'").execute((ctx) => {
 		logger.info("determine-automatic-bump");
 		return FireflyOkAsync(ctx);
 	}).build();
@@ -1042,17 +1192,69 @@ function createDetermineAutomaticBump() {
 
 //#endregion
 //#region src/commands/release/tasks/prompt-bump-strategy.task.ts
+const BUMP_STRATEGIES = [{
+	label: "Automatic Bump",
+	value: BUMP_STRATEGY_AUTO,
+	hint: "Determines the next version based on conventional commits history"
+}, {
+	label: "Manual Bump",
+	value: BUMP_STRATEGY_MANUAL,
+	hint: "Manually specify the next version"
+}];
+const VALID_STRATEGY_VALUES = BUMP_STRATEGIES.map((s) => s.value);
+/**
+* Validates that the selected strategy is one of the allowed values.
+*
+* @param strategy The selected version bump strategy.
+* @returns A FireflyResult indicating success or failure of validation.
+*/
+function validateStrategy(strategy) {
+	if (!VALID_STRATEGY_VALUES.includes(strategy)) return invalidErr({ message: `Invalid version bump strategy: ${strategy}` });
+	return FireflyOk(strategy);
+}
+/**
+* Prompts the user to select a bump strategy using the logger's prompt API.
+*/
+function promptBumpStrategy() {
+	const defaultStrategy = BUMP_STRATEGIES[0];
+	if (!defaultStrategy) return notFoundErrAsync({ message: "No default version bump strategy found" });
+	logger.verbose("PromptBumpStrategyTask: Prompting user for version bump strategy.");
+	return wrapPromise(logger.prompt("Select version bump strategy", {
+		type: "select",
+		options: BUMP_STRATEGIES,
+		initial: defaultStrategy.value,
+		cancel: "undefined"
+	})).andThen((selected) => {
+		if (!selected || selected === "") return failedErrAsync({ message: "Operation cancelled by user" });
+		if (logger.level === LogLevels.verbose) logger.log("");
+		if (logger.level !== LogLevels.verbose) logger.log("");
+		const validationResult = validateStrategy(selected);
+		if (validationResult.isErr()) return FireflyErrAsync(validationResult.error);
+		logger.verbose(`PromptBumpStrategyTask: Selected version bump strategy: '${selected}'`);
+		return FireflyOkAsync(selected);
+	});
+}
+/**
+* Creates the Prompt Bump Strategy Task.
+*
+* This task prompts the user to select a version bump strategy (automatic or manual) and
+* stores it in the release context. It depends on `initialize-release-version` and will be
+* skipped when `skipBump` is enabled or a `bumpStrategy`/`releaseType` is already provided.
+*
+* This task:
+* 1. Prompts the user to select a bump strategy
+*/
 function createPromptBumpStrategyTask() {
-	return TaskBuilder.create("prompt-bump-strategy").description("Prompts the user for a version bump strategy").dependsOn("initialize-release-version").skipWhenWithReason((ctx) => ctx.config.skipBump || Boolean(ctx.config.bumpStrategy) || Boolean(ctx.config.releaseType), "Skipped: skipBump enabled, or bumpStrategy/releaseType already specified").execute((ctx) => {
-		logger.info("prompt-bump-strategy");
-		return FireflyOkAsync(ctx);
-	}).build();
+	return TaskBuilder.create("prompt-bump-strategy").description("Prompts the user for a version bump strategy").dependsOn("initialize-release-version").skipWhenWithReason((ctx) => ctx.config.skipBump || Boolean(ctx.config.bumpStrategy) || Boolean(ctx.config.releaseType), "Skipped: skipBump enabled, or bumpStrategy/releaseType already specified").execute((ctx) => promptBumpStrategy().andThen((strategy) => FireflyOkAsync(ctx.fork("selectedBumpStrategy", strategy)))).build();
 }
 
 //#endregion
 //#region src/commands/release/tasks/prompt-manual-bump.task.ts
 function createPromptManualVersionTask() {
-	return TaskBuilder.create("prompt-manual-version").description("Prompts the user for a manual version bump selections").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => ctx.config.skipBump || Boolean(ctx.config.bumpStrategy) || Boolean(ctx.config.releaseType), "Skipped: skipBump enabled, or bumpStrategy/releaseType already specified").execute((ctx) => {
+	return TaskBuilder.create("prompt-manual-version").description("Prompts the user for a manual version bump selections").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => {
+		const bumpStrategy = ctx.data.selectedBumpStrategy ?? ctx.config.bumpStrategy;
+		return ctx.config.skipBump || bumpStrategy !== BUMP_STRATEGY_MANUAL;
+	}, "Skipped: skipBump enabled or bumpStrategy is not 'manual'").execute((ctx) => {
 		logger.info("prompt-manual-version");
 		return FireflyOkAsync(ctx);
 	}).build();
@@ -1060,11 +1262,43 @@ function createPromptManualVersionTask() {
 
 //#endregion
 //#region src/commands/release/tasks/straight-version-bump.task.ts
+/**
+* Parses the current version from a raw string.
+*
+* @param currentVersionRaw - The raw string representing the current version
+* @returns A FireflyResult containing the parsed Version or a validation error
+*/
+function parseCurrentVersion(currentVersionRaw) {
+	if (!currentVersionRaw) return validationErr({ message: "Current version is undefined" });
+	return Version.from(currentVersionRaw);
+}
+/**
+* Builds the bump options from the release context.
+*/
+function buildBumpOptionsFromContext(ctx) {
+	const currentVersionResult = parseCurrentVersion(ctx.data.currentVersion);
+	if (currentVersionResult.isErr()) return FireflyErrAsync(currentVersionResult.error);
+	const releaseType = ctx.config.releaseType;
+	if (releaseType === void 0) return invalidErrAsync({ message: "Release type is required for straight bump" });
+	return FireflyOkAsync({
+		currentVersion: currentVersionResult.value,
+		releaseType,
+		preReleaseID: ctx.config.preReleaseID,
+		preReleaseBase: ctx.config.preReleaseBase
+	});
+}
+/**
+* Performs the straight bump by delegating to the version bumper service.
+*/
+function executeStraightVersionBump(ctx) {
+	return buildBumpOptionsFromContext(ctx).andThen((options) => ctx.services.versionBumper.bump(options)).andThen((newVersion) => {
+		const from = ctx.data.currentVersion || "unknown";
+		logger.info(`Bumped version: ${colors.green(from)} -> ${colors.green(newVersion.raw)}`);
+		return FireflyOkAsync(ctx.fork("nextVersion", newVersion.toString()));
+	});
+}
 function createStraightVersionBump() {
-	return TaskBuilder.create("straight-version-bump").description("Performs a direct version bump based on the configured release type").dependsOn("initialize-release-version").skipWhenWithReason((ctx) => ctx.config.skipBump || ctx.config.releaseType === void 0, "Skipped: skipBump is enabled or no release type specified").execute((ctx) => {
-		logger.info("straight-version-bump");
-		return FireflyOkAsync(ctx);
-	}).build();
+	return TaskBuilder.create("straight-version-bump").description("Performs a direct version bump based on the configured release type").dependsOn("initialize-release-version").skipWhenWithReason((ctx) => ctx.config.skipBump || ctx.config.releaseType === void 0, "Skipped: skipBump is enabled or no release type specified").execute((ctx) => executeStraightVersionBump(ctx)).build();
 }
 
 //#endregion
@@ -1091,11 +1325,36 @@ function createBumpStrategyGroup() {
 
 //#endregion
 //#region src/commands/release/tasks/initialize-release-version.task.ts
+const PACKAGE_JSON_FILE = "package.json";
+/**
+* Reads package.json and extracts the version field.
+*
+* Behavior:
+* - Reads the configured package.json file.
+* - If the version property is missing, returns a validation error.
+* - Otherwise resolves with the version string.
+*/
+function getVersionFromPackageJson(ctx) {
+	return ctx.services.packageJson.read(PACKAGE_JSON_FILE).andThen((pkg) => {
+		const version = pkg.version;
+		if (!version) return validationErrAsync({ message: "The 'version' field is missing in package.json." });
+		logger.verbose(`InitializeReleaseVersionTask: Prepared current version: ${version}`);
+		return FireflyOkAsync(version);
+	});
+}
+/**
+* Creates the Initialize Release Version task.
+*
+* This task initializes the current release version by reading it from package.json.
+*
+* This task:
+* 1. Reads the version from package.json
+*/
 function createInitializeReleaseVersion() {
-	return TaskBuilder.create("initialize-release-version").description("Hydrate and prepare the release configuration").dependsOn("prepare-release-config").execute((ctx) => {
-		logger.info("initialize-release-version");
-		return FireflyOkAsync(ctx);
-	}).build();
+	return TaskBuilder.create("initialize-release-version").description("Initialize current release version from package.json").dependsOn("prepare-release-config").execute((ctx) => getVersionFromPackageJson(ctx).andThen((currentVersion) => {
+		logger.info(`Current version is ${colors.green(currentVersion)}`);
+		return FireflyOkAsync(ctx.fork("currentVersion", currentVersion));
+	})).build();
 }
 
 //#endregion
@@ -1105,6 +1364,12 @@ const SSH_REMOTE_REGEX = /git@[^:]+:([^/]+)\/([^/.]+)(?:\.git)?/;
 const SCOPED_PACKAGE_REGEX = /^@([^/]+)\/(.+)$/;
 const PRERELEASE_REGEX = /^\d+\.\d+\.\d+-([a-zA-Z]+)/;
 /**
+* Terminologies:
+*
+* Prepared: The value has been determined and set in the context.
+* Using: The value was explicitly provided in the config and is used as-is.
+*/
+/**
 * Parses a git remote URL to extract owner and repository name.
 * Supports both HTTPS and SSH formats.
 *
@@ -1147,38 +1412,17 @@ function parsePackageName(packageName) {
 * extractPreReleaseId("1.0.0-beta.1") // "beta"
 * extractPreReleaseId("1.0.0") // undefined
 */
-function extractPreReleaseId(version) {
+function extractPreReleaseID(version) {
 	return version.match(PRERELEASE_REGEX)?.[1];
 }
 /**
-* Hydrates the repository field from git remote URL.
+* Hydrates the `name` field from package.json when not provided in config.
+*
+* Cases:
+* 1. If name is undefined and package.json has no name, returns a validation error.
+* 2. If name is undefined and package.json has a name, extracts the name (stripping scope) and returns it.
+* 3. Otherwise uses provided name.
 */
-function hydrateRepository(ctx) {
-	return ctx.services.git.isInsideRepository().andThen((isRepo) => {
-		if (!isRepo) return FireflyOkAsync(void 0);
-		return ctx.services.git.getRemoteUrl().map((url) => {
-			const parsed = parseGitRemoteUrl(url);
-			if (parsed) return `${parsed.owner}/${parsed.repo}`;
-			return null;
-		}).orElse(() => FireflyOkAsync(null)).map((val) => val ?? void 0).andTee((repository) => logger.verbose(`PrepareReleaseConfigTask: Prepared repository: ${repository}`));
-	});
-}
-function hydrateFromPackageJson(ctx) {
-	return ctx.services.fs.exists("package.json").andThen((exists) => {
-		if (!exists) return FireflyOkAsync({
-			name: void 0,
-			scope: void 0,
-			preReleaseId: void 0
-		});
-		return ctx.services.packageJson.read("package.json").andThen((pkg) => zip3Async(hydrateNameFromPackageJson(ctx, pkg), hydrateScopeFromPackageJson(ctx, pkg), hydratePreReleaseIdFromPackageJson(ctx, pkg)).map(([name, scope, preReleaseId]) => {
-			const result = {};
-			if (name) result.name = name;
-			if (scope) result.scope = scope;
-			if (preReleaseId) result.preReleaseId = preReleaseId;
-			return result;
-		}));
-	});
-}
 function hydrateNameFromPackageJson(ctx, packageJson) {
 	if (ctx.config.name === void 0 && !packageJson.name) return validationErrAsync({ message: "Could not find a valid name in package.json" });
 	if (ctx.config.name === void 0 && packageJson.name) {
@@ -1189,6 +1433,14 @@ function hydrateNameFromPackageJson(ctx, packageJson) {
 	logger.verbose(`PrepareReleaseConfigTask: Using provided name: "${ctx.config.name}" as it is explicitly set`);
 	return FireflyOkAsync(ctx.config.name);
 }
+/**
+* Hydrates the `scope` field from package.json when not provided in config.
+*
+* Cases:
+* 1. If scope is explicitly provided (key exists and value is not undefined), it is used.
+* 2. If not provided, but package.json has a scoped `name` (e.g., "@scope/name"), the scope will be extracted and returned.
+* 3. Otherwise returns undefined.
+*/
 function hydrateScopeFromPackageJson(ctx, packageJson) {
 	if (Object.hasOwn(ctx.config, "scope") && ctx.config.scope !== void 0) {
 		logger.verbose(`PrepareReleaseConfigTask: Using provided scope: "${ctx.config.scope}" as it is explicitly set`);
@@ -1204,24 +1456,181 @@ function hydrateScopeFromPackageJson(ctx, packageJson) {
 	logger.verbose("PrepareReleaseConfigTask: No scope to prepare from package.json");
 	return FireflyOkAsync(void 0);
 }
-function hydratePreReleaseIdFromPackageJson(ctx, packageJson) {
-	if (ctx.config.preReleaseId !== void 0 && ctx.config.preReleaseId.trim() !== "") {
-		logger.verbose(`PrepareReleaseConfigTask: Using provided preReleaseId: "${ctx.config.preReleaseId}" as it is explicitly set`);
-		return FireflyOkAsync(ctx.config.preReleaseId);
+/**
+* Hydrates the `preReleaseID` field from `package.json.version` when not provided.
+*
+* Cases:
+* 1. If preReleaseID is explicitly provided and not an empty string, it is used.
+* 2. If not provided, and `package.json.version` contains a prerelease segment, the prerelease identifier will be extracted and returned.
+* 3. Otherwise the function defaults to "alpha".
+*/
+function hydratePreReleaseIDFromPackageJson(ctx, packageJson) {
+	if (Object.hasOwn(ctx.config, "preReleaseID") && ctx.config.preReleaseID !== void 0) {
+		logger.verbose(`PrepareReleaseConfigTask: Using provided preReleaseID: "${ctx.config.preReleaseID}" as it is explicitly set`);
+		return FireflyOkAsync(ctx.config.preReleaseID);
 	}
 	if (packageJson.version) {
 		const parsed = parse(packageJson.version);
 		if (!parsed) return validationErrAsync({ message: `Invalid version format in package.json: ${packageJson.version}` });
 		if (parsed.prerelease.length > 0 && typeof parsed.prerelease[0] === "string") {
-			const preReleaseId = extractPreReleaseId(packageJson.version);
-			logger.verbose(`PrepareReleaseConfigTask: Prepared preReleaseId from package.json: ${preReleaseId}`);
-			return FireflyOkAsync(preReleaseId);
+			const preReleaseID = extractPreReleaseID(packageJson.version);
+			logger.verbose(`PrepareReleaseConfigTask: Prepared preReleaseID from package.json: ${preReleaseID}`);
+			return FireflyOkAsync(preReleaseID);
 		}
 	}
-	logger.verbose("PrepareReleaseConfigTask: No preReleaseId to prepare from package.json, defaulting to 'alpha'");
+	logger.verbose("PrepareReleaseConfigTask: No preReleaseID to prepare from package.json, defaulting to 'alpha'");
 	return FireflyOkAsync("alpha");
 }
 /**
+* Hydrates the `preReleaseBase` field.
+*
+* Behavior:
+* - If explicitly provided in config (key exists and value is not undefined) use as-is.
+* - Otherwise default to 0.
+*
+* Note: we do NOT infer `preReleaseBase` from package.json anymore.
+*/
+function hydratePreReleaseBase(ctx) {
+	const baseMaybe = ctx.config.preReleaseBase;
+	if (Object.hasOwn(ctx.config, "preReleaseBase") && baseMaybe !== void 0) {
+		logger.verbose(`PrepareReleaseConfigTask: Using provided preReleaseBase: "${ctx.config.preReleaseBase}" as it is explicitly set`);
+		return FireflyOkAsync(baseMaybe);
+	}
+	logger.verbose("PrepareReleaseConfigTask: No preReleaseBase explicitly provided, defaulting to 0");
+	return FireflyOkAsync(0);
+}
+/**
+* Hydrates name, scope, and preReleaseId from package.json.
+*
+* Behavior:
+* - If package.json does not exist, returns all values as undefined.
+* - If it exists, reads package.json and returns parsed results for name, scope and preReleaseId.
+* - If preReleaseBase is explicitly provided in config, it is used as-is, if not, it defaults to 0.
+*/
+function hydrateFromPackageJson(ctx) {
+	return ctx.services.fs.exists("package.json").andThen((exists) => {
+		if (!exists) return FireflyOkAsync({
+			name: void 0,
+			scope: void 0,
+			preReleaseID: void 0,
+			preReleaseBase: void 0
+		});
+		return ctx.services.packageJson.read("package.json").andThen((pkg) => hydrateNameFromPackageJson(ctx, pkg).andThen((name) => hydrateScopeFromPackageJson(ctx, pkg).andThen((scope) => hydratePreReleaseIDFromPackageJson(ctx, pkg).andThen((preReleaseId) => hydratePreReleaseBase(ctx).map((preReleaseBase) => {
+			const result = {};
+			if (name) result.name = name;
+			if (scope) result.scope = scope;
+			if (preReleaseId) result.preReleaseId = preReleaseId;
+			if (preReleaseBase !== void 0) result.preReleaseBase = preReleaseBase;
+			return result;
+		})))));
+	});
+}
+/**
+* Hydrates the repository field from git remote URL.
+*
+* Behavior:
+* - If not inside a git repository, resolves to undefined.
+* - If inside a repository, detect the repository URL
+*   using a fall-through strategy (upstream remote → origin → first remote).
+* - Parses the URL and returns "owner/repo" when possible.
+*/
+function hydrateRepository(ctx) {
+	return ctx.services.git.inferRepositoryUrl().andThen((url) => {
+		if (!url) return validationErrAsync({ message: "Could not determine git remote URL to infer repository information" });
+		const parsed = parseGitRemoteUrl(url);
+		if (parsed) return FireflyOkAsync(`${parsed.owner}/${parsed.repo}`);
+		return validationErrAsync({ message: `Could not parse repository information from git remote URL: ${url}` });
+	}).andTee((repository) => logger.verbose(`PrepareReleaseConfigTask: Prepared repository: ${repository}`));
+}
+/**
+* Hydrates branch setting from git.
+*
+* Behavior:
+* - If not inside a git repository, resolves to undefined.
+* - If a branch is explicitly provided in the config, validates it against the
+*   current git branch and returns it (otherwise returns a validation error).
+* - If no branch is provided in the config, uses current git branch.
+*/
+function hydrateBranch(ctx) {
+	return ctx.services.git.isInsideRepository().andThen((isRepo) => {
+		if (!isRepo) return FireflyOkAsync(void 0);
+		return ctx.services.git.getCurrentBranch().andThen((currentBranch) => {
+			if (Object.hasOwn(ctx.config, "branch") && ctx.config.branch !== void 0 && ctx.config.branch.trim() !== "") {
+				if (ctx.config.branch !== currentBranch) return validationErrAsync({ message: `Configured branch "${ctx.config.branch}" does not match current git branch "${currentBranch}"` });
+				logger.verbose(`PrepareReleaseConfigTask: Using provided branch: "${ctx.config.branch}" as it is explicitly set`);
+				return FireflyOkAsync(ctx.config.branch);
+			}
+			logger.verbose(`PrepareReleaseConfigTask: Prepared branch from git: ${currentBranch}`);
+			return FireflyOkAsync(currentBranch);
+		});
+	});
+}
+/**
+* Hydrates repository and branch information from git.
+*
+* Behavior:
+* - If not inside a git repository, resolves both values to undefined.
+* - Otherwise it composes `hydrateRepository` and `hydrateBranch` and returns both values.
+*/
+function hydrateFromGit(ctx) {
+	return ctx.services.git.isInsideRepository().andThen((isRepo) => {
+		if (!isRepo) return FireflyOkAsync({
+			repository: void 0,
+			branch: void 0
+		});
+		return hydrateRepository(ctx).andThen((repository) => hydrateBranch(ctx).map((branch) => {
+			const result = {};
+			if (repository) result.repository = repository;
+			if (branch) result.branch = branch;
+			return result;
+		}));
+	});
+}
+/**
+* Hydrates release flags (releaseLatest, releasePreRelease, releaseDraft).
+*
+* Behavior:
+* - If exactly one flag is explicitly set to true, use that and set others to false.
+* - If no flags are explicitly set, default to releaseLatest = true, others = false.
+* - Validation of exclusivity is handled by the schema, so we only need to determine defaults.
+*/
+function hydrateReleaseFlags(ctx) {
+	const { releaseLatest, releasePreRelease, releaseDraft } = ctx.config;
+	const latestExplicit = releaseLatest === true;
+	const preReleaseExplicit = releasePreRelease === true;
+	const draftExplicit = releaseDraft === true;
+	if (preReleaseExplicit) {
+		logger.verbose(`PrepareReleaseConfigTask: Using "releasePreRelease" as it is explicitly set`);
+		return FireflyOkAsync({
+			releaseLatest: false,
+			releasePreRelease: true,
+			releaseDraft: false
+		});
+	}
+	if (draftExplicit) {
+		logger.verbose(`PrepareReleaseConfigTask: Using "releaseDraft" as it is explicitly set`);
+		return FireflyOkAsync({
+			releaseLatest: false,
+			releasePreRelease: false,
+			releaseDraft: true
+		});
+	}
+	if (latestExplicit) {
+		logger.verbose(`PrepareReleaseConfigTask: Using "releaseLatest" as it is explicitly set`);
+		return FireflyOkAsync({
+			releaseLatest: true,
+			releasePreRelease: false,
+			releaseDraft: false
+		});
+	}
+	logger.verbose("PrepareReleaseConfigTask: Prepared releaseLatest as default since no flag was explicitly set");
+	return FireflyOkAsync({
+		releaseLatest: true,
+		releasePreRelease: false,
+		releaseDraft: false
+	});
+}
+/**
 * Creates the Prepare Release Config Task.
 *
 * This task determines and hydrates configuration settings, by inferring values from the environment.
@@ -1230,17 +1639,27 @@ function hydratePreReleaseIdFromPackageJson(ctx, packageJson) {
 * 1. Detects repository owner/repo from git remote URL
 * 2. Extracts name and scope from package.json
 * 3. Extracts preReleaseId from package.json version
+* 4. Detects current git branch if not provided
+* 5. Determines release flags (latest, preRelease, draft) with proper defaults
 */
 function createPrepareReleaseConfigTask() {
 	return TaskBuilder.create("prepare-release-config").description("Hydrate and prepare the release configuration").execute((ctx) => {
 		const hydrated = {};
-		return zipAsync(hydrateRepository(ctx), hydrateFromPackageJson(ctx)).map(([repository, pkgData]) => {
-			if (repository) hydrated.repository = repository;
+		return hydrateFromGit(ctx).andThen((gitData) => {
+			if (gitData.repository) hydrated.repository = gitData.repository;
+			if (gitData.branch) hydrated.branch = gitData.branch;
+			return hydrateFromPackageJson(ctx);
+		}).andThen((pkgData) => {
 			if (pkgData.name) hydrated.name = pkgData.name;
 			if (pkgData.scope) hydrated.scope = pkgData.scope;
-			if (pkgData.preReleaseId) hydrated.preReleaseId = pkgData.preReleaseId;
-			logger.verbose(`PrepareReleaseConfigTask: Hydrated config: ${JSON.stringify(hydrated)}`);
-			return ctx.fork("hydratedConfig", hydrated);
+			if (pkgData.preReleaseID) hydrated.preReleaseID = pkgData.preReleaseID;
+			if (pkgData.preReleaseBase !== void 0) hydrated.preReleaseBase = pkgData.preReleaseBase;
+			return hydrateReleaseFlags(ctx);
+		}).map((releaseFlags) => {
+			hydrated.releaseLatest = releaseFlags.releaseLatest;
+			hydrated.releasePreRelease = releaseFlags.releasePreRelease;
+			hydrated.releaseDraft = releaseFlags.releaseDraft;
+			return ctx.forkConfig(hydrated);
 		});
 	}).build();
 }
@@ -1407,7 +1826,7 @@ function validateReleaseFlagExclusivity(ctx) {
 		"releasePreRelease",
 		"releaseDraft"
 	];
-	if (flagNames.filter((k) => ctx.value[k]).length > 1) ctx.issues.push({
+	if (flagNames.filter((k) => ctx.value[k] === true).length > 1) ctx.issues.push({
 		code: "custom",
 		message: `Only one of ${flagNames.join(", ")} can be set to true.`,
 		input: ctx.value,
@@ -1453,13 +1872,15 @@ function validateSkipFlagCombinations(ctx) {
 const ReleaseConfigSchema = z$1.object({
 	name: z$1.string().optional().describe("Unscoped project name. Auto-detected from package.json."),
 	scope: z$1.string().optional().describe("Org/user scope without '@'. Auto-detected from package.json."),
-	base: z$1.string().default("").describe("Relative path from repository root to project root."),
+	repository: z$1.string().optional().describe("GitHub repository in 'owner/repo' format."),
+	base: z$1.string().optional().describe("Relative path from repository root to project root."),
+	branch: z$1.string().optional().describe("Git branch to release from."),
 	changelogPath: z$1.string().default("CHANGELOG.md").describe("Changelog file path, relative to project root."),
 	bumpStrategy: BumpStrategySchema.describe("\"auto\" (from commits) or \"manual\" (user-specified)."),
 	releaseType: ReleaseTypeSchema.optional().describe("The release type to bump."),
-	preReleaseId: z$1.string().optional().describe("Pre-release ID (e.g., \"alpha\", \"beta\")."),
+	preReleaseID: z$1.string().optional().describe("Pre-release ID (e.g., \"alpha\", \"beta\")."),
 	preReleaseBase: PreReleaseBaseSchema.describe("Starting version for pre-releases."),
-	releaseNotes: z$1.string().default("").describe("Custom release notes for changelog."),
+	releaseNotes: z$1.string().optional().describe("Custom release notes for changelog."),
 	commitMessage: z$1.string().default(COMMIT_MSG_TEMPLATE).describe("Commit message template with placeholders."),
 	tagName: z$1.string().default(TAG_NAME_TEMPLATE).describe("Tag name template with placeholders."),
 	skipBump: z$1.coerce.boolean().default(false).describe("Skip version bump step."),
@@ -1469,9 +1890,9 @@ const ReleaseConfigSchema = z$1.object({
 	skipGit: z$1.coerce.boolean().default(false).describe("Skip all git-related steps."),
 	skipPreflightCheck: z$1.coerce.boolean().default(false).describe("Skip preflight checks."),
 	releaseTitle: z$1.string().default(RELEASE_TITLE_TEMPLATE).describe("GitHub release title with placeholders."),
-	releaseLatest: z$1.coerce.boolean().default(true).describe("Mark as latest release."),
-	releasePreRelease: z$1.coerce.boolean().default(false).describe("Mark as pre-release."),
-	releaseDraft: z$1.coerce.boolean().default(false).describe("Release as draft version.")
+	releaseLatest: z$1.coerce.boolean().optional().describe("Mark as latest release."),
+	releasePreRelease: z$1.coerce.boolean().optional().describe("Mark as pre-release."),
+	releaseDraft: z$1.coerce.boolean().optional().describe("Release as draft version.")
 }).check((ctx) => {
 	validateReleaseFlagExclusivity(ctx);
 	validateSkipGitRedundancy(ctx);
@@ -1525,21 +1946,41 @@ function defineService(definition) {
 */
 const SERVICE_DEFINITIONS = {
 	fs: defineService({ factory: async ({ basePath }) => {
-		const { createFileSystemService } = await import("./filesystem.service-B_dgIoTJ.js");
+		const { createFileSystemService } = await import("./filesystem.service-Bsm3j1Bv.js");
 		return createFileSystemService(basePath);
 	} }),
 	packageJson: defineService({
 		dependencies: ["fs"],
 		factory: async ({ getService }) => {
 			const fs = await getService("fs");
-			const { createPackageJsonService } = await import("./package-json.service-QN7SzRTt.js");
+			const { createPackageJsonService } = await import("./package-json.service-d4pVcOFd.js");
 			return createPackageJsonService(fs);
 		}
 	}),
 	git: defineService({ factory: async ({ basePath }) => {
-		const { createGitService } = await import("./git.service-C5zcZ5BB.js");
+		const { createGitService } = await import("./git.service-B3PC7qIe.js");
 		return createGitService(basePath);
-	} })
+	} }),
+	versionBumper: defineService({ factory: async () => {
+		const { createVersionBumperService } = await import("./version-bumper.service-ZBJ2jcLS.js");
+		return createVersionBumperService();
+	} }),
+	versionStrategy: defineService({
+		dependencies: ["versionBumper"],
+		factory: async ({ getService }) => {
+			const versionBumper = await getService("versionBumper");
+			const { createVersionStrategyService } = await import("./version-strategy.service-BdpKRWLc.js");
+			return createVersionStrategyService(versionBumper);
+		}
+	}),
+	commitAnalysis: defineService({
+		dependencies: ["git"],
+		factory: async ({ getService }) => {
+			const git = await getService("git");
+			const { createCommitAnalysisService } = await import("./commit-analysis.service-B8W5aORO.js");
+			return createCommitAnalysisService(git);
+		}
+	})
 };
 /**
 * Array of all service keys for iteration
@@ -1800,7 +2241,7 @@ function logGraphStatistics(stats) {
 
 //#endregion
 //#region src/commands/release/release.command.ts
-const RELEASE_SERVICES = defineServiceKeys("fs", "packageJson", "git");
+const RELEASE_SERVICES = defineServiceKeys("fs", "packageJson", "git", "commitAnalysis", "versionBumper", "versionStrategy");
 const releaseCommand = createCommand({
 	meta: {
 		name: "release",
@@ -2120,6 +2561,30 @@ var ImmutableWorkflowContext = class ImmutableWorkflowContext {
 			services: this.services
 		});
 	}
+	/**
+	* @example Merging hydrated config values
+	* ```typescript
+	* const updatedCtx = ctx.forkConfig({
+	*   repository: "owner/repo",
+	*   branch: "main"
+	* });
+	* ```
+	*/
+	forkConfig(updates) {
+		if (Object.keys(updates).length === 0) return this;
+		const mergedConfig = {
+			...this.config,
+			...updates
+		};
+		const frozenConfig = Object.freeze(mergedConfig);
+		return new ImmutableWorkflowContext({
+			startTime: this.startTime,
+			workspace: this.workspace,
+			config: frozenConfig,
+			data: this.#data,
+			services: this.services
+		});
+	}
 	has(key) {
 		return key in this.#data;
 	}
@@ -2178,7 +2643,11 @@ var WorkflowExecutor = class {
 		const startTime = /* @__PURE__ */ new Date();
 		const executedTaskIds = [];
 		const skippedTaskIds = [];
-		if (this.options.dryRun) logger.warn("Workflow executing in DRY RUN mode - no actual changes will be made");
+		if (this.options.dryRun) logger.warn("Running in DRY-RUN mode: No changes will be made.");
+		const version = RuntimeEnv.version;
+		const dashIndex = version.indexOf("-");
+		if (dashIndex !== -1) if (dashIndex === version.length - 1 || version[dashIndex + 1] === "n") logger.warn(`You are running a DEVELOPMENT build of Firefly (${colors.dim(version)}). This is a 'next' build and may be unstable.`);
+		else logger.warn(`You are running a PRE-RELEASE version of Firefly (${colors.dim(version)}). Unexpected behavior or bugs may occur.`);
 		logger.verbose(`WorkflowExecutor: Starting execution of ${tasks.length} tasks`);
 		return this.executeTasksSequentially(tasks, initialContext, executedTaskIds, skippedTaskIds).andThen(() => this.buildExecutionSuccessResult(startTime, executedTaskIds, skippedTaskIds)).orElse((error) => this.handleExecutionFailure({
 			error,
@@ -2206,6 +2675,8 @@ var WorkflowExecutor = class {
 	handleExecutionFailure(args) {
 		const { error, startTime, executedTaskIds, skippedTaskIds, initialContext } = args;
 		const endTime = /* @__PURE__ */ new Date();
+		if (DebugFlags.showRawError) logger.error(error);
+		else logger.error(error.message);
 		if (this.options.enableRollback && this.executedTasks.length > 0) {
 			logger.verbose(`WorkflowExecutor: Attempting rollback of ${this.executedTasks.length} tasks`);
 			return this.rollback(initialContext).andThen((rollbackSuccess) => {
@@ -2281,9 +2752,6 @@ var WorkflowExecutor = class {
 			executionLists.executedTaskIds.push(currentTask.meta.id);
 			this.executedTasks.push(currentTask);
 			return this.executeTasksSequentially(remainingTasks, updatedContext, executionLists.executedTaskIds, executionLists.skippedTaskIds);
-		}).mapErr((error) => {
-			logger.error(error.message);
-			return error;
 		});
 	}
 	rollback(context) {
@@ -2955,6 +3423,18 @@ async function resolveServiceWithContext(key, context) {
 /**
 * Creates a lazy proxy that defers async service instantiation until first access.
 *
+* IMPORTANT:
+* This proxy always defers instantiation and wraps calls in a ResultAsync chain
+* in order to safely await the real service instance before invoking the method.
+*
+* At runtime the proxy therefore returns ResultAsync even if the concrete service
+* method returns a synchronous Result.
+*
+* Because of this behavior, service interfaces should return FireflyAsyncResult<T>
+* from their public methods to avoid type mismatches and confusion. Implementations
+* that have purely synchronous behavior should return FireflyOkAsync / FireflyErrAsync
+* so they still conform to the async contract expected by the proxy.
+*
 * @template T - The service interface type
 * @param factory - Async function that creates the actual service instance
 * @returns A proxy that behaves like the service but instantiates lazily