Image {move.image_name} already has an active image move job

Error message

Image {move.image_name} already has an active image move job

What it means

An image may participate in only one active (non-terminal) move job at a time. preflight_moves consults _has_active_job_for_image(image_name) and raises ValueError if this image is already listed in another planned/running job, preventing conflicting concurrent moves of the same file.

Source

Thrown at invokeai/app/services/image_moves/image_moves_default.py:445

        destinations: set[Path] = set()
        thumbnail_destinations: set[Path] = set()
        for move in moves:
            if not move.old_path.exists():
                if not move.is_intermediate:
                    raise FileNotFoundError(f"Source image does not exist: {move.old_path}")
                continue
            if move.new_path.exists():
                raise FileExistsError(f"Destination image already exists: {move.new_path}")
            if move.old_path == move.new_path:
                raise ValueError(f"Old and new paths are identical for {move.image_name}")
            if move.new_path in destinations:
                raise ValueError(f"Duplicate destination path: {move.new_path}")
            destinations.add(move.new_path)
            if move.new_thumbnail_path in thumbnail_destinations:
                raise ValueError(f"Duplicate destination thumbnail path: {move.new_thumbnail_path}")
            thumbnail_destinations.add(move.new_thumbnail_path)
            if self._has_active_job_for_image(move.image_name):
                raise ValueError(f"Image {move.image_name} already has an active image move job")
            self._assert_same_filesystem(move.old_path, move.new_path)
            if move.old_thumbnail_path.exists():
                if move.new_thumbnail_path.exists():
                    raise FileExistsError(f"Destination thumbnail already exists: {move.new_thumbnail_path}")
                self._assert_same_filesystem(move.old_thumbnail_path, move.new_thumbnail_path)

    def _record_missing_source_errors(self, moves: Sequence[PlannedImageMove]) -> tuple[list[PlannedImageMove], int]:
        remaining_moves: list[PlannedImageMove] = []
        errors = 0
        for move in moves:
            if move.old_path.exists() or move.is_intermediate:
                remaining_moves.append(move)
                continue
            message = f"Source image does not exist: {move.old_path}"
            self.create_error_move_job(move, message)
            self._logger.error(message)
            errors += 1
        return remaining_moves, errors

View on GitHub (pinned to 0b6a024f2f)

Solutions

Wait for the existing job to reach 'committed' or 'error' before planning again
Run startup_recovery to finalize the stale job, then retry
Remove the image from the active job or mark that job 'error' if its outcome is known

Example fix

// before
service.preflight_moves(moves)
// after
if any(service.has_active_job_for(m.image_name) for m in moves):
    raise RuntimeError("image already in an active move job; wait or run recovery")
service.preflight_moves(moves)

Defensive patterns

Strategy: validation

Validate before calling

busy = [m.image_name for m in moves if service.has_active_job_for_image(m.image_name)]
if busy:
    raise ValueError(f"images already in active jobs: {busy}")
service.preflight_moves(moves)

Type guard

def image_is_free(image_name: str, active_names: set[str]) -> bool:
    return image_name not in active_names

Try / catch

try:
    service.preflight_moves(moves)
except ValueError as e:
    if "already has an active image move job" in str(e):
        wait_for_active_jobs()  # poll until committed/error
        service.preflight_moves(moves)
    else:
        raise

Prevention

Never queue the same image into two overlapping batches
Run startup recovery so crashed jobs don't linger as active
Check per-image active-job status in the UI before allowing re-queue

When it happens

Trigger: Re-adding an image to a new batch while a previous job containing it is still 'planned'/'running'; concurrent API requests both planning a move for the same image; a stale non-terminal job from a crash still listing the image.

Common situations: Users queuing the same image for two boards; retrying a move without waiting for the first job to finish; crashed jobs never finalized via startup recovery.

Related errors

AI-assisted analysis of invoke-ai/InvokeAI@0b6a024f2f (2026-08-29). Data as JSON: /api/errors/e983aa1338759c8e. Report an issue: GitHub.