Windows Scheduled task succeeds but returns result 0x1

Troubleshooting Windows Scheduled Tasks: Success with Exit Code 0x1

Explore common causes and solutions when a Windows Scheduled Task reports 'succeeded' but returns a mysterious 0x1 exit code, indicating a potential issue despite apparent success.

Windows Task Scheduler is a powerful tool for automating administrative tasks, scripts, and applications. When a scheduled task executes, it provides a 'Last Run Result' which is crucial for determining if the task completed successfully. Typically, a result of 0x0 indicates successful completion without errors. However, you might encounter a peculiar situation where a task reports 'succeeded' but its 'Last Run Result' is 0x1. This can be confusing, as 0x1 often implies a non-zero exit code, usually indicating a warning or minor error, even if the primary function of the task appeared to complete.

Understanding Exit Code 0x1

The 0x1 exit code, or decimal 1, is a generic error code. Unlike specific error codes that pinpoint an exact problem, 0x1 is often used by applications or scripts to signal a non-fatal error, a warning, or simply that the program terminated, but not with a perfect 0 (success). In the context of Windows Scheduled Tasks, this can stem from various sources:

• Script/Application Logic: The most common reason is that the script or application being run explicitly returns 1 under certain conditions, even if its main objective was achieved. For example, a script might return 1 if it processed some files but found no new files to process, or if it encountered a minor discrepancy that didn't prevent its overall goal.
• Command Interpreter (cmd.exe/PowerShell): When you run a command via cmd.exe or powershell.exe, these interpreters themselves can return 1 if the command they tried to execute had a non-zero exit code, or if there was an issue with the command's syntax or execution environment.
• Missing or Incorrect Paths: If the executable or script specified in the task's 'Program/script' field cannot be found, or if its working directory is incorrect, the task scheduler might report 0x1.

Common Scenarios and Diagnostics

Identifying the exact cause requires careful investigation. Here are some common scenarios and diagnostic steps:

Scenario 1: Batch Files (.bat, .cmd)

Batch files often implicitly return the exit code of the last command executed. If the last command in your batch file returns 1, the scheduled task will reflect that.

@echo off
echo This is a test batch file.
rem Simulating a command that might return 1
exit /b 1

A batch file explicitly returning exit code 1.

To force a 0 exit code, you can add exit /b 0 as the very last line of your batch file, assuming all preceding operations were successful.

Scenario 2: PowerShell Scripts (.ps1)

PowerShell scripts can also return specific exit codes. If your script uses exit 1 or if an unhandled error occurs that PowerShell translates into a non-zero exit, you'll see 0x1.

Write-Host "Starting PowerShell script..."
# Simulate a condition that might lead to a non-zero exit
if ((Get-Date).DayOfWeek -eq "Sunday") {
    Write-Warning "It's Sunday! Exiting with warning code."
    exit 1
}
Write-Host "Script completed successfully."
exit 0

A PowerShell script returning exit code 1 under a specific condition.

When running PowerShell scripts via Task Scheduler, ensure you use the correct invocation. It's often best to call powershell.exe directly and pass your script as an argument.

Program/script: powershell.exe
Add arguments (optional): -ExecutionPolicy Bypass -File "C:\Scripts\MyScript.ps1"

Correct Task Scheduler action for a PowerShell script.

Scenario 3: External Executables

If your task runs an executable (.exe), the application itself is responsible for its exit code. Consult the application's documentation or contact its vendor to understand what 1 signifies for that specific program.

Troubleshooting flow for Task Scheduler exit code 0x1.

Practical Steps to Diagnose and Resolve

Follow these steps to narrow down the cause and implement a solution.

1. Step 1

Run the command/script manually: Open cmd.exe or PowerShell as the user configured for the scheduled task (or as Administrator if the task runs with highest privileges). Execute the exact command string used in the Task Scheduler action. Observe the output and note the exit code by typing echo %errorlevel% (for cmd) or $LASTEXITCODE (for PowerShell) immediately after the command finishes.

2. Step 2

Redirect output to a log file: Modify the task's action to redirect standard output and error to a file. This can capture messages that might explain the non-zero exit code. For example: cmd /c "C:\Scripts\MyBatch.bat > C:\Logs\MyBatch.log 2>&1" or powershell.exe -ExecutionPolicy Bypass -File "C:\Scripts\MyScript.ps1" > C:\Logs\MyScript.log 2>&1.

3. Step 3

Check Windows Event Logs: Always review the 'Application' and 'System' logs in Event Viewer for any errors or warnings around the time the task ran. Also, check the 'Microsoft-Windows-TaskScheduler/Operational' log for detailed task execution information.

4. Step 4

Verify Task Configuration: Double-check the 'Program/script' path, 'Add arguments (optional)', and 'Start in (optional)' fields in the task's 'Actions' tab. Incorrect paths or missing working directories are common culprits.

5. Step 5

Simplify the script/command: Temporarily reduce your script or command to its absolute simplest form (e.g., just echo Hello in a batch file, or Write-Host 'Hello' in PowerShell) and run it via the task scheduler. If this simplified version returns 0x0, the issue lies within your script's logic. Gradually add back functionality to pinpoint the problematic section.

6. Step 6

Explicitly return 0: If the 0x1 is acceptable (e.g., it indicates a minor warning you want to ignore), but you want the Task Scheduler to report 0x0, modify your script to explicitly return 0 at its successful conclusion. For batch files, use exit /b 0. For PowerShell, use exit 0.