diff --git a/src/components/manage/change-warning.tsx b/src/components/manage/change-warning.tsx
new file mode 100644
index 0000000..2cfd1cd
--- /dev/null
+++ b/src/components/manage/change-warning.tsx
@@ -0,0 +1,25 @@
+import clsx from "clsx";
+
+/** A caution line under a repository's change preview; renders nothing without a warning. */
+export function ChangeWarning({
+	className,
+	warning,
+}: Readonly<{
+	className?: string;
+	warning: string | null;
+}>) {
+	if (warning === null) {
+		return null;
+	}
+
+	return (
+		<p
+			className={clsx(
+				"mt-1 text-amber-700 text-sm/6 sm:text-xs/6 dark:text-amber-400",
+				className
+			)}
+		>
+			{warning}
+		</p>
+	);
+}
diff --git a/src/components/manage/manage-edit-dialog.tsx b/src/components/manage/manage-edit-dialog.tsx
index 21966ce..030a8e8 100644
--- a/src/components/manage/manage-edit-dialog.tsx
+++ b/src/components/manage/manage-edit-dialog.tsx
@@ -15,11 +15,13 @@ import { Field, Fieldset, Label } from "@/components/ui/fieldset";
 import { Strong, Text } from "@/components/ui/text";
 import { formatRepositoryCount } from "@/format";
 import type { GitHubRepository, ManageRepositoryActions } from "@/github/types";
+import { ChangeWarning } from "./change-warning";
 import {
 	MANAGE_ARCHIVE_ACTION_OPTIONS,
 	MANAGE_SUBSCRIPTION_ACTION_OPTIONS,
 } from "./types";
 import {
+	getArchivedVisibilityWarning,
 	getManageActionsSummary,
 	getManageVisibilityActionOptions,
 	getRepositoryChangeLines,
@@ -160,6 +162,9 @@ function RepositoryChangePreview({
 			) : (
 				<Text className="mt-1">No change needed.</Text>
 			)}
+			<ChangeWarning
+				warning={getArchivedVisibilityWarning(repository, actions)}
+			/>
 		</RepositoryPreviewItem>
 	);
 }
diff --git a/src/components/manage/manage-review-dialog.tsx b/src/components/manage/manage-review-dialog.tsx
index 3762e44..77ebe1c 100644
--- a/src/components/manage/manage-review-dialog.tsx
+++ b/src/components/manage/manage-review-dialog.tsx
@@ -15,7 +15,12 @@ import {
 import { Strong, Text } from "@/components/ui/text";
 import { formatRepositoryCount } from "@/format";
 import type { GitHubRepository, ManageRepositoryActions } from "@/github/types";
-import { getRepositoryChangeLines, type StagedChanges } from "./utils";
+import { ChangeWarning } from "./change-warning";
+import {
+	getArchivedVisibilityWarning,
+	getRepositoryChangeLines,
+	type StagedChanges,
+} from "./utils";
 
 /** Lists every staged change so the whole batch is confirmed at once. */
 export function ManageReviewDialog({
@@ -105,6 +110,9 @@ function StagedChangeItem({
 	const changeLines = actions
 		? getRepositoryChangeLines(repository, actions)
 		: [];
+	const warning = actions
+		? getArchivedVisibilityWarning(repository, actions)
+		: null;
 
 	return (
 		<li className="flex items-start justify-between gap-3 px-3 py-2">
@@ -115,6 +123,7 @@ function StagedChangeItem({
 						{changeLine}
 					</Text>
 				))}
+				<ChangeWarning warning={warning} />
 			</div>
 			<Button
 				aria-label={`Remove changes for ${repository.name}`}
diff --git a/src/components/manage/use-manage-flow.ts b/src/components/manage/use-manage-flow.ts
index e89cfbe..4e5843f 100644
--- a/src/components/manage/use-manage-flow.ts
+++ b/src/components/manage/use-manage-flow.ts
@@ -1,4 +1,4 @@
-import { useCallback, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 import { getFailedRepositoryNames } from "@/components/repositories/list-utils";
 import {
 	type RepositoryListState,
@@ -15,9 +15,13 @@ import type {
 } from "@/server-functions";
 import { DEFAULT_MANAGE_ACTIONS } from "./types";
 import {
+	type AppliedRepositoryStates,
+	applyRepositoryStates,
 	createManageChangeInput,
+	getAppliedRepositoryState,
 	hasChangedSetting,
 	hasManageAction,
+	pruneAppliedStates,
 	type StagedChanges,
 	showManageResultToast,
 	stageChanges,
@@ -25,6 +29,7 @@ import {
 
 const MANAGE_CHUNK_SIZE = 10;
 const EMPTY_STAGED_CHANGES: StagedChanges = new Map();
+const EMPTY_APPLIED_STATES: AppliedRepositoryStates = new Map();
 
 const chunk = <Item>(items: Item[], size: number): Item[][] => {
 	const chunks: Item[][] = [];
@@ -82,7 +87,7 @@ export function useManageFlow({
 	expectedRepositoryCount,
 	onManageChunk,
 	onRunComplete,
-	repositories,
+	repositories: loadedRepositories,
 }: Readonly<{
 	expectedRepositoryCount: number;
 	onManageChunk: (
@@ -91,6 +96,20 @@ export function useManageFlow({
 	onRunComplete: (didChangeAnything: boolean) => Promise<void>;
 	repositories: GitHubRepository[];
 }>): ManageFlow {
+	// Settings a run changed show at once; the overlay lifts as the refetched list catches up.
+	const [appliedStates, setAppliedStates] =
+		useState<AppliedRepositoryStates>(EMPTY_APPLIED_STATES);
+	const repositories = useMemo(
+		() => applyRepositoryStates(loadedRepositories, appliedStates),
+		[appliedStates, loadedRepositories]
+	);
+
+	useEffect(() => {
+		setAppliedStates((previous) =>
+			pruneAppliedStates(loadedRepositories, previous)
+		);
+	}, [loadedRepositories]);
+
 	const list = useRepositoryList(repositories, {
 		expectedCount: expectedRepositoryCount,
 	});
@@ -211,8 +230,32 @@ export function useManageFlow({
 		openReview();
 	};
 
+	const recordAppliedStates = (
+		chunkResults: ManageRepositoryResult[],
+		changes: StagedChanges
+	): void => {
+		setAppliedStates((previous) => {
+			const next = new Map(previous);
+
+			for (const result of chunkResults) {
+				const actions = changes.get(result.repository);
+				const applied = actions && getAppliedRepositoryState(actions, result);
+
+				if (applied) {
+					next.set(result.repository, {
+						...previous.get(result.repository),
+						...applied,
+					});
+				}
+			}
+
+			return next;
+		});
+	};
+
 	const runChunks = async (
-		changeInputs: ManageRepositoryChangeInput[]
+		changeInputs: ManageRepositoryChangeInput[],
+		changes: StagedChanges
 	): Promise<ChunkedRun> => {
 		const results: ManageRepositoryResult[] = [];
 
@@ -232,6 +275,7 @@ export function useManageFlow({
 			);
 
 			results.push(...chunkResult.results);
+			recordAppliedStates(chunkResult.results, changes);
 			setManageResults([...results]);
 			setPendingRepositories((previousPending) =>
 				previousPending.filter((name) => !chunkRepositories.has(name))
@@ -263,7 +307,7 @@ export function useManageFlow({
 		let run: ChunkedRun;
 
 		try {
-			run = await runChunks(changeInputs);
+			run = await runChunks(changeInputs, stagedChanges);
 		} finally {
 			setPendingRepositories([]);
 			setIsManaging(false);
diff --git a/src/components/manage/utils.test.ts b/src/components/manage/utils.test.ts
index 38b5799..467c7d6 100644
--- a/src/components/manage/utils.test.ts
+++ b/src/components/manage/utils.test.ts
@@ -16,6 +16,9 @@ import type {
 	RepositoryVisibility,
 } from "@/github/types";
 import {
+	applyRepositoryStates,
+	getAppliedRepositoryState,
+	getArchivedVisibilityWarning,
 	getManageActionsSummary,
 	getManageRepositoryStatus,
 	getManageResultCounts,
@@ -26,6 +29,7 @@ import {
 	getRepositoryChangeLines,
 	getRepositoryStateActions,
 	mergeStagedActions,
+	pruneAppliedStates,
 	showManageResultToast,
 	stageChanges,
 } from "./utils";
@@ -222,6 +226,89 @@ describe("getManageActionsSummary", () => {
 	});
 });
 
+describe("getArchivedVisibilityWarning", () => {
+	it("warns when an archived repository changes visibility and stays archived", () => {
+		expect(
+			getArchivedVisibilityWarning(
+				createRepository({ archived: true, visibility: "public" }),
+				createActions({ visibilityAction: "private" })
+			)
+		).toContain("archive date");
+	});
+
+	it("stays quiet when the repository is unarchived, active, or keeps its visibility", () => {
+		const archivedPublic = createRepository({
+			archived: true,
+			visibility: "public",
+		});
+
+		expect(
+			getArchivedVisibilityWarning(
+				archivedPublic,
+				createActions({
+					archiveAction: "unarchived",
+					visibilityAction: "private",
+				})
+			)
+		).toBeNull();
+		expect(
+			getArchivedVisibilityWarning(
+				createRepository({ archived: false, visibility: "public" }),
+				createActions({ visibilityAction: "private" })
+			)
+		).toBeNull();
+		expect(
+			getArchivedVisibilityWarning(
+				archivedPublic,
+				createActions({ visibilityAction: "public" })
+			)
+		).toBeNull();
+	});
+});
+
+describe("applied repository states", () => {
+	it("collects only the settings a run actually changed", () => {
+		expect(
+			getAppliedRepositoryState(
+				createActions({
+					archiveAction: "archived",
+					subscriptionAction: "ignoring",
+					visibilityAction: "private",
+				}),
+				createManageResult({
+					archive: createSettingResult({ outcome: "changed" }),
+					subscription: createSettingResult({ outcome: "failed" }),
+					visibility: createSettingResult({ outcome: "unchanged" }),
+				})
+			)
+		).toEqual({ archived: true });
+		expect(
+			getAppliedRepositoryState(
+				createActions({ visibilityAction: "private" }),
+				createManageResult({
+					visibility: createSettingResult({ outcome: "failed" }),
+				})
+			)
+		).toBeNull();
+	});
+
+	it("overlays applied states and prunes them once the list catches up", () => {
+		const stale = createRepository({ name: "repo", visibility: "public" });
+		const other = createRepository({ name: "other" });
+		const applied = new Map([["repo", { visibility: "private" as const }]]);
+		const overlaid = applyRepositoryStates([stale, other], applied);
+
+		expect(overlaid[0]?.visibility).toBe("private");
+		expect(overlaid[1]).toBe(other);
+		expect(pruneAppliedStates([stale], applied)).toBe(applied);
+
+		const fresh = createRepository({ name: "repo", visibility: "private" });
+
+		expect(applyRepositoryStates([fresh], applied)[0]).toBe(fresh);
+		expect(pruneAppliedStates([fresh], applied).size).toBe(0);
+	});
+});
+
 describe("getRepositoryChangeLines", () => {
 	it("returns no lines when every action keeps the current value", () => {
 		expect(
diff --git a/src/components/manage/utils.ts b/src/components/manage/utils.ts
index 6ef1483..768cc6b 100644
--- a/src/components/manage/utils.ts
+++ b/src/components/manage/utils.ts
@@ -29,6 +29,94 @@ const getSettingResults = (
 	result.subscription,
 ];
 
+/** The repository fields the app can change, as they stand after a run. */
+export type AppliedRepositoryState = Partial<
+	Pick<GitHubRepository, "archived" | "subscription" | "visibility">
+>;
+
+export type AppliedRepositoryStates = ReadonlyMap<
+	string,
+	AppliedRepositoryState
+>;
+
+/**
+ * The new values a successful run gave a repository, so the table can show
+ * them before the list is refetched.
+ */
+export const getAppliedRepositoryState = (
+	actions: ManageRepositoryActions,
+	result: ManageRepositoryResult
+): AppliedRepositoryState | null => {
+	const applied: AppliedRepositoryState = {};
+
+	if (
+		result.archive?.outcome === "changed" &&
+		actions.archiveAction !== "current"
+	) {
+		applied.archived = actions.archiveAction === "archived";
+	}
+
+	if (
+		result.visibility?.outcome === "changed" &&
+		actions.visibilityAction !== "current"
+	) {
+		applied.visibility = actions.visibilityAction;
+	}
+
+	if (
+		result.subscription?.outcome === "changed" &&
+		actions.subscriptionAction !== "current"
+	) {
+		applied.subscription = actions.subscriptionAction;
+	}
+
+	return Object.keys(applied).length > 0 ? applied : null;
+};
+
+const matchesAppliedState = (
+	repository: GitHubRepository,
+	applied: AppliedRepositoryState
+): boolean =>
+	Object.entries(applied).every(
+		([key, value]) => repository[key as keyof AppliedRepositoryState] === value
+	);
+
+/** Overlays applied states on the loaded list; repositories already up to date keep their identity. */
+export const applyRepositoryStates = (
+	repositories: GitHubRepository[],
+	appliedStates: AppliedRepositoryStates
+): GitHubRepository[] => {
+	if (appliedStates.size === 0) {
+		return repositories;
+	}
+
+	return repositories.map((repository) => {
+		const applied = appliedStates.get(repository.name);
+
+		return applied && !matchesAppliedState(repository, applied)
+			? { ...repository, ...applied }
+			: repository;
+	});
+};
+
+/** Drops applied states the refetched list already reflects. */
+export const pruneAppliedStates = (
+	repositories: GitHubRepository[],
+	appliedStates: AppliedRepositoryStates
+): AppliedRepositoryStates => {
+	const next = new Map(appliedStates);
+
+	for (const repository of repositories) {
+		const applied = next.get(repository.name);
+
+		if (applied && matchesAppliedState(repository, applied)) {
+			next.delete(repository.name);
+		}
+	}
+
+	return next.size === appliedStates.size ? appliedStates : next;
+};
+
 export const hasChangedSetting = (result: ManageRepositoryResult): boolean =>
 	getSettingResults(result).some(
 		(settingResult) => settingResult?.outcome === "changed"
@@ -211,6 +299,26 @@ export const getRepositoryChangeLines = (
 		getSubscriptionChangeLine(repository, actions),
 	].filter((line): line is string => line !== null);
 
+/**
+ * GitHub only lets an archived repository be unarchived, so a visibility change
+ * unarchives and re-archives it, and GitHub then shows today as the archive date.
+ */
+export const getArchivedVisibilityWarning = (
+	repository: GitHubRepository,
+	actions: ManageRepositoryActions
+): string | null => {
+	const changesVisibility =
+		getVisibilityChangeLine(repository, actions) !== null;
+	const staysArchived =
+		repository.archived && actions.archiveAction !== "unarchived";
+
+	if (!(changesVisibility && staysArchived)) {
+		return null;
+	}
+
+	return "Changing visibility re-archives this repository, so GitHub will show today as its archive date.";
+};
+
 export const getManageVisibilityActionOptions = (
 	supportsInternalVisibility: boolean
 ): ReadonlyArray<{
diff --git a/src/github/github.test.ts b/src/github/github.test.ts
index 428e0ab..75faf7b 100644
--- a/src/github/github.test.ts
+++ b/src/github/github.test.ts
@@ -1135,6 +1135,108 @@ describe("manageGitHubRepositories", () => {
 		expect(results[0]?.visibility?.outcome).toBe("changed");
 	});
 
+	const createArchivedRepositoryFetch = (requestBodies: unknown[]) =>
+		createFetchImplementation((_url, init) => {
+			if ((init.method ?? "GET") === "GET") {
+				return new Response(
+					JSON.stringify(createManagedRepositoryResponse(true, "public")),
+					{ status: 200, statusText: "OK" }
+				);
+			}
+
+			requestBodies.push(JSON.parse(String(init.body)));
+
+			return new Response("", { status: 200, statusText: "OK" });
+		});
+
+	it("unarchives and re-archives around a visibility change on an archived repository", async () => {
+		const requestBodies: unknown[] = [];
+
+		const results = await manageGitHubRepositories(
+			"token",
+			"owner",
+			[
+				{
+					actions: { ...noChangeActions, visibilityAction: "private" },
+					repository: "repo",
+				},
+			],
+			createArchivedRepositoryFetch(requestBodies)
+		);
+
+		expect(requestBodies).toEqual([
+			{ archived: false },
+			{ archived: true, visibility: "private" },
+		]);
+		expect(results[0]?.ok).toBe(true);
+		expect(results[0]?.archive).toBeNull();
+		expect(results[0]?.visibility?.outcome).toBe("changed");
+	});
+
+	it("unarchives before changing visibility when the repository should end up unarchived", async () => {
+		const requestBodies: unknown[] = [];
+
+		const results = await manageGitHubRepositories(
+			"token",
+			"owner",
+			[
+				{
+					actions: {
+						archiveAction: "unarchived",
+						subscriptionAction: "current",
+						visibilityAction: "private",
+					},
+					repository: "repo",
+				},
+			],
+			createArchivedRepositoryFetch(requestBodies)
+		);
+
+		expect(requestBodies).toEqual([
+			{ archived: false },
+			{ visibility: "private" },
+		]);
+		expect(results[0]?.archive?.outcome).toBe("changed");
+		expect(results[0]?.visibility?.outcome).toBe("changed");
+	});
+
+	it("reports a failed re-archive after unarchiving for a visibility change", async () => {
+		const fetchImplementation = createFetchImplementation((_url, init) => {
+			if ((init.method ?? "GET") === "GET") {
+				return new Response(
+					JSON.stringify(createManagedRepositoryResponse(true, "public")),
+					{ status: 200, statusText: "OK" }
+				);
+			}
+
+			const body = JSON.parse(String(init.body)) as { archived?: boolean };
+
+			return body.archived === false
+				? new Response("", { status: 200, statusText: "OK" })
+				: new Response(JSON.stringify({ message: "Nope" }), {
+						status: 422,
+						statusText: "Unprocessable Entity",
+					});
+		});
+
+		const results = await manageGitHubRepositories(
+			"token",
+			"owner",
+			[
+				{
+					actions: { ...noChangeActions, visibilityAction: "private" },
+					repository: "repo",
+				},
+			],
+			fetchImplementation
+		);
+
+		expect(results[0]?.ok).toBe(false);
+		expect(results[0]?.visibility?.outcome).toBe("failed");
+		expect(results[0]?.archive?.outcome).toBe("failed");
+		expect(results[0]?.archive?.error).toContain("could not be archived again");
+	});
+
 	describe("notification subscription updates", () => {
 		it("watches a repository that has no existing subscription", async () => {
 			const methods: string[] = [];
diff --git a/src/github/manage.ts b/src/github/manage.ts
index d37da74..5476f05 100644
--- a/src/github/manage.ts
+++ b/src/github/manage.ts
@@ -279,6 +279,63 @@ const loadManagedRepository = async (
 	return (await response.json()) as GitHubManagedRepositoryResponse;
 };
 
+const patchRepositorySettings = async (
+	context: ManageContext,
+	repositoryName: string,
+	body: RepositorySettingsBody
+): Promise<ManageSettingResult> => {
+	const pathname = repositoryPathname(context.owner, repositoryName);
+	const response = await fetchWithRateLimitRetry(context, () =>
+		fetchGitHubResponse(context, pathname, jsonRequestInit("PATCH", body))
+	);
+
+	return await toSettingResult(response, `Failed to update ${repositoryName}.`);
+};
+
+/**
+ * GitHub rejects every write to an archived repository except unarchiving it,
+ * so a visibility change unarchives first and re-archives unless the repository
+ * is meant to end up unarchived.
+ */
+const applyVisibilityToArchivedRepository = async (
+	context: ManageContext,
+	repositoryName: string,
+	body: RepositorySettingsBody
+): Promise<RepositorySettingsResults> => {
+	const staysArchived = body.archived !== false;
+	const unarchiveResult = await patchRepositorySettings(
+		context,
+		repositoryName,
+		{ archived: false }
+	);
+	const archiveResultAfterUnarchive = staysArchived ? null : unarchiveResult;
+
+	if (unarchiveResult.outcome === "failed") {
+		return {
+			archive: staysArchived ? null : unarchiveResult,
+			visibility: { ...unarchiveResult },
+		};
+	}
+
+	const visibilityResult = await patchRepositorySettings(
+		context,
+		repositoryName,
+		{ archived: staysArchived ? true : undefined, visibility: body.visibility }
+	);
+	const rearchiveFailed =
+		staysArchived && visibilityResult.outcome === "failed";
+
+	return {
+		archive: rearchiveFailed
+			? {
+					...visibilityResult,
+					error: `${repositoryName} was unarchived to change its visibility and could not be archived again: ${visibilityResult.error}`,
+				}
+			: archiveResultAfterUnarchive,
+		visibility: visibilityResult,
+	};
+};
+
 const applyRepositorySettings = async (
 	context: ManageContext,
 	repositoryName: string,
@@ -315,12 +372,18 @@ const applyRepositorySettings = async (
 			return { archive, visibility };
 		}
 
-		const patchResponse = await fetchWithRateLimitRetry(context, () =>
-			fetchGitHubResponse(context, pathname, jsonRequestInit("PATCH", body))
-		);
-		const patchResult = await toSettingResult(
-			patchResponse,
-			`Failed to update ${repositoryName}.`
+		if (current.archived && body.visibility !== undefined) {
+			return await applyVisibilityToArchivedRepository(
+				context,
+				repositoryName,
+				body
+			);
+		}
+
+		const patchResult = await patchRepositorySettings(
+			context,
+			repositoryName,
+			body
 		);
 
 		return {