padrone 1.7.1 → 1.8.1

package/src/core/exec.ts

@@ -6,6 +6,7 @@ import type {
   InterceptorExecuteResult,
   InterceptorParseContext,
   InterceptorParseResult,
+  InterceptorRouteContext,
   InterceptorValidateContext,
   InterceptorValidateResult,
   PadroneActionContext,
@@ -15,7 +16,7 @@ import type {
 } from '../types/index.ts';
 import { getCommandRuntime } from './commands.ts';
 import { RoutingError, SignalError, ValidationError } from './errors.ts';
-import { resolveRegisteredInterceptors, runInterceptorChain, wrapWithLifecycle } from './interceptors.ts';
+import { resolveRegisteredInterceptors, runInterceptorChain, wrapWithCommandLifecycle, wrapWithLifecycle } from './interceptors.ts';
 import { errorResult, noop, thenMaybe, warnIfUnexpectedAsync, withDrain } from './results.ts';
 import { buildCommandArgs, formatIssueMessages, validateCommandArgs } from './validate.ts';
 
@@ -152,6 +153,7 @@ export function execCommand(
   const factoryCache = new Map<RegisteredInterceptor, ResolvedInterceptor>();
   const rootRegistered = rootCommand.interceptors ?? [];
   const rootInterceptors = resolveRegisteredInterceptors(rootRegistered, factoryCache);
+  const rootInterceptorSet = new Set(rootInterceptors);
 
   const runPipeline = (signal: AbortSignal, pipelineContext: unknown) => {
     // ── Phase 1: Parse ──────────────────────────────────────────────────
@@ -159,7 +161,7 @@ export function execCommand(
       input: resolvedInput,
       command: rootCommand,
       signal,
-      context: pipelineContext,
+      context: pipelineContext as object,
       runtime,
       program: ctx.builder,
       caller,
@@ -176,68 +178,107 @@ export function execCommand(
       pipelineState.rawArgs = parsed.rawArgs;
       pipelineState.positionalArgs = parsed.positionalArgs;
       const commandInterceptors = resolveRegisteredInterceptors(collectInterceptorsFn(command), factoryCache);
+      const commandOnlyInterceptors = commandInterceptors.filter((i) => !rootInterceptorSet.has(i));
       const context = resolveContext(command, pipelineContext);
 
-      // ── Phase 2: Validate ───────────────────────────────────────────
-      const validateCtx: InterceptorValidateContext = {
+      // ── Phase 2: Route ──────────────────────────────────────────────
+      const routeCtx: InterceptorRouteContext = {
         ...parseCtx,
         command,
         rawArgs: parsed.rawArgs,
         positionalArgs: parsed.positionalArgs,
-        context,
-        evalInteractive: evalOptions?.interactive,
+        context: context as object,
       };
 
-      const coreValidate = (validateCtx: InterceptorValidateContext): InterceptorValidateResult | Promise<InterceptorValidateResult> => {
-        const preprocessedArgs = buildCommandArgs(validateCtx.command, validateCtx.rawArgs, validateCtx.positionalArgs);
-        const validated = validateCommandArgs(validateCtx.command, preprocessedArgs);
-        return thenMaybe(validated, (v) => v as InterceptorValidateResult);
-      };
-
-      const validatedOrPromise = runInterceptorChain('validate', commandInterceptors, validateCtx, coreValidate);
+      const routedOrPromise = runInterceptorChain('route', commandInterceptors, routeCtx, () => {});
 
-      // ── Phase 3: Execute (or handle validation errors) ──────────────
-      const continueAfterValidate = (v: InterceptorValidateResult) => {
-        pipelineState.args = v.args;
-        if (v.argsResult?.issues) return handleValidationIssues(v.argsResult as StandardSchemaV1.FailureResult, command, errorMode);
-
-        const executeCtx: InterceptorExecuteContext = {
-          ...validateCtx,
-          args: v.args,
-        };
+      const continueAfterRoute = () => {
+        const runValidateAndExecute = () => {
+          // ── Phase 3: Validate ───────────────────────────────────────────
+          const validateCtx: InterceptorValidateContext = {
+            ...parseCtx,
+            command,
+            rawArgs: parsed.rawArgs,
+            positionalArgs: parsed.positionalArgs,
+            context: context as object,
+            evalInteractive: evalOptions?.interactive,
+          };
 
-        const coreExecute = (executeCtx: InterceptorExecuteContext): InterceptorExecuteResult => {
-          const handler = command.action ?? noop;
-          const effectiveRuntime = executeCtx.runtime;
-          const actionCtx: PadroneActionContext = {
-            runtime: effectiveRuntime,
-            command: executeCtx.command,
-            program: ctx.builder as any,
-            signal: executeCtx.signal,
-            context: executeCtx.context,
-            caller,
+          const coreValidate = (
+            validateCtx: InterceptorValidateContext,
+          ): InterceptorValidateResult | Promise<InterceptorValidateResult> => {
+            const { args: preprocessedArgs, issues } = buildCommandArgs(
+              validateCtx.command,
+              validateCtx.rawArgs,
+              validateCtx.positionalArgs,
+            );
+            if (issues) return { args: undefined, argsResult: { issues } as any };
+            const validated = validateCommandArgs(validateCtx.command, preprocessedArgs);
+            return thenMaybe(validated, (v) => v as InterceptorValidateResult);
           };
-          const result = handler(executeCtx.args as any, actionCtx);
-          return { result };
-        };
 
-        const executedOrPromise = runInterceptorChain('execute', commandInterceptors, executeCtx, coreExecute);
+          const validatedOrPromise = runInterceptorChain('validate', commandInterceptors, validateCtx, coreValidate);
+
+          // ── Phase 3: Execute (or handle validation errors) ──────────────
+          const continueAfterValidate = (v: InterceptorValidateResult) => {
+            pipelineState.args = v.args;
+            if (v.argsResult?.issues) return handleValidationIssues(v.argsResult as StandardSchemaV1.FailureResult, command, errorMode);
 
-        return thenMaybe(executedOrPromise, (e) => {
-          const finalize = (result: unknown) =>
-            withDrain({
-              command: command as any,
+            const executeCtx: InterceptorExecuteContext = {
+              ...validateCtx,
               args: v.args,
-              argsResult: v.argsResult,
-              result,
+            };
+
+            const coreExecute = (executeCtx: InterceptorExecuteContext): InterceptorExecuteResult => {
+              const handler = command.action ?? noop;
+              const effectiveRuntime = executeCtx.runtime;
+              const actionCtx: PadroneActionContext = {
+                runtime: effectiveRuntime,
+                command: executeCtx.command,
+                program: ctx.builder as any,
+                signal: executeCtx.signal,
+                context: executeCtx.context,
+                caller,
+              };
+              const result = handler(executeCtx.args as any, actionCtx);
+              return { result };
+            };
+
+            const executedOrPromise = runInterceptorChain('execute', commandInterceptors, executeCtx, coreExecute);
+
+            return thenMaybe(executedOrPromise, (e) => {
+              const finalize = (result: unknown) =>
+                withDrain({
+                  command: command as any,
+                  args: v.args,
+                  argsResult: v.argsResult,
+                  result,
+                });
+
+              if (e.result instanceof Promise) return e.result.then(finalize);
+              return finalize(e.result);
             });
+          };
+
+          return thenMaybe(warnIfUnexpectedAsync(validatedOrPromise, command), continueAfterValidate) as any;
+        };
 
-          if (e.result instanceof Promise) return e.result.then(finalize);
-          return finalize(e.result);
-        });
+        return wrapWithCommandLifecycle(
+          commandOnlyInterceptors,
+          command,
+          resolvedInput,
+          runValidateAndExecute,
+          (result) => withDrain({ command: command as any, args: undefined, argsResult: undefined, result }),
+          signal,
+          context,
+          runtime,
+          ctx.builder,
+          caller,
+          pipelineState,
+        );
       };
 
-      return thenMaybe(warnIfUnexpectedAsync(validatedOrPromise, command), continueAfterValidate) as any;
+      return thenMaybe(routedOrPromise, continueAfterRoute) as any;
     };
 
     return thenMaybe(parsedOrPromise, continueAfterParse) as any;

package/src/core/interceptors.ts

@@ -151,7 +151,7 @@ function deduplicateInterceptors(interceptors: ResolvedInterceptor[]): ResolvedI
  * into the context before passing to the next interceptor or core function.
  */
 export function runInterceptorChain<TCtx extends object, TResult>(
-  phase: 'start' | 'parse' | 'validate' | 'execute' | 'error' | 'shutdown',
+  phase: 'start' | 'parse' | 'route' | 'validate' | 'execute' | 'error' | 'shutdown',
   interceptors: ResolvedInterceptor[],
   ctx: TCtx,
   core: (ctx: TCtx) => TResult | Promise<TResult>,
@@ -173,9 +173,15 @@ export function runInterceptorChain<TCtx extends object, TResult>(
     ) => TResult | Promise<TResult>;
     const prevNext = next;
     next = (currentCtx: TCtx) =>
-      handler(currentCtx, (overrides?: Record<string, unknown>) =>
-        prevNext(overrides ? (Object.assign({}, currentCtx, overrides) as TCtx) : currentCtx),
-      );
+      handler(currentCtx, (overrides?: Record<string, unknown>) => {
+        if (!overrides) return prevNext(currentCtx);
+        // Auto-merge context: `next({ context: { user } })` merges into existing context
+        // instead of replacing it, so interceptors can't accidentally drop context.
+        if (overrides.context != null && typeof overrides.context === 'object') {
+          overrides = { ...overrides, context: Object.assign({}, (currentCtx as Record<string, unknown>).context, overrides.context) };
+        }
+        return prevNext(Object.assign({}, currentCtx, overrides) as TCtx);
+      });
   }
 
   return next(ctx);
@@ -220,7 +226,7 @@ export function wrapWithLifecycle<T>(
       error,
       result,
       signal: effectiveSignal,
-      context: effectiveContext,
+      context: effectiveContext as object,
       runtime: runtime!,
       program: program!,
       caller,
@@ -243,7 +249,7 @@ export function wrapWithLifecycle<T>(
       input,
       error,
       signal: effectiveSignal,
-      context: effectiveContext,
+      context: effectiveContext as object,
       runtime: runtime!,
       program: program!,
       caller,
@@ -272,7 +278,7 @@ export function wrapWithLifecycle<T>(
   const startCtx: InterceptorStartContext = {
     command,
     signal: effectiveSignal,
-    context: effectiveContext,
+    context: effectiveContext as object,
     runtime: runtime!,
     program: program!,
     input,
@@ -300,3 +306,97 @@ export function wrapWithLifecycle<T>(
 
   return handleSuccess(result);
 }
+
+/**
+ * Wraps a command-level pipeline (validate + execute) with error → shutdown lifecycle hooks.
+ * Unlike `wrapWithLifecycle`, this has no `start` phase and uses the resolved command context.
+ * Only interceptors exclusive to the command chain (not in root) should be passed here.
+ */
+export function wrapWithCommandLifecycle<T>(
+  interceptors: ResolvedInterceptor[],
+  command: AnyPadroneCommand,
+  input: string | undefined,
+  pipeline: () => T | Promise<T>,
+  wrapErrorResult: ((result: unknown) => T) | undefined,
+  signal: AbortSignal,
+  context: unknown,
+  runtime: ResolvedPadroneRuntime,
+  program: AnyPadroneProgram,
+  caller: 'cli' | 'eval' | 'run' | 'repl' | 'serve' | 'mcp' | 'tool',
+  pipelineState: { rawArgs?: Record<string, unknown>; positionalArgs?: string[]; args?: unknown },
+): T | Promise<T> {
+  const hasError = interceptors.some((p) => p.error);
+  const hasShutdown = interceptors.some((p) => p.shutdown);
+
+  if (!hasError && !hasShutdown) return pipeline();
+
+  const runShutdown = (error?: unknown, result?: unknown) => {
+    if (!hasShutdown) return;
+    const ctx: InterceptorShutdownContext = {
+      command,
+      input,
+      error,
+      result,
+      signal,
+      context: context as object,
+      runtime,
+      program,
+      caller,
+      ...pipelineState,
+    };
+    return runInterceptorChain('shutdown', interceptors, ctx, () => {});
+  };
+
+  const runError = (error: unknown): T | Promise<T> => {
+    if (!hasError) {
+      const s = runShutdown(error);
+      if (s instanceof Promise)
+        return s.then(() => {
+          throw error;
+        });
+      throw error;
+    }
+    const ctx: InterceptorErrorContext = {
+      command,
+      input,
+      error,
+      signal,
+      context: context as object,
+      runtime,
+      program,
+      caller,
+      ...pipelineState,
+    };
+    const errorResult = runInterceptorChain('error', interceptors, ctx, (): InterceptorErrorResult => ({ error }));
+    return thenMaybe(errorResult, (er) => {
+      if (er.error !== undefined) {
+        const s = runShutdown(er.error);
+        return thenMaybe(s as void | Promise<void>, () => {
+          throw er.error;
+        });
+      }
+      const wrapped = wrapErrorResult ? wrapErrorResult(er.result) : (er.result as T);
+      const s = runShutdown(undefined, wrapped);
+      return thenMaybe(s as void | Promise<void>, () => wrapped);
+    });
+  };
+
+  const handleSuccess = (result: T): T | Promise<T> => {
+    const s = runShutdown(undefined, result);
+    if (s instanceof Promise) return s.then(() => result);
+    return result;
+  };
+
+  let result: T | Promise<T>;
+  try {
+    result = pipeline();
+  } catch (e) {
+    return runError(e);
+  }
+
+  if (result instanceof Promise) {
+    return result.then(handleSuccess, runError);
+  }
+
+  return handleSuccess(result);
+}

package/src/core/program-methods.ts

@@ -11,7 +11,7 @@ import type {
   PadroneAPI,
   PadroneReplPreferences,
 } from '../types/index.ts';
-import { parsePositionalConfig } from './args.ts';
+import { extractSchemaMetadata, parsePositionalConfig } from './args.ts';
 import { findCommandByName, getCommandRuntime, resolveAllCommands } from './commands.ts';
 import { RoutingError } from './errors.ts';
 import type { ExecContext } from './exec.ts';
@@ -37,6 +37,15 @@ export function createProgramMethods(ctx: ExecContext, evalCommand: AnyPadronePr
     const positionalConfig = commandObj.meta?.positional ? parsePositionalConfig(commandObj.meta.positional) : [];
     const positionalNames = new Set(positionalConfig.map((p) => p.name));
 
+    // Build reverse map: arg name → first negative keyword (for stringify)
+    const negativeKeyword: Record<string, string> = {};
+    if (commandObj.argsSchema) {
+      const { negatives } = extractSchemaMetadata(commandObj.argsSchema, commandObj.meta?.fields, commandObj.meta?.autoAlias);
+      for (const [keyword, argName] of Object.entries(negatives)) {
+        if (!(argName in negativeKeyword)) negativeKeyword[argName] = keyword;
+      }
+    }
+
     if (args && typeof args === 'object') {
       for (const { name, variadic } of positionalConfig) {
         const value = (args as Record<string, unknown>)[name];
@@ -60,6 +69,7 @@ export function createProgramMethods(ctx: ExecContext, evalCommand: AnyPadronePr
 
         if (typeof value === 'boolean') {
           if (value) parts.push(`--${key}`);
+          else if (negativeKeyword[key]) parts.push(`--${negativeKeyword[key]}`);
           else parts.push(`--no-${key}`);
         } else if (Array.isArray(value)) {
           for (const v of value) {
@@ -117,7 +127,7 @@ export function createProgramMethods(ctx: ExecContext, evalCommand: AnyPadronePr
         positionalArgs: [],
         args,
         signal: inertSignal,
-        context: resolvedCtx,
+        context: resolvedCtx as object,
         runtime: commandRuntime,
         program: ctx.builder as any,
         caller: 'run',

package/src/core/validate.ts

@@ -51,8 +51,8 @@ export function parseCommand(input: string | undefined, rootCommand: AnyPadroneC
   const argsMeta = curCommand.meta?.fields;
   const schemaMetadata = curCommand.argsSchema
     ? extractSchemaMetadata(curCommand.argsSchema, argsMeta, curCommand.meta?.autoAlias)
-    : { flags: {}, aliases: {} };
-  const { flags, aliases } = schemaMetadata;
+    : { flags: {}, aliases: {}, negatives: {}, customNegation: new Set<string>() };
+  const { flags, aliases, negatives, customNegation } = schemaMetadata;
 
   const arrayArguments = new Set<string>();
   if (curCommand.argsSchema) {
@@ -77,6 +77,10 @@ export function parseCommand(input: string | undefined, rootCommand: AnyPadroneC
       key = [flags[arg.key[0]!]!];
     } else if (arg.type === 'named' && arg.key.length === 1 && aliases[arg.key[0]!]) {
       key = [aliases[arg.key[0]!]!];
+    } else if (arg.type === 'named' && arg.key.length === 1 && negatives[arg.key[0]!]) {
+      // Negative keyword: --remote sets local to false
+      setNestedValue(rawArgs, [negatives[arg.key[0]!]!], false);
+      continue;
     } else {
       key = arg.key;
     }
@@ -84,6 +88,12 @@ export function parseCommand(input: string | undefined, rootCommand: AnyPadroneC
     const rootKey = key[0]!;
 
     if (arg.type === 'named' && arg.negated) {
+      // Skip --no- prefix negation for args with custom negation
+      if (customNegation.has(rootKey)) {
+        // Treat as unknown: put it back as `no-<key>` so detectUnknownArgs catches it
+        setNestedValue(rawArgs, [`no-${key.join('.')}`], false);
+        continue;
+      }
       setNestedValue(rawArgs, key, false);
       continue;
     }
@@ -132,8 +142,9 @@ export function buildCommandArgs(
   command: AnyPadroneCommand,
   rawArgs: Record<string, unknown>,
   positionalArgs: string[],
-): Record<string, unknown> {
+): { args: Record<string, unknown>; issues?: StandardSchemaV1.Issue[] } {
   let preprocessedArgs = preprocessArgs(rawArgs, { flags: {}, aliases: {} });
+  let issues: StandardSchemaV1.Issue[] | undefined;
 
   const positionalConfig = command.meta?.positional ? parsePositionalConfig(command.meta.positional) : [];
 
@@ -143,6 +154,13 @@ export function buildCommandArgs(
       const { name, variadic } = positionalConfig[i]!;
       if (argIndex >= positionalArgs.length) break;
 
+      // Detect ambiguity: same arg provided both positionally and as a named option
+      if (name in preprocessedArgs) {
+        issues ??= [];
+        issues.push({ path: [name], message: `Ambiguous argument "${name}": provided both positionally and as a named option` });
+        continue;
+      }
+
       if (variadic) {
         const remainingPositionals = positionalConfig.slice(i + 1);
         const nonVariadicAfter = remainingPositionals.filter((p) => !p.variadic).length;
@@ -163,7 +181,7 @@ export function buildCommandArgs(
     preprocessedArgs = coerceArgs(preprocessedArgs, command.argsSchema);
   }
 
-  return preprocessedArgs;
+  return { args: preprocessedArgs, issues };
 }
 
 /**
@@ -180,9 +198,9 @@ export function checkUnknownArgs(command: AnyPadroneCommand, preprocessedArgs: R
   }
 
   const argsMeta = command.meta?.fields;
-  const { flags, aliases } = extractSchemaMetadata(command.argsSchema, argsMeta, command.meta?.autoAlias);
+  const { flags, aliases, negatives } = extractSchemaMetadata(command.argsSchema, argsMeta, command.meta?.autoAlias);
 
-  return detectUnknownArgs(preprocessedArgs, command.argsSchema, flags, aliases);
+  return detectUnknownArgs(preprocessedArgs, command.argsSchema, flags, aliases, negatives);
 }
 
 /**
@@ -241,7 +259,8 @@ export function coreValidateForParse(
   rawArgs: Record<string, unknown>,
   positionalArgs: string[],
 ): InterceptorValidateResult | Promise<InterceptorValidateResult> {
-  const preprocessedArgs = buildCommandArgs(command, rawArgs, positionalArgs);
+  const { args: preprocessedArgs, issues } = buildCommandArgs(command, rawArgs, positionalArgs);
+  if (issues) return { args: undefined, argsResult: { issues } as any };
   const validated = validateCommandArgs(command, preprocessedArgs);
   return thenMaybe(validated, (v) => v as InterceptorValidateResult);
 }

package/src/extension/auto-output.ts

@@ -88,7 +88,7 @@ function createAutoOutputInterceptor(outputConfig?: OutputConfig) {
         return { result: collected };
       };
 
-      const executedOrPromise = next({ context: { ...(ctx.context as any), output: indicator } });
+      const executedOrPromise = next({ context: { output: indicator } });
       if (executedOrPromise instanceof Promise) return executedOrPromise.then(handleResult);
       return handleResult(executedOrPromise);
     },

package/src/extension/config.ts

@@ -4,6 +4,7 @@ import { ConfigError } from '../core/errors.ts';
 import { defineInterceptor } from '../core/interceptors.ts';
 import { thenMaybe } from '../core/results.ts';
 import type { AnyPadroneBuilder, CommandTypesBase, InterceptorValidateContext } from '../types/index.ts';
+import type { WithAsync } from '../util/type-utils.ts';
 import { getRootCommand } from '../util/utils.ts';
 
 // ── Types ────────────────────────────────────────────────────────────────
@@ -189,7 +190,7 @@ function loadConfig(
  *   }))
  * ```
  */
-export function padroneConfig(options?: PadroneConfigOptions): <T extends CommandTypesBase>(builder: T) => T {
+export function padroneConfig(options?: PadroneConfigOptions): <T extends CommandTypesBase>(builder: T) => WithAsync<T> {
   if (options?.disabled) {
     const disabled = defineInterceptor({ id: 'padrone:config', name: 'padrone:config', order: -999, disabled: true }, () => ({}));
     return ((builder: AnyPadroneBuilder) => builder.intercept(disabled)) as any;

package/src/extension/env.ts

@@ -5,6 +5,7 @@ import { thenMaybe } from '../core/results.ts';
 import type { AnyPadroneBuilder, CommandTypesBase, InterceptorValidateContext } from '../types/index.ts';
 import type { LoadEnvFilesOptions } from '../util/dotenv.ts';
 import { loadEnvFiles } from '../util/dotenv.ts';
+import type { WithAsync } from '../util/type-utils.ts';
 
 // ── Types ────────────────────────────────────────────────────────────────
 
@@ -53,13 +54,13 @@ function isSchema(value: unknown): value is StandardSchemaV1 {
  *
  * Env values have lower precedence than CLI args and stdin, but higher than config files.
  */
-export function padroneEnv(schema: StandardSchemaV1): <T extends CommandTypesBase>(builder: T) => T;
-export function padroneEnv(schema: StandardSchemaV1, options: PadroneEnvOptions): <T extends CommandTypesBase>(builder: T) => T;
-export function padroneEnv(options: PadroneEnvOptions): <T extends CommandTypesBase>(builder: T) => T;
+export function padroneEnv(schema: StandardSchemaV1): <T extends CommandTypesBase>(builder: T) => WithAsync<T>;
+export function padroneEnv(schema: StandardSchemaV1, options: PadroneEnvOptions): <T extends CommandTypesBase>(builder: T) => WithAsync<T>;
+export function padroneEnv(options: PadroneEnvOptions): <T extends CommandTypesBase>(builder: T) => WithAsync<T>;
 export function padroneEnv(
   schemaOrOptions: StandardSchemaV1 | PadroneEnvOptions,
   maybeOptions?: PadroneEnvOptions,
-): <T extends CommandTypesBase>(builder: T) => T {
+): <T extends CommandTypesBase>(builder: T) => WithAsync<T> {
   const schema = isSchema(schemaOrOptions) ? schemaOrOptions : undefined;
   const options = isSchema(schemaOrOptions) ? maybeOptions : schemaOrOptions;
   const hasFiles = options?.modes !== undefined;

package/src/extension/index.ts

@@ -1,3 +1,4 @@
+export type { WithAsync } from '../util/type-utils.ts';
 export type { PadroneAutoOutputOptions } from './auto-output.ts';
 export { padroneAutoOutput } from './auto-output.ts';
 export { padroneColor } from './color.ts';

package/src/extension/interactive.ts

@@ -37,7 +37,8 @@ const interactiveInterceptor = defineInterceptor({ id: 'padrone:interactive', na
     if (!willPrompt) return next();
 
     // Preprocess args to determine what's missing
-    const preprocessedArgs = buildCommandArgs(command, ctx.rawArgs, ctx.positionalArgs);
+    const { args: preprocessedArgs, issues: positionalIssues } = buildCommandArgs(command, ctx.rawArgs, ctx.positionalArgs);
+    if (positionalIssues) return { args: undefined, argsResult: { issues: positionalIssues } } as any;
 
     // Check for unknown args before prompting
     const unknowns = checkUnknownArgs(command, preprocessedArgs);

package/src/extension/logger.ts

@@ -209,7 +209,7 @@ function loggerInterceptor(rawConfig?: PadroneLoggerConfig) {
             timestamps: rawConfig?.timestamps ?? ctxCfg?.timestamps ?? false,
           };
           const logger = createLogger(ctx.runtime, resolved.level, resolved, ctx.context?.tracing);
-          return next({ context: { ...ctx.context, logger } });
+          return next({ context: { logger } });
         },
       };
     });

package/src/extension/progress-renderer.ts

@@ -265,6 +265,9 @@ export function createTerminalProgress(message: string, options?: PadroneProgres
       }, tickInterval)
     : undefined;
 
+  // Prevent the spinner timer from keeping the process alive on uncaught errors
+  if (timer && typeof timer === 'object' && 'unref' in timer) (timer as NodeJS.Timeout).unref();
+
   render();
 
   const clear = () => {

package/src/extension/progress.ts

@@ -198,10 +198,35 @@ function progressInterceptor(config: string | PadroneProgressConfig) {
             ctx.runtime.error = originalError;
           };
 
-          return next();
+          const onValidationFailure = (error: unknown) => {
+            if (indicator) {
+              cleanup(indicator, msgs!.success, msgs!.error, error, undefined, true);
+              teardown();
+            }
+          };
+
+          const checkResult = (result: any) => {
+            if (result.argsResult?.issues) onValidationFailure(new Error('Validation failed'));
+            return result;
+          };
+
+          let result: any;
+          try {
+            result = next();
+          } catch (err) {
+            onValidationFailure(err);
+            throw err;
+          }
+          if (result instanceof Promise) {
+            return result.then(checkResult, (err: unknown) => {
+              onValidationFailure(err);
+              throw err;
+            });
+          }
+          return checkResult(result);
         },
 
-        execute(ctx, next) {
+        execute(_ctx, next) {
           // Transition from validation message to progress message
           if (indicator && msgs!.validation) indicator.update(msgs!.progress);
 
@@ -221,7 +246,7 @@ function progressInterceptor(config: string | PadroneProgressConfig) {
 
           let result: any;
           try {
-            result = next({ context: { ...(ctx.context as any), progress: effectiveIndicator } });
+            result = next({ context: { progress: effectiveIndicator } });
           } catch (err) {
             onError(err);
           }
@@ -259,6 +284,15 @@ function progressInterceptor(config: string | PadroneProgressConfig) {
           onSuccess(result!.result);
           return result;
         },
+
+        shutdown(ctx) {
+          // Safety net: if validate/execute cleanup paths were bypassed (e.g., outer interceptor
+          // threw during execute before reaching this interceptor's execute handler), stop the indicator.
+          if (indicator) {
+            cleanup(indicator, msgs!.success, msgs!.error, ctx.error, ctx.result, !!ctx.error);
+            teardown();
+          }
+        },
       };
     })
     .provides<{ progress: PadroneProgressIndicator }>();

package/src/extension/tracing.ts

@@ -109,7 +109,7 @@ function tracingInterceptor(config: ResolvedTracingConfig) {
           },
         };
 
-        return next({ context: { ...(ctx.context as any), tracing: padroneTracer } });
+        return next({ context: { tracing: padroneTracer } });
       },
 
       error(ctx, next) {