wp-studio 1.7.9 → 1.7.10

package/dist/cli/plugin/skills/taxonomist/scripts/apply-changes.php

@@ -0,0 +1,223 @@
+<?php
+/**
+ * Apply category changes from an AI-generated suggestions file.
+ *
+ * Reads a JSON file of per-post category suggestions and applies them.
+ * Categories are resolved by slug to prevent drift between the
+ * export/analysis and apply phases.
+ *
+ * Usage:
+ *   TAXONOMIST_SUGGESTIONS=/path/to/suggestions.json studio wp eval-file apply-changes.php
+ *
+ * Environment variables:
+ *   TAXONOMIST_SUGGESTIONS  Path to the suggestions JSON file. Required.
+ *                           Format: [{"post_id": 123, "cats": ["wordpress", "ai"]}, ...]
+ *                           Values in "cats" are category slugs.
+ *   TAXONOMIST_LOG          Path for the change log TSV.
+ *                           Default: /tmp/taxonomist-changes.tsv
+ *   TAXONOMIST_MODE         "preview" (default) shows what would change.
+ *                           "apply" executes the changes.
+ *   TAXONOMIST_REMOVE_CATS  Comma-separated category slugs to strip from
+ *                           posts that receive new suggestions.
+ *
+ * @package Taxonomist
+ */
+
+$suggestions_file = getenv( 'TAXONOMIST_SUGGESTIONS' );
+$log_file         = getenv( 'TAXONOMIST_LOG' ) ? getenv( 'TAXONOMIST_LOG' ) : '/tmp/taxonomist-changes.tsv';
+$apply_mode       = getenv( 'TAXONOMIST_MODE' ) ? getenv( 'TAXONOMIST_MODE' ) : 'preview';
+$remove_cats_str  = getenv( 'TAXONOMIST_REMOVE_CATS' ) ? getenv( 'TAXONOMIST_REMOVE_CATS' ) : '';
+
+if ( ! $suggestions_file || ! file_exists( $suggestions_file ) ) {
+	WP_CLI::error( 'Set TAXONOMIST_SUGGESTIONS to the suggestions JSON path' );
+}
+
+$suggestions_json = file_get_contents( $suggestions_file ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents
+if ( false === $suggestions_json ) {
+	WP_CLI::error( 'Failed to read suggestions file' );
+}
+$suggestions = json_decode( $suggestions_json, true );
+if ( null === $suggestions && JSON_ERROR_NONE !== json_last_error() ) {
+	WP_CLI::error( 'Failed to parse suggestions file' );
+}
+if ( ! is_array( $suggestions ) ) {
+	WP_CLI::error( 'Suggestions file must decode to a JSON array' );
+}
+
+$all_cats     = get_terms(
+	array(
+		'taxonomy'   => 'category',
+		'hide_empty' => false,
+	)
+);
+$slug_to_id   = array();
+$slug_to_name = array();
+foreach ( $all_cats as $t ) {
+	$slug_to_id[ $t->slug ]   = $t->term_id;
+	$slug_to_name[ $t->slug ] = $t->name;
+}
+
+$remove_slugs = array_filter( array_map( 'trim', explode( ',', $remove_cats_str ) ) );
+$remove_ids   = array();
+foreach ( $remove_slugs as $slug ) {
+	if ( isset( $slug_to_id[ $slug ] ) ) {
+		$remove_ids[] = $slug_to_id[ $slug ];
+	}
+}
+
+$default_cat_id = (int) get_option( 'default_category' );
+if ( in_array( $default_cat_id, $remove_ids, true ) ) {
+	$default_term = get_term( $default_cat_id, 'category' );
+	$default_name = $default_term ? $default_term->name : "ID $default_cat_id";
+	WP_CLI::error(
+		"TAXONOMIST_REMOVE_CATS includes '$default_name' which is the site's default category. " .
+		'Change the default category setting first (wp option update default_category NEW_ID), then retry.'
+	);
+}
+
+$unresolved = array();
+foreach ( $suggestions as $suggestion ) {
+	$suggested_refs = isset( $suggestion['cats'] ) ? $suggestion['cats'] : array();
+	foreach ( $suggested_refs as $ref ) {
+		if ( ! isset( $slug_to_id[ $ref ] ) ) {
+			$unresolved[ $ref ] = true;
+		}
+	}
+}
+if ( ! empty( $unresolved ) ) {
+	$list = implode( ', ', array_keys( $unresolved ) );
+	WP_CLI::error(
+		"Taxonomy drift detected: these categories from the suggestions do not exist in the live site: $list. " .
+		'Re-export and re-analyze, or create the missing categories first.'
+	);
+}
+
+// phpcs:disable WordPress.WP.AlternativeFunctions.file_system_operations_fopen
+// phpcs:disable WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+$log = fopen( $log_file, 'w' );
+if ( false === $log ) {
+	WP_CLI::error( 'Failed to open log file for writing: ' . $log_file );
+}
+$header_written = fputcsv( $log, array( 'timestamp', 'action', 'post_id', 'post_title', 'old_categories', 'new_categories', 'cats_added', 'cats_removed' ), "\t" );
+if ( false === $header_written ) {
+	fclose( $log );
+	WP_CLI::error( 'Failed to write log header to ' . $log_file );
+}
+
+$changes     = 0;
+$skipped     = 0;
+$error_count = 0;
+
+foreach ( $suggestions as $suggestion ) {
+	$current_post_id = isset( $suggestion['post_id'] ) ? $suggestion['post_id'] : $suggestion['id'];
+	$suggested_refs  = isset( $suggestion['cats'] ) ? $suggestion['cats'] : array();
+
+	if ( empty( $suggested_refs ) ) {
+		++$skipped;
+		continue;
+	}
+
+	$current_post = get_post( $current_post_id );
+	if ( ! $current_post ) {
+		++$error_count;
+		continue;
+	}
+
+	$current_ids   = wp_get_post_categories( $current_post_id );
+	$current_names = array();
+	foreach ( $current_ids as $cid ) {
+		$t = get_term( $cid, 'category' );
+		if ( $t && ! is_wp_error( $t ) ) {
+			$current_names[ $cid ] = $t->name;
+		}
+	}
+
+	$kept_ids = array();
+	foreach ( $current_ids as $cid ) {
+		if ( ! in_array( $cid, $remove_ids, true ) ) {
+			$kept_ids[] = $cid;
+		}
+	}
+
+	$suggested_ids = array();
+	foreach ( $suggested_refs as $ref ) {
+		if ( isset( $slug_to_id[ $ref ] ) ) {
+			$suggested_ids[] = $slug_to_id[ $ref ];
+		}
+	}
+
+	$new_ids = array_values( array_unique( array_merge( array_values( $kept_ids ), $suggested_ids ) ) );
+
+	$sorted_current = $current_ids;
+	$sorted_new     = $new_ids;
+	sort( $sorted_current );
+	sort( $sorted_new );
+	if ( $sorted_current === $sorted_new ) {
+		++$skipped;
+		continue;
+	}
+
+	$added_ids   = array_diff( $new_ids, $current_ids );
+	$removed_ids = array_diff( $current_ids, $new_ids );
+
+	$added_names = array();
+	foreach ( $added_ids as $aid ) {
+		$t = get_term( $aid, 'category' );
+		if ( $t ) {
+			$added_names[] = $t->name;
+		}
+	}
+
+	$removed_names = array();
+	foreach ( $removed_ids as $rid ) {
+		$removed_names[] = isset( $current_names[ $rid ] ) ? $current_names[ $rid ] : '?';
+	}
+
+	$new_names = array();
+	foreach ( $new_ids as $nid ) {
+		$t = get_term( $nid, 'category' );
+		if ( $t ) {
+			$new_names[] = $t->name;
+		}
+	}
+
+	$ts      = gmdate( 'Y-m-d H:i:s' );
+	$log_row = array(
+		$ts,
+		'SET_CATS',
+		$current_post_id,
+		$current_post->post_title,
+		implode( '|', array_values( $current_names ) ),
+		implode( '|', $new_names ),
+		implode( '|', $added_names ),
+		implode( '|', $removed_names ),
+	);
+
+	if ( 'apply' === $apply_mode ) {
+		$set_result = wp_set_post_categories( $current_post_id, $new_ids );
+		if ( is_wp_error( $set_result ) || false === $set_result ) {
+			++$error_count;
+			WP_CLI::warning( 'Failed to set categories for post ID ' . $current_post_id );
+			continue;
+		}
+	}
+
+	$log_result = fputcsv( $log, $log_row, "\t" );
+	if ( false === $log_result ) {
+		fclose( $log );
+		WP_CLI::error( 'Failed to write change log row for post ID ' . $current_post_id );
+	}
+
+	++$changes;
+	if ( 0 === $changes % 200 ) {
+		WP_CLI::log( "Processed $changes changes..." );
+		wp_cache_flush();
+	}
+}
+
+fclose( $log );
+// phpcs:enable
+
+$verb = ( 'apply' === $apply_mode ) ? 'Applied' : 'Would apply';
+WP_CLI::success( "$verb $changes changes. Skipped: $skipped. Errors: $error_count." );
+WP_CLI::log( 'Log: ' . $log_file );

package/dist/cli/plugin/skills/taxonomist/scripts/backup.php

@@ -0,0 +1,112 @@
+<?php
+/**
+ * Create a complete backup of the current taxonomy state.
+ *
+ * Captures every category term with its metadata and the exact category
+ * assignments for every published post. Together these allow a full restore
+ * to the pre-change state.
+ *
+ * Usage:
+ *   studio wp eval-file backup.php
+ *
+ * Environment variables:
+ *   TAXONOMIST_OUTPUT  Path for the backup JSON file.
+ *                      Default: /tmp/taxonomist-backup.json
+ *
+ * @package Taxonomist
+ */
+
+$output_file = getenv( 'TAXONOMIST_OUTPUT' ) ? getenv( 'TAXONOMIST_OUTPUT' ) : '/tmp/taxonomist-backup.json';
+
+$terms     = get_terms(
+	array(
+		'taxonomy'   => 'category',
+		'hide_empty' => false,
+	)
+);
+$term_data = array();
+foreach ( $terms as $t ) {
+	$term_data[] = array(
+		'term_id'     => $t->term_id,
+		'name'        => $t->name,
+		'slug'        => $t->slug,
+		'description' => $t->description,
+		'count'       => $t->count,
+		'parent'      => $t->parent,
+	);
+}
+
+$post_cats  = array();
+$batch_size = 200;
+$last_id    = 0;
+
+while ( true ) {
+	$query_args = array(
+		'posts_per_page'   => $batch_size,
+		'post_status'      => 'publish',
+		'post_type'        => 'post',
+		'orderby'          => 'ID',
+		'order'            => 'ASC',
+		'suppress_filters' => false,
+	);
+
+	if ( $last_id > 0 ) {
+		add_filter(
+			'posts_where',
+			$keyset_filter = function ( $where ) use ( $last_id ) {
+				global $wpdb;
+				return $where . $wpdb->prepare( " AND {$wpdb->posts}.ID > %d", $last_id );
+			}
+		);
+	}
+
+	$all_posts = get_posts( $query_args );
+
+	if ( isset( $keyset_filter ) ) {
+		remove_filter( 'posts_where', $keyset_filter );
+		unset( $keyset_filter );
+	}
+
+	if ( empty( $all_posts ) ) {
+		break;
+	}
+
+	foreach ( $all_posts as $p ) {
+		$cat_ids   = wp_get_post_categories( $p->ID );
+		$cat_slugs = wp_get_post_categories( $p->ID, array( 'fields' => 'slugs' ) );
+
+		$post_cats[] = array(
+			'post_id'        => $p->ID,
+			'post_title'     => $p->post_title,
+			'category_ids'   => $cat_ids,
+			'category_slugs' => array_values( $cat_slugs ),
+		);
+	}
+
+	$last_id = $all_posts[ count( $all_posts ) - 1 ]->ID;
+	wp_cache_flush();
+}
+
+$default_cat_id   = (int) get_option( 'default_category' );
+$default_cat_term = get_term( $default_cat_id, 'category' );
+$default_cat_slug = $default_cat_term ? $default_cat_term->slug : '';
+
+$backup = array(
+	'timestamp'             => gmdate( 'Y-m-d H:i:s' ),
+	'site_url'              => get_site_url(),
+	'total_posts'           => count( $post_cats ),
+	'total_categories'      => count( $term_data ),
+	'default_category_slug' => $default_cat_slug,
+	'categories'            => $term_data,
+	'post_categories'       => $post_cats,
+);
+
+$backup_json = wp_json_encode( $backup, JSON_PRETTY_PRINT );
+if ( false === $backup_json ) {
+	WP_CLI::error( 'Failed to JSON-encode backup payload' );
+}
+$bytes_written = file_put_contents( $output_file, $backup_json ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_file_put_contents
+if ( false === $bytes_written ) {
+	WP_CLI::error( 'Failed to write backup file: ' . $output_file );
+}
+WP_CLI::success( 'Backup saved to ' . $output_file . ' (' . count( $post_cats ) . ' posts, ' . count( $term_data ) . ' categories)' );

package/dist/cli/plugin/skills/taxonomist/scripts/export-posts.php

@@ -0,0 +1,119 @@
+<?php
+/**
+ * Export all published posts with full content and categories to JSON.
+ *
+ * Streams posts one-by-one to avoid memory issues on large sites.
+ * Output is a JSON array where each element contains the post ID, title,
+ * publication date, full text content (HTML stripped), assigned category
+ * names, and permalink URL.
+ *
+ * Usage:
+ *   studio wp eval-file export-posts.php
+ *
+ * Environment variables:
+ *   TAXONOMIST_OUTPUT  Path for the output JSON file.
+ *                      Default: /tmp/taxonomist-export.json
+ *
+ * @package Taxonomist
+ */
+
+$output_file = getenv( 'TAXONOMIST_OUTPUT' ) ? getenv( 'TAXONOMIST_OUTPUT' ) : '/tmp/taxonomist-export.json';
+
+// phpcs:disable WordPress.WP.AlternativeFunctions.file_system_operations_fopen
+// phpcs:disable WordPress.WP.AlternativeFunctions.file_system_operations_fwrite
+// phpcs:disable WordPress.WP.AlternativeFunctions.file_system_operations_fclose
+$fp = fopen( $output_file, 'w' );
+if ( false === $fp ) {
+	WP_CLI::error( 'Failed to open export file for writing: ' . $output_file );
+}
+$write_or_error = static function ( $file_pointer, $contents, $context ) {
+	if ( false === fwrite( $file_pointer, $contents ) ) {
+		WP_CLI::error( 'Failed to write ' . $context );
+	}
+};
+$write_or_error( $fp, "[\n", 'opening JSON array to ' . $output_file );
+
+$batch_size     = 100;
+$last_id        = 0;
+$total_exported = 0;
+$first          = true;
+
+while ( true ) {
+	$query_args = array(
+		'posts_per_page'   => $batch_size,
+		'post_status'      => 'publish',
+		'post_type'        => 'post',
+		'orderby'          => 'ID',
+		'order'            => 'ASC',
+		'suppress_filters' => false,
+	);
+
+	if ( $last_id > 0 ) {
+		add_filter(
+			'posts_where',
+			$keyset_filter = function ( $where ) use ( $last_id ) {
+				global $wpdb;
+				return $where . $wpdb->prepare( " AND {$wpdb->posts}.ID > %d", $last_id );
+			}
+		);
+	}
+
+	$all_posts = get_posts( $query_args );
+
+	if ( isset( $keyset_filter ) ) {
+		remove_filter( 'posts_where', $keyset_filter );
+		unset( $keyset_filter );
+	}
+
+	if ( empty( $all_posts ) ) {
+		break;
+	}
+
+	foreach ( $all_posts as $p ) {
+		if ( ! $first ) {
+			$write_or_error( $fp, ",\n", 'JSON separator to ' . $output_file );
+		}
+		$first = false;
+
+		$cat_names = wp_get_post_categories( $p->ID, array( 'fields' => 'names' ) );
+		$cat_slugs = wp_get_post_categories( $p->ID, array( 'fields' => 'slugs' ) );
+
+		$content = wp_strip_all_tags( $p->post_content );
+		$content = preg_replace( '/\s+/', ' ', $content );
+		$content = trim( $content );
+
+		$row = wp_json_encode(
+			array(
+				'post_id'        => $p->ID,
+				'title'          => html_entity_decode( $p->post_title, ENT_QUOTES, 'UTF-8' ),
+				'date'           => $p->post_date,
+				'content'        => $content,
+				'categories'     => array_values( $cat_names ),
+				'category_slugs' => array_values( $cat_slugs ),
+				'url'            => get_permalink( $p->ID ),
+			)
+		);
+
+		if ( false === $row ) {
+			fclose( $fp );
+			WP_CLI::error( 'Failed to JSON-encode post ID ' . $p->ID );
+		}
+		$write_or_error( $fp, $row, 'post row for post ID ' . $p->ID );
+		++$total_exported;
+
+		if ( 0 === $total_exported % 500 ) {
+			WP_CLI::log( "Exported $total_exported posts..." );
+		}
+	}
+
+	$last_id = $all_posts[ count( $all_posts ) - 1 ]->ID;
+	wp_cache_flush();
+}
+
+$write_or_error( $fp, "\n]", 'closing JSON array to ' . $output_file );
+if ( false === fclose( $fp ) ) {
+	WP_CLI::error( 'Failed to close export file: ' . $output_file );
+}
+// phpcs:enable
+
+WP_CLI::success( "Exported $total_exported posts to $output_file" );

package/dist/cli/plugin/skills/taxonomist/scripts/restore.php

@@ -0,0 +1,233 @@
+<?php
+/**
+ * Restore taxonomy state from a backup file.
+ *
+ * Performs a full authoritative restore: the category taxonomy after this
+ * script runs will exactly match the backup.
+ *
+ * Usage:
+ *   TAXONOMIST_BACKUP=/path/to/backup.json studio wp eval-file restore.php
+ *
+ * Environment variables:
+ *   TAXONOMIST_BACKUP  Path to the backup JSON file created by backup.php.
+ *                      Required.
+ *
+ * @package Taxonomist
+ */
+
+$backup_file = getenv( 'TAXONOMIST_BACKUP' );
+if ( ! $backup_file || ! file_exists( $backup_file ) ) {
+	WP_CLI::error( 'Set TAXONOMIST_BACKUP env var to the backup file path' );
+}
+
+$backup = json_decode( file_get_contents( $backup_file ), true ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents
+if ( ! $backup ) {
+	WP_CLI::error( 'Failed to parse backup file' );
+}
+
+WP_CLI::log( 'Restoring from backup: ' . $backup['timestamp'] );
+WP_CLI::log( 'Posts: ' . $backup['total_posts'] . ', Categories: ' . $backup['total_categories'] );
+
+$backup_slugs   = array();
+$old_id_to_slug = array();
+foreach ( $backup['categories'] as $category ) {
+	$backup_slugs[ $category['slug'] ]      = $category;
+	$old_id_to_slug[ $category['term_id'] ] = $category['slug'];
+}
+
+// Step 1: Recreate missing categories and update existing ones.
+$existing_terms   = get_terms(
+	array(
+		'taxonomy'   => 'category',
+		'hide_empty' => false,
+	)
+);
+$existing_by_slug = array();
+foreach ( $existing_terms as $t ) {
+	$existing_by_slug[ $t->slug ] = $t;
+}
+
+$slug_to_id = array();
+$created    = 0;
+$updated    = 0;
+
+foreach ( $backup['categories'] as $category ) {
+	$slug = $category['slug'];
+
+	if ( isset( $existing_by_slug[ $slug ] ) ) {
+		$existing     = $existing_by_slug[ $slug ];
+		$needs_update = (
+			$existing->name !== $category['name'] ||
+			$existing->description !== $category['description']
+		);
+		if ( $needs_update ) {
+			wp_update_term(
+				$existing->term_id,
+				'category',
+				array(
+					'name'        => $category['name'],
+					'description' => $category['description'],
+				)
+			);
+			++$updated;
+			WP_CLI::log( 'Updated category: ' . $category['name'] );
+		}
+		$slug_to_id[ $slug ] = $existing->term_id;
+	} else {
+		$temp_name = $category['name'];
+		$result    = wp_insert_term(
+			$temp_name,
+			'category',
+			array(
+				'slug'        => $category['slug'],
+				'description' => $category['description'],
+			)
+		);
+		if ( is_wp_error( $result ) && 'term_exists' === $result->get_error_code() ) {
+			$temp_name = $category['name'] . '-taxonomist-' . uniqid();
+			$result    = wp_insert_term(
+				$temp_name,
+				'category',
+				array(
+					'slug'        => $category['slug'] . '-taxonomist-' . uniqid(),
+					'description' => $category['description'],
+				)
+			);
+		}
+		if ( ! is_wp_error( $result ) ) {
+			$slug_to_id[ $slug ] = $result['term_id'];
+			++$created;
+			WP_CLI::log( 'Recreated category: ' . $category['name'] );
+		} else {
+			WP_CLI::warning( 'Failed to recreate ' . $category['name'] . ': ' . $result->get_error_message() );
+		}
+	}
+}
+
+// Step 2: Restore parent-child hierarchy.
+$hierarchy_fixed = 0;
+foreach ( $backup['categories'] as $category ) {
+	$slug       = $category['slug'];
+	$old_parent = $category['parent'];
+
+	if ( ! isset( $slug_to_id[ $slug ] ) ) {
+		continue;
+	}
+
+	$current_id       = $slug_to_id[ $slug ];
+	$target_parent_id = 0;
+
+	if ( $old_parent > 0 && isset( $old_id_to_slug[ $old_parent ] ) ) {
+		$parent_slug = $old_id_to_slug[ $old_parent ];
+		if ( isset( $slug_to_id[ $parent_slug ] ) ) {
+			$target_parent_id = $slug_to_id[ $parent_slug ];
+		} else {
+			WP_CLI::warning( "Parent slug '$parent_slug' not found for category '$slug'" );
+		}
+	}
+
+	$current_term = get_term( $current_id, 'category' );
+	if ( ! $current_term ) {
+		continue;
+	}
+
+	$needs_fix = (
+		(int) $current_term->parent !== $target_parent_id ||
+		$current_term->name !== $category['name'] ||
+		$current_term->slug !== $category['slug']
+	);
+	if ( $needs_fix ) {
+		wp_update_term(
+			$current_id,
+			'category',
+			array(
+				'parent' => $target_parent_id,
+				'name'   => $category['name'],
+				'slug'   => $category['slug'],
+			)
+		);
+		++$hierarchy_fixed;
+	}
+}
+
+if ( $hierarchy_fixed > 0 ) {
+	WP_CLI::log( "Fixed $hierarchy_fixed parent-child relationships." );
+}
+
+// Step 3: Restore every post's categories.
+$restored    = 0;
+$error_count = 0;
+foreach ( $backup['post_categories'] as $pc ) {
+	$current_post_id = $pc['post_id'];
+	$target_ids      = array();
+
+	foreach ( $pc['category_slugs'] as $slug ) {
+		if ( isset( $slug_to_id[ $slug ] ) ) {
+			$target_ids[] = $slug_to_id[ $slug ];
+		} else {
+			WP_CLI::warning( "Category slug '$slug' not found for post ID $current_post_id" );
+			++$error_count;
+		}
+	}
+
+	$current_post = get_post( $current_post_id );
+	if ( ! $current_post ) {
+		WP_CLI::warning( 'Post ID ' . $current_post_id . ' no longer exists' );
+		++$error_count;
+		continue;
+	}
+
+	$set_result = wp_set_post_categories( $current_post_id, $target_ids );
+	if ( is_wp_error( $set_result ) || false === $set_result ) {
+		WP_CLI::warning( 'Failed to restore categories for post ID ' . $current_post_id );
+		++$error_count;
+		continue;
+	}
+	++$restored;
+
+	if ( 0 === $restored % 500 && $restored > 0 ) {
+		WP_CLI::log( "Restored $restored posts..." );
+		wp_cache_flush();
+	}
+}
+
+// Step 4: Delete categories created after the backup.
+$post_restore_terms = get_terms(
+	array(
+		'taxonomy'   => 'category',
+		'hide_empty' => false,
+	)
+);
+$deleted            = 0;
+foreach ( $post_restore_terms as $t ) {
+	if ( ! isset( $backup_slugs[ $t->slug ] ) ) {
+		$default_cat = (int) get_option( 'default_category' );
+		if ( $t->term_id === $default_cat ) {
+			$first_backup_slug = array_key_first( $backup_slugs );
+			if ( $first_backup_slug && isset( $slug_to_id[ $first_backup_slug ] ) ) {
+				update_option( 'default_category', $slug_to_id[ $first_backup_slug ] );
+			}
+		}
+		wp_delete_term( $t->term_id, 'category' );
+		WP_CLI::log( 'Deleted post-backup category: ' . $t->name );
+		++$deleted;
+	}
+}
+
+// Step 5: Restore the default_category setting.
+if ( isset( $backup['default_category_slug'] ) ) {
+	$default_slug = $backup['default_category_slug'];
+	if ( isset( $slug_to_id[ $default_slug ] ) ) {
+		update_option( 'default_category', $slug_to_id[ $default_slug ] );
+		WP_CLI::log( 'Restored default category: ' . $default_slug );
+	}
+}
+
+// Step 6: Recount term usage.
+WP_CLI::runcommand( 'term recount category' );
+
+WP_CLI::success(
+	"Restored $restored posts. " .
+	"Created $created categories, updated $updated, deleted $deleted. " .
+	"Errors: $error_count."
+);