diff --git a/apps/web/app/settings/system/storage/page.tsx b/apps/web/app/settings/system/storage/page.tsx
index 7d5acc5ce5..80a6a06d5c 100644
--- a/apps/web/app/settings/system/storage/page.tsx
+++ b/apps/web/app/settings/system/storage/page.tsx
@@ -1,12 +1,13 @@
+"use client";
+
+import { useTranslation } from "react-i18next";
 import { StorageMaintenanceSettings } from "@/components/settings/system/storage/storage-maintenance-settings";
 import { SystemPageShell } from "@/components/settings/system/system-page-shell";
 
 export default function StoragePage() {
+  const { t } = useTranslation();
   return (
-    <SystemPageShell
-      title="Storage"
-      description="Review disk use and reclaim space from Kandev-owned workspaces, caches, and Docker resources whenever your installation needs it."
-    >
+    <SystemPageShell title={t("system:storageTitle")} description={t("system:storageDescription")}>
       <StorageMaintenanceSettings />
     </SystemPageShell>
   );
diff --git a/apps/web/components/settings/system/storage/storage-confirmation-dialogs.test.tsx b/apps/web/components/settings/system/storage/storage-confirmation-dialogs.test.tsx
new file mode 100644
index 0000000000..1c3367e1a6
--- /dev/null
+++ b/apps/web/components/settings/system/storage/storage-confirmation-dialogs.test.tsx
@@ -0,0 +1,146 @@
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+import { activateLocale } from "@/lib/i18n";
+import {
+  DedicatedDockerDialog,
+  ExternalGoCacheDialog,
+  PermanentDeleteDialog,
+  QuarantinePurgeDialog,
+} from "./storage-confirmation-dialogs";
+
+afterEach(cleanup);
+
+describe("storage confirmation dialogs", () => {
+  // The confirm gate is `confirmation !== phrase`, so the phrase must reach the
+  // user exactly as the comparison expects it. Translating it — or letting the
+  // <Trans> tag index drift off its <strong> child — would leave a dialog the
+  // user cannot satisfy, and nothing else in the suite would fail.
+  it("shows the untranslated phrase and only enables the action on an exact match", () => {
+    const onConfirm = vi.fn();
+    render(
+      <PermanentDeleteDialog entry={null} open onOpenChange={vi.fn()} onConfirm={onConfirm} />,
+    );
+
+    const description = screen.getByText(/This cannot be undone/);
+    expect(description.textContent).toBe(
+      "This cannot be undone. Kandev will permanently remove the selected quarantine entry. Type DELETE to continue.",
+    );
+
+    const input = screen.getByLabelText("Type DELETE to confirm");
+    const action = screen.getByTestId("storage-quarantine-delete-confirm") as HTMLButtonElement;
+    expect(action.disabled).toBe(true);
+
+    fireEvent.change(input, { target: { value: "delete" } });
+    expect(action.disabled).toBe(true);
+
+    fireEvent.change(input, { target: { value: "DELETE" } });
+    expect(action.disabled).toBe(false);
+  });
+
+  // Two independent counts cannot share one i18next `count`, so this sentence is
+  // two plural messages joined. Both forms are asserted whole.
+  it("agrees both quarantine counts with their own number", () => {
+    const purge = (eligibleCount: number, protectedCount: number) =>
+      render(
+        <QuarantinePurgeDialog
+          scope="eligible"
+          eligibleCount={eligibleCount}
+          protectedCount={protectedCount}
+          open
+          onOpenChange={vi.fn()}
+          onConfirm={vi.fn()}
+        />,
+      );
+
+    purge(1, 1);
+    expect(screen.getByText(/This will permanently remove/).textContent).toBe(
+      "This will permanently remove 1 eligible item. 1 protected item remains until its retention deadline. Type DELETE ELIGIBLE to continue.",
+    );
+
+    cleanup();
+    purge(3, 2);
+    expect(screen.getByText(/This will permanently remove/).textContent).toBe(
+      "This will permanently remove 3 eligible items. 2 protected items remain until their retention deadlines. Type DELETE ELIGIBLE to continue.",
+    );
+  });
+});
+
+/**
+ * The pseudo-locale oracle, at unit scale.
+ *
+ * `i18next/no-literal-string` runs in `mode: "jsx-only"`, so a string this file
+ * hands to `<ConfirmationDialog>` through a helper or a template would be
+ * invisible to lint, and a clean lint is not proof the file is done. Under
+ * `pseudo` every catalog message is accented, so any word-like ASCII left in a
+ * dialog is a literal that never reached the catalog — except the confirmation
+ * phrase, which must stay verbatim for `confirmation !== phrase` to be
+ * satisfiable. These four dialogs carry the page's destructive actions, so they
+ * are the ones worth pinning.
+ *
+ * Accessibility copy is scanned too. A screen-reader-only string is exactly the
+ * kind that survives a migration untranslated, because nothing on screen looks
+ * wrong — and the input's `aria-label` is the only place the confirmation phrase
+ * is announced.
+ */
+describe("storage confirmation dialogs under the pseudo-locale", () => {
+  const ACCENTED = /[À-ɏ]/;
+  const WORDLIKE = /[A-Za-z]{4,}/;
+  /** Attributes that carry copy, mirroring the eslint guard's include list. */
+  const COPY_ATTRIBUTES = ["aria-label", "aria-description", "title", "placeholder", "alt"];
+
+  /** Text and accessibility copy in the open dialog that is not accented. */
+  function unlocalizedText(): string[] {
+    const dialog = document.querySelector("[role=alertdialog]");
+    if (!dialog) throw new Error("dialog did not render");
+    const leftovers = new Set<string>();
+    const consider = (value: string | null | undefined) => {
+      const text = (value ?? "").trim();
+      if (text && WORDLIKE.test(text) && !ACCENTED.test(text)) leftovers.add(text);
+    };
+
+    const walker = document.createTreeWalker(dialog, NodeFilter.SHOW_TEXT);
+    let node = walker.nextNode();
+    while (node) {
+      consider(node.textContent);
+      node = walker.nextNode();
+    }
+    for (const element of [dialog, ...dialog.querySelectorAll("*")]) {
+      for (const attribute of COPY_ATTRIBUTES) consider(element.getAttribute(attribute));
+    }
+    return [...leftovers];
+  }
+
+  beforeAll(async () => {
+    await activateLocale("pseudo");
+  });
+  afterAll(async () => {
+    await activateLocale("en");
+  });
+
+  const dialogProps = { open: true, onOpenChange: vi.fn(), onConfirm: vi.fn() };
+
+  it.each([
+    ["DEDICATED", <DedicatedDockerDialog key="d" {...dialogProps} />],
+    ["ADOPT", <ExternalGoCacheDialog key="a" path="" {...dialogProps} />],
+    ["DELETE", <PermanentDeleteDialog key="p" entry={null} {...dialogProps} />],
+    [
+      "DELETE ALL NOW",
+      <QuarantinePurgeDialog
+        key="q"
+        scope="all"
+        eligibleCount={0}
+        protectedCount={0}
+        {...dialogProps}
+      />,
+    ],
+  ])("leaves only the %s phrase un-accented", (phrase, element) => {
+    render(element);
+    // The phrase appears twice — in the sentence and in the input's aria-label —
+    // and both must be the raw token, so the deduped set is exactly one entry.
+    expect(unlocalizedText()).toEqual([phrase]);
+    const input = screen.getByRole("textbox");
+    const label = input.getAttribute("aria-label") ?? "";
+    expect(label).toContain(phrase);
+    expect(label.replace(phrase, "")).toMatch(ACCENTED);
+  });
+});
diff --git a/apps/web/components/settings/system/storage/storage-confirmation-dialogs.tsx b/apps/web/components/settings/system/storage/storage-confirmation-dialogs.tsx
index 64e6688375..5953985774 100644
--- a/apps/web/components/settings/system/storage/storage-confirmation-dialogs.tsx
+++ b/apps/web/components/settings/system/storage/storage-confirmation-dialogs.tsx
@@ -12,14 +12,24 @@ import {
   AlertDialogTitle,
 } from "@kandev/ui/alert-dialog";
 import { Input } from "@kandev/ui/input";
+import { Trans, useTranslation } from "react-i18next";
 import type { StorageQuarantineEntry, StorageQuarantinePurgeScope } from "@/lib/types/system";
 
+/**
+ * `phrase` is a sentinel, never copy: the user must type it verbatim and the
+ * confirm button gates on `confirmation !== props.phrase`. Translating one of
+ * these would make the dialog impossible to satisfy in that locale — so the
+ * union stays English and travels as an interpolated value everywhere it is
+ * shown (see docs/i18n.md, "Do not translate").
+ */
+type ConfirmationPhrase = "DEDICATED" | "ADOPT" | "DELETE" | "DELETE ELIGIBLE" | "DELETE ALL NOW";
+
 type ConfirmationDialogProps = {
   open: boolean;
   onOpenChange: (open: boolean) => void;
   title: string;
   description: string;
-  phrase: "DEDICATED" | "ADOPT" | "DELETE" | "DELETE ELIGIBLE" | "DELETE ALL NOW";
+  phrase: ConfirmationPhrase;
   actionLabel: string;
   actionTestId: string;
   destructive?: boolean;
@@ -27,6 +37,7 @@ type ConfirmationDialogProps = {
 };
 
 function ConfirmationDialog(props: ConfirmationDialogProps) {
+  const { t } = useTranslation();
   const [confirmation, setConfirmation] = useState("");
   useEffect(() => {
     if (!props.open) setConfirmation("");
@@ -37,18 +48,23 @@ function ConfirmationDialog(props: ConfirmationDialogProps) {
         <AlertDialogHeader>
           <AlertDialogTitle>{props.title}</AlertDialogTitle>
           <AlertDialogDescription className="text-left">
-            {props.description} Type <strong>{props.phrase}</strong> to continue.
+            {props.description}{" "}
+            <Trans i18nKey="system:storageTypeToConfirm" values={{ phrase: props.phrase }}>
+              Type <strong>{props.phrase}</strong> to continue.
+            </Trans>
           </AlertDialogDescription>
         </AlertDialogHeader>
         <Input
           value={confirmation}
           onChange={(event) => setConfirmation(event.target.value)}
           className="h-11"
-          aria-label={`Type ${props.phrase} to confirm`}
+          aria-label={t("system:storageTypeToConfirmAria", { phrase: props.phrase })}
           data-testid={`${props.actionTestId}-confirmation`}
         />
         <AlertDialogFooter>
-          <AlertDialogCancel className="min-h-11 cursor-pointer">Cancel</AlertDialogCancel>
+          <AlertDialogCancel className="min-h-11 cursor-pointer">
+            {t("common:cancel")}
+          </AlertDialogCancel>
           <AlertDialogAction
             variant={props.destructive ? "destructive" : "default"}
             disabled={confirmation !== props.phrase}
@@ -67,13 +83,14 @@ function ConfirmationDialog(props: ConfirmationDialogProps) {
 export function DedicatedDockerDialog(
   props: Pick<ConfirmationDialogProps, "open" | "onOpenChange" | "onConfirm">,
 ) {
+  const { t } = useTranslation();
   return (
     <ConfirmationDialog
       {...props}
-      title="Use this dedicated Docker daemon"
-      description="Build-cache and unused-image cleanup affect the entire configured daemon, including resources created outside Kandev. Only acknowledge a daemon dedicated to this installation."
+      title={t("system:storageDedicatedDialogTitle")}
+      description={t("system:storageDedicatedDialogDescription")}
       phrase="DEDICATED"
-      actionLabel="Acknowledge daemon"
+      actionLabel={t("system:storageAcknowledgeDaemon")}
       actionTestId="storage-docker-confirm"
     />
   );
@@ -83,13 +100,17 @@ export function ExternalGoCacheDialog({
   path,
   ...props
 }: Pick<ConfirmationDialogProps, "open" | "onOpenChange" | "onConfirm"> & { path: string }) {
+  const { t } = useTranslation();
   return (
     <ConfirmationDialog
       {...props}
-      title="Adopt an external Go build cache"
-      description={`Kandev will be allowed to rotate and quarantine the existing cache at ${path || "the selected path"}. This path must be absolute and on the same filesystem as Kandev trash.`}
+      title={t("system:storageAdoptDialogTitle")}
+      description={t("system:storageAdoptDialogDescription", {
+        // A filesystem path the user typed — interpolated, never translated.
+        path: path || t("system:storageAdoptDialogFallbackPath"),
+      })}
       phrase="ADOPT"
-      actionLabel="Adopt cache"
+      actionLabel={t("system:storageAdoptCache")}
       actionTestId="storage-go-cache-adopt-confirm"
     />
   );
@@ -101,13 +122,17 @@ export function PermanentDeleteDialog({
 }: Pick<ConfirmationDialogProps, "open" | "onOpenChange" | "onConfirm"> & {
   entry: StorageQuarantineEntry | null;
 }) {
+  const { t } = useTranslation();
   return (
     <ConfirmationDialog
       {...props}
-      title="Permanently delete quarantined data"
-      description={`This cannot be undone. Kandev will permanently remove ${entry?.quarantine_path ?? "the selected quarantine entry"}.`}
+      title={t("system:storageDeleteDialogTitle")}
+      description={t("system:storageDeleteDialogDescription", {
+        // The quarantine path comes from the API — interpolated, never translated.
+        path: entry?.quarantine_path ?? t("system:storageDeleteDialogFallbackPath"),
+      })}
       phrase="DELETE"
-      actionLabel="Delete permanently"
+      actionLabel={t("system:storageDeletePermanently")}
       actionTestId="storage-quarantine-delete-confirm"
       destructive
     />
@@ -124,18 +149,22 @@ export function QuarantinePurgeDialog({
   eligibleCount: number;
   protectedCount: number;
 }) {
+  const { t } = useTranslation();
   const eligible = scope === "eligible";
+  // Two independent counts cannot share one `count`, so this is two plural
+  // messages joined — not one message with a hand-written English `s`.
+  const eligibleDescription = `${t("system:storagePurgeEligibleCount", { count: eligibleCount })} ${t("system:storagePurgeProtectedCount", { count: protectedCount })}`;
   return (
     <ConfirmationDialog
       {...props}
-      title={eligible ? "Clear eligible quarantine" : "Force clear all quarantine"}
-      description={
+      title={
         eligible
-          ? `This will permanently remove ${eligibleCount} eligible item${eligibleCount === 1 ? "" : "s"}. ${protectedCount} protected item${protectedCount === 1 ? " remains" : "s remain"} until ${protectedCount === 1 ? "its" : "their"} retention deadline${protectedCount === 1 ? "" : "s"}.`
-          : "This attempts to permanently remove every quarantined item immediately and cannot be undone for entries that succeed. Failed entries may remain visible and retryable."
+          ? t("system:storageClearEligibleDialogTitle")
+          : t("system:storageForceClearDialogTitle")
       }
+      description={eligible ? eligibleDescription : t("system:storageForceClearDescription")}
       phrase={eligible ? "DELETE ELIGIBLE" : "DELETE ALL NOW"}
-      actionLabel={eligible ? "Clear eligible" : "Force clear all"}
+      actionLabel={eligible ? t("system:storageClearEligible") : t("system:storageForceClearAll")}
       actionTestId={
         eligible
           ? "storage-quarantine-clear-eligible-confirm"
diff --git a/apps/web/components/settings/system/storage/storage-maintenance-settings.tsx b/apps/web/components/settings/system/storage/storage-maintenance-settings.tsx
index 15437c3ee1..c9f882ea01 100644
--- a/apps/web/components/settings/system/storage/storage-maintenance-settings.tsx
+++ b/apps/web/components/settings/system/storage/storage-maintenance-settings.tsx
@@ -68,6 +68,7 @@ function StorageActions({
   controller: ReturnType<typeof useStorageMaintenance>;
   disabledReason?: string;
 }) {
+  const { t } = useTranslation();
   const analysisActive =
     controller.analysisJob?.state === "queued" || controller.analysisJob?.state === "running";
   const cleanupActive =
@@ -75,11 +76,8 @@ function StorageActions({
   return (
     <div className="flex min-w-0 flex-col gap-4 sm:flex-row sm:items-start sm:justify-between">
       <div className="min-w-0 sm:max-w-xl">
-        <p className="text-sm font-medium">Reclaim disk space safely</p>
-        <p className="text-xs text-muted-foreground">
-          Analyze for a read-only snapshot, or run the enabled cleanup rules when you want to
-          recover space immediately.
-        </p>
+        <p className="text-sm font-medium">{t("system:storageActionsTitle")}</p>
+        <p className="text-xs text-muted-foreground">{t("system:storageActionsDescription")}</p>
       </div>
       <div className="grid min-w-0 grid-cols-1 gap-3 sm:grid-cols-2">
         <div data-testid="storage-analyze-control">
@@ -87,7 +85,7 @@ function StorageActions({
             variant="outline"
             className="w-full sm:w-44"
             disabledReason={
-              disabledReason ?? (analysisActive ? "Storage analysis is still running." : undefined)
+              disabledReason ?? (analysisActive ? t("system:storageAnalysisRunning") : undefined)
             }
             onClick={() => void controller.analyze()}
             data-testid="storage-analyze"
@@ -95,10 +93,10 @@ function StorageActions({
           >
             <StorageJobButtonContent
               job={controller.analysisJob}
-              idleLabel="Analyze"
-              activeLabel="Analyzing..."
-              successLabel="Analysis complete"
-              failedLabel="Analysis failed"
+              idleLabel={t("system:storageAnalyze")}
+              activeLabel={t("system:storageAnalyzing")}
+              successLabel={t("system:storageAnalysisComplete")}
+              failedLabel={t("system:storageAnalysisFailed")}
               idleIcon={<IconRefresh className="size-4" />}
             />
           </StorageActionButton>
@@ -107,7 +105,7 @@ function StorageActions({
           <StorageActionButton
             className="w-full sm:w-44"
             disabledReason={
-              disabledReason ?? (cleanupActive ? "Storage cleanup is still running." : undefined)
+              disabledReason ?? (cleanupActive ? t("system:storageCleanupRunning") : undefined)
             }
             onClick={() => void controller.runNow()}
             data-testid="storage-run-now"
@@ -115,10 +113,10 @@ function StorageActions({
           >
             <StorageJobButtonContent
               job={controller.cleanupJob}
-              idleLabel="Run now"
-              activeLabel="Cleaning..."
-              successLabel="Cleanup complete"
-              failedLabel="Cleanup failed"
+              idleLabel={t("system:storageRunNow")}
+              activeLabel={t("system:storageCleaning")}
+              successLabel={t("system:storageCleanupComplete")}
+              failedLabel={t("system:storageCleanupFailed")}
               idleIcon={<IconPlayerPlay className="size-4" />}
             />
           </StorageActionButton>
@@ -133,6 +131,7 @@ function StorageActionFeedback({
 }: {
   controller: ReturnType<typeof useStorageMaintenance>;
 }) {
+  const { t } = useTranslation();
   if (controller.busy) {
     return (
       <StorageBusyFeedback busy={controller.busy} onRunAnyway={() => void controller.runAnyway()} />
@@ -142,7 +141,7 @@ function StorageActionFeedback({
   return (
     <Alert variant="destructive" data-testid="storage-error">
       <IconAlertTriangle className="size-4" />
-      <AlertTitle>Storage action failed</AlertTitle>
+      <AlertTitle>{t("system:storageActionFailed")}</AlertTitle>
       <AlertDescription className="break-words">{controller.error}</AlertDescription>
     </Alert>
   );
@@ -155,27 +154,29 @@ function StorageBusyFeedback({
   busy: StorageBusyState;
   onRunAnyway: () => void;
 }) {
+  const { t } = useTranslation();
   return (
     <Alert variant="destructive" data-testid="storage-busy">
       <IconAlertTriangle className="size-4" />
-      <AlertTitle>Storage cleanup found active Kandev work</AlertTitle>
+      <AlertTitle>{t("system:storageBusyTitle")}</AlertTitle>
       <AlertDescription className="break-words">
-        <p>Cleanup may disrupt the following work:</p>
+        <p>{t("system:storageBusyIntro")}</p>
         <ul className="mt-2 list-disc space-y-1 pl-5">
+          {/* Resource labels are rendered by the API, not the catalog. */}
           {busy.resources.map((resource) => (
             <li key={resource.kind}>{resource.label}</li>
           ))}
         </ul>
         {busy.forceAvailable && (
           <>
-            <p className="mt-3">Running cleanup anyway may disrupt this active work.</p>
+            <p className="mt-3">{t("system:storageBusyForceHint")}</p>
             <StorageActionButton
               variant="outline"
               className="mt-3 w-full sm:w-auto"
               onClick={onRunAnyway}
               data-testid="storage-run-anyway"
             >
-              <IconPlayerPlay className="size-4" /> Run anyway
+              <IconPlayerPlay className="size-4" /> {t("system:storageRunAnyway")}
             </StorageActionButton>
           </>
         )}
@@ -197,8 +198,8 @@ function policyBlockedReason(
   action: ReturnType<typeof useStorageMaintenance>["pendingAction"],
   loading: boolean,
 ) {
-  if (action === "adopt") return t("settings:storageAdoptionPending");
-  if (loading) return t("settings:storagePolicyLoadingBlock");
+  if (action === "adopt") return t("system:storageAdoptionPending");
+  if (loading) return t("system:storagePolicyLoadingBlock");
   return undefined;
 }
 
@@ -206,7 +207,7 @@ function storageActionDisabledReason(
   t: (key: string) => string,
   action: ReturnType<typeof useStorageMaintenance>["pendingAction"],
 ) {
-  if (action) return t("settings:storageActionPending");
+  if (action) return t("system:storageActionPending");
   return undefined;
 }
 
@@ -265,7 +266,7 @@ function StoragePolicyState({ loading, error }: { loading: boolean; error?: stri
     <Card data-testid="storage-policy-state">
       <CardContent className="flex items-center gap-2 py-8 text-sm text-muted-foreground">
         {loading && <Spinner className="size-4" data-testid="storage-policy-spinner" />}
-        <span>{loading ? t("settings:loading") : t("settings:storageSectionUnavailable")}</span>
+        <span>{loading ? t("settings:loading") : t("system:storageSectionUnavailable")}</span>
         {error && <span className="break-words text-destructive">{error}</span>}
       </CardContent>
     </Card>
diff --git a/apps/web/components/settings/system/storage/storage-overview-card.test.tsx b/apps/web/components/settings/system/storage/storage-overview-card.test.tsx
index 3aa6ddbaad..a5add91926 100644
--- a/apps/web/components/settings/system/storage/storage-overview-card.test.tsx
+++ b/apps/web/components/settings/system/storage/storage-overview-card.test.tsx
@@ -1,6 +1,7 @@
 import { cleanup, fireEvent, render, screen } from "@testing-library/react";
 import { TooltipProvider } from "@kandev/ui/tooltip";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { formatDateTime } from "@/lib/i18n/formats";
 import type { StorageOverviewResponse } from "@/lib/types/system";
 import { StorageOverviewCard } from "./storage-overview-card";
 
@@ -64,7 +65,11 @@ describe("StorageOverviewCard", () => {
     const timestamp = screen.getByText("Last analyzed 2m ago");
     expect(timestamp.tagName).toBe("TIME");
     expect(timestamp.getAttribute("dateTime")).toBe(analyzedAt);
-    expect(timestamp.getAttribute("title")).toBe(new Date(analyzedAt).toLocaleString());
+    // The absolute time follows the active i18next locale, not the browser's.
+    expect(timestamp.getAttribute("title")).toBe(formatDateTime(analyzedAt));
+    expect(timestamp.getAttribute("aria-label")).toBe(
+      `Last analyzed ${formatDateTime(analyzedAt)}`,
+    );
     vi.useRealTimers();
   });
 
diff --git a/apps/web/components/settings/system/storage/storage-overview-card.tsx b/apps/web/components/settings/system/storage/storage-overview-card.tsx
index 5104a2becc..477fb383ef 100644
--- a/apps/web/components/settings/system/storage/storage-overview-card.tsx
+++ b/apps/web/components/settings/system/storage/storage-overview-card.tsx
@@ -4,16 +4,24 @@ import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@kand
 import { Spinner } from "@kandev/ui/spinner";
 import { IconChartPie, IconTrash } from "@tabler/icons-react";
 import { useTranslation } from "react-i18next";
+import { formatDateTime, formatRelative } from "@/lib/i18n/formats";
 import type {
   StorageMaintenanceSettings,
   StorageOverviewResponse,
   StorageQuarantineSummary,
 } from "@/lib/types/system";
-import { formatRelativeTime } from "@/lib/utils";
 import { StorageActionButton } from "./storage-action-button";
 import { formatGigabytes } from "./storage-units";
 import { storageAnalysisTotal } from "./storage-totals";
 
+/**
+ * Copy for the resource rows is built in plain functions rather than JSX, so
+ * `i18next/no-literal-string` (mode `jsx-only`) never inspected any of it. Each
+ * takes `t` from the caller's `useTranslation` instead of importing the
+ * module-level one, so the rows re-render on a locale switch.
+ */
+type Translate = (key: string, options?: Record<string, unknown>) => string;
+
 interface Props {
   overview: StorageOverviewResponse | null;
   settings?: StorageMaintenanceSettings;
@@ -32,78 +40,92 @@ interface StorageResource {
 }
 
 function goCacheDisabledReason(
+  t: Translate,
   overview: StorageOverviewResponse,
   pendingReason?: string,
   settings?: StorageMaintenanceSettings,
 ) {
   if (pendingReason) return pendingReason;
   if (overview.summary.go_cache.owned !== true) {
-    return "Only a Kandev-owned Go build cache can be cleaned.";
+    return t("system:storageGoCacheNotOwned");
   }
   if (
     (overview.summary.go_cache.size_bytes ?? 0) <=
     (settings ?? overview.settings).go_cache.max_bytes
   ) {
-    return "The Go build cache is below its configured size limit.";
+    return t("system:storageGoCacheBelowLimit");
   }
   return undefined;
 }
 
-function quarantineResource(summary: StorageQuarantineSummary): StorageResource {
+function quarantineResource(t: Translate, summary: StorageQuarantineSummary): StorageResource {
   if (summary.available === false) {
     return {
       id: "quarantine",
-      label: "Quarantined resources",
-      value: "Unavailable",
-      detail: "Quarantine usage could not be measured",
+      label: t("system:storageQuarantinedResources"),
+      value: t("system:storageUnavailableValue"),
+      detail: t("system:storageQuarantineUnmeasured"),
       warning: summary.warning,
     };
   }
   return {
     id: "quarantine",
-    label: "Quarantined resources",
+    label: t("system:storageQuarantinedResources"),
     value: formatGigabytes(summary.size_bytes),
-    detail: `${summary.count} items moved aside for recovery before permanent deletion`,
+    detail: t("system:storageQuarantineMovedAside", { count: summary.count }),
   };
 }
 
 function dockerMeasurement(
+  t: Translate,
   available: boolean,
   value: string,
   detail: string,
 ): Pick<StorageResource, "value" | "detail"> {
   if (!available) {
-    return { value: "Unavailable", detail: "Docker usage could not be measured" };
+    return {
+      value: t("system:storageUnavailableValue"),
+      detail: t("system:storageDockerUnmeasured"),
+    };
   }
   return { value, detail };
 }
 
-function storageResources(overview: StorageOverviewResponse): StorageResource[] {
+function storageResources(t: Translate, overview: StorageOverviewResponse): StorageResource[] {
   const { summary } = overview;
   const dockerWarning = summary.docker.warnings?.join(" · ");
+  // The Docker host is an address, not copy; the fallback naming the default is.
+  const dockerHost = overview.capabilities.docker_host || t("system:storageDefaultDockerHost");
   return [
     {
       id: "workspaces",
-      label: "Task workspaces",
+      label: t("system:storageTaskWorkspaces"),
       value: formatGigabytes(summary.workspaces.total_bytes ?? 0),
-      detail: `${formatGigabytes(summary.workspaces.candidate_bytes ?? 0)} reclaimable after the grace period · ${formatGigabytes(summary.workspaces.active_bytes ?? 0)} active`,
+      detail: t("system:storageWorkspacesDetail", {
+        reclaimable: formatGigabytes(summary.workspaces.candidate_bytes ?? 0),
+        active: formatGigabytes(summary.workspaces.active_bytes ?? 0),
+      }),
       warning: summary.workspaces.warning,
     },
-    quarantineResource(summary.quarantine),
+    quarantineResource(t, summary.quarantine),
     {
       id: "managed-containers",
-      label: "Kandev containers",
+      label: t("system:storageKandevContainers"),
       ...dockerMeasurement(
+        t,
         summary.docker.available,
         formatGigabytes(summary.docker.managed_container_bytes ?? 0),
-        `${summary.docker.managed_container_count ?? 0} managed containers`,
+        t("system:storageManagedContainerCount", {
+          count: summary.docker.managed_container_count ?? 0,
+        }),
       ),
       warning: dockerWarning,
     },
     {
       id: "go-cache",
-      label: "Go build cache",
+      label: t("system:storageGoBuildCache"),
       value: formatGigabytes(summary.go_cache.size_bytes ?? 0),
+      // A filesystem path from the API — never routed through the catalog.
       detail: summary.go_cache.path ?? overview.capabilities.managed_go_cache_path,
       warning: summary.go_cache.warning,
     },
@@ -111,7 +133,7 @@ function storageResources(overview: StorageOverviewResponse): StorageResource[]
       ? [
           {
             id: "unmanaged-go-cache",
-            label: "User Go build cache",
+            label: t("system:storageUserGoBuildCache"),
             value: formatGigabytes(summary.go_cache.unmanaged_size_bytes ?? 0),
             detail: summary.go_cache.unmanaged_path,
           },
@@ -119,31 +141,34 @@ function storageResources(overview: StorageOverviewResponse): StorageResource[]
       : []),
     {
       id: "docker-image-layers",
-      label: "Docker image layers",
+      label: t("system:storageDockerImageLayers"),
       ...dockerMeasurement(
+        t,
         summary.docker.available,
         formatGigabytes(summary.docker.image_layer_bytes ?? 0),
-        overview.capabilities.docker_host || "Default Docker host",
+        dockerHost,
       ),
       warning: dockerWarning,
     },
     {
       id: "docker-build-cache",
-      label: "Docker build cache",
+      label: t("system:storageDockerBuildCache"),
       ...dockerMeasurement(
+        t,
         summary.docker.available,
         formatGigabytes(summary.docker.build_cache_bytes),
-        overview.capabilities.docker_host || "Default Docker host",
+        dockerHost,
       ),
       warning: dockerWarning,
     },
     {
       id: "docker-unused-images",
-      label: "Unused Docker images",
+      label: t("system:storageUnusedDockerImages"),
       ...dockerMeasurement(
+        t,
         summary.docker.available,
         formatGigabytes(summary.docker.unused_image_bytes),
-        "Unused by every container and older than the configured age",
+        t("system:storageUnusedImagesDetail"),
       ),
       warning: dockerWarning,
     },
@@ -157,6 +182,7 @@ interface ResourceRowProps {
 }
 
 function ResourceRow({ resource, goCacheCleanupDisabledReason, onRunGoCache }: ResourceRowProps) {
+  const { t } = useTranslation();
   return (
     <AccordionItem value={resource.id} data-testid={`storage-resource-${resource.id}`}>
       <AccordionTrigger
@@ -179,7 +205,7 @@ function ResourceRow({ resource, goCacheCleanupDisabledReason, onRunGoCache }: R
             onClick={onRunGoCache}
             data-testid="storage-go-cache-clean"
           >
-            <IconTrash className="size-4" /> Clean Go cache
+            <IconTrash className="size-4" /> {t("system:storageCleanGoCache")}
           </StorageActionButton>
         )}
       </AccordionContent>
@@ -203,7 +229,7 @@ export function StorageOverviewCard({
         <CardContent className="flex items-center gap-2 py-8 text-sm text-muted-foreground">
           {isLoading && <Spinner className="size-4" data-testid="storage-overview-spinner" />}
           <span>
-            {isLoading ? t("settings:storageLoadingData") : t("settings:storageSectionUnavailable")}
+            {isLoading ? t("system:storageLoadingData") : t("system:storageSectionUnavailable")}
           </span>
           {error && <span className="break-words text-destructive">{error}</span>}
         </CardContent>
@@ -211,46 +237,45 @@ export function StorageOverviewCard({
     );
   }
   const { summary } = overview;
-  const analyzedAt = new Date(overview.analyzed_at).toLocaleString();
-  const cleanupDisabledReason = goCacheDisabledReason(overview, disabledReason, settings);
-  const resources = storageResources(overview);
+  const analyzedAt = formatDateTime(overview.analyzed_at);
+  const cleanupDisabledReason = goCacheDisabledReason(t, overview, disabledReason, settings);
+  const resources = storageResources(t, overview);
   const total = storageAnalysisTotal(summary);
   return (
     <Card className="min-w-0" data-testid="storage-overview-card">
       <CardHeader>
         <CardTitle className="flex items-center gap-2 text-base">
-          <IconChartPie className="size-4" /> Storage analysis
+          <IconChartPie className="size-4" /> {t("system:storageAnalysisTitle")}
           {isLoading && <Spinner className="size-4" data-testid="storage-overview-spinner" />}
-          {!summary.docker.available && <Badge variant="outline">Docker unavailable</Badge>}
+          {!summary.docker.available && (
+            <Badge variant="outline">{t("system:storageDockerUnavailableBadge")}</Badge>
+          )}
         </CardTitle>
-        <CardDescription>
-          A read-only breakdown of current usage and reclaimable space. Run Analyze occasionally to
-          refresh these estimates; it never deletes or moves anything.
-        </CardDescription>
+        <CardDescription>{t("system:storageAnalysisDescription")}</CardDescription>
         <time
           className="text-xs text-muted-foreground"
           dateTime={overview.analyzed_at}
           title={analyzedAt}
-          aria-label={`Last analyzed ${analyzedAt}`}
+          aria-label={t("system:storageLastAnalyzed", { time: analyzedAt })}
         >
-          Last analyzed {formatRelativeTime(overview.analyzed_at)}
+          {t("system:storageLastAnalyzed", { time: formatRelative(overview.analyzed_at) })}
         </time>
         <div
           className="flex flex-wrap items-center gap-2 text-xs"
           data-testid="storage-analysis-total"
         >
           <span className="font-medium">
-            {t("settings:storageTotalCounted", { size: formatGigabytes(total.bytes) })}
+            {t("system:storageTotalCounted", { size: formatGigabytes(total.bytes) })}
           </span>
           {total.partial && (
             <Badge variant="outline" data-testid="storage-analysis-total-partial">
-              {t("settings:storageTotalPartial")}
+              {t("system:storageTotalPartial")}
             </Badge>
           )}
         </div>
         {error && (
           <p className="break-words text-xs text-destructive" data-testid="storage-overview-error">
-            {t("settings:storageSectionUnavailable")}: {error}
+            {t("system:storageSectionUnavailable")}: {error}
           </p>
         )}
       </CardHeader>
diff --git a/apps/web/components/settings/system/storage/storage-policy-card.test.tsx b/apps/web/components/settings/system/storage/storage-policy-card.test.tsx
index d83ac98d1a..deb3e1b55c 100644
--- a/apps/web/components/settings/system/storage/storage-policy-card.test.tsx
+++ b/apps/web/components/settings/system/storage/storage-policy-card.test.tsx
@@ -38,6 +38,7 @@ const testIds = {
   dockerImagesUnused: "storage-docker-unused-images-hours",
 };
 const ADOPTION_PATH_TEST_ID = "storage-go-cache-adopt-path";
+const ADOPT_BUTTON_TEST_ID = "storage-go-cache-adopt";
 
 afterEach(cleanup);
 
@@ -213,7 +214,7 @@ describe("StoragePolicyCard interactions", () => {
       "storage-quarantine-retention",
       testIds.goCacheMax,
       "storage-go-cache-adopt-path",
-      "storage-go-cache-adopt",
+      ADOPT_BUTTON_TEST_ID,
       "storage-docker-dedicated",
       "storage-docker-build-cache",
       testIds.dockerBuildCacheKeep,
@@ -306,3 +307,51 @@ describe("StoragePolicyCard interactions", () => {
     expect(screen.getAllByLabelText(/^More information about /)).toHaveLength(16);
   });
 });
+
+// The adoption button picks one of three reasons and the managed-cache row
+// interpolates a path. Both are now catalog lookups rather than literals, so a
+// missing key or a renamed placeholder degrades to a raw key or a dropped path
+// rather than failing anything else.
+describe("Go cache section copy", () => {
+  const enabledGoCache = { ...settings, go_cache: { ...settings.go_cache, enabled: true } };
+
+  /**
+   * The reason renders inside a Radix tooltip, which jsdom will not open from a
+   * synthetic mouse event — focus the wrapper span the disabled button sits in,
+   * as apps/web/CLAUDE.md prescribes for this shape.
+   */
+  async function adoptionDisabledReason(): Promise<string> {
+    const trigger = screen.getByTestId(ADOPT_BUTTON_TEST_ID).parentElement;
+    if (!trigger) throw new Error("adopt button has no tooltip trigger");
+    fireEvent.focus(trigger);
+    const tooltip = await screen.findAllByRole("tooltip");
+    return tooltip[0]?.textContent ?? "";
+  }
+
+  it("explains each reason adoption is unavailable", async () => {
+    renderCard(true, vi.fn(), enabledGoCache, enabledGoCache);
+    expect(await adoptionDisabledReason()).toBe("Wait for the current storage action to finish.");
+
+    cleanup();
+    renderCard();
+    expect(await adoptionDisabledReason()).toBe("Enable the managed Go cache first.");
+
+    cleanup();
+    renderCard(false, vi.fn(), enabledGoCache, enabledGoCache);
+    expect(await adoptionDisabledReason()).toBe("Enter an absolute cache path first.");
+
+    // A whitespace-only path is still no path.
+    fireEvent.change(screen.getByTestId(ADOPTION_PATH_TEST_ID), { target: { value: "   " } });
+    expect(await adoptionDisabledReason()).toBe("Enter an absolute cache path first.");
+
+    fireEvent.change(screen.getByTestId(ADOPTION_PATH_TEST_ID), { target: { value: "/tmp/go" } });
+    expect((screen.getByTestId(ADOPT_BUTTON_TEST_ID) as HTMLButtonElement).disabled).toBe(false);
+  });
+
+  it("interpolates the managed cache path rather than concatenating it", () => {
+    renderCard();
+    expect(
+      screen.getByText(`New host-local executions use ${capabilities.managed_go_cache_path}.`),
+    ).toBeTruthy();
+  });
+});
diff --git a/apps/web/components/settings/system/storage/storage-policy-card.tsx b/apps/web/components/settings/system/storage/storage-policy-card.tsx
index 2ddb8ebb62..4d182c55aa 100644
--- a/apps/web/components/settings/system/storage/storage-policy-card.tsx
+++ b/apps/web/components/settings/system/storage/storage-policy-card.tsx
@@ -4,6 +4,7 @@ import { useEffect, useRef, useState } from "react";
 import { Input } from "@kandev/ui/input";
 import { Label } from "@kandev/ui/label";
 import { Switch } from "@kandev/ui/switch";
+import { useTranslation } from "react-i18next";
 import { settingsWithDockerAcknowledgement } from "@/hooks/domains/system/use-storage-maintenance";
 import type { StorageCapabilities, StorageMaintenanceSettings } from "@/lib/types/system";
 import { DedicatedDockerDialog, ExternalGoCacheDialog } from "./storage-confirmation-dialogs";
@@ -35,6 +36,7 @@ function settingIsDirty<T>(
 }
 
 function ScheduleSection({ settings, savedSettings, pending, onChange }: PolicySectionProps) {
+  const { t } = useTranslation();
   const enabledDirty = settingIsDirty(settings, savedSettings, (value) => value.enabled);
   const intervalDirty = settingIsDirty(
     settings,
@@ -45,20 +47,20 @@ function ScheduleSection({ settings, savedSettings, pending, onChange }: PolicyS
   return (
     <PolicySection
       sectionId="schedule"
-      title="Schedule"
-      description="Controls when automatic maintenance is allowed to start. Manual actions remain available when scheduling is off."
+      title={t("system:storageScheduleTitle")}
+      description={t("system:storageScheduleDescription")}
       isDirty={enabledDirty || intervalDirty || idleDirty}
     >
       <SettingRow
-        title="Scheduled maintenance"
-        description="Periodically reclaim disk space using the enabled resource rules."
-        help="When enabled, Kandev checks this policy at the configured interval and starts only after Kandev has been idle for the required period. Turning it off does not disable Analyze or Run now."
+        title={t("system:storageScheduledMaintenance")}
+        description={t("system:storageScheduledMaintenanceDescription")}
+        help={t("system:storageScheduledMaintenanceHelp")}
         control={
           <Switch
             checked={settings.enabled}
             disabled={pending}
             onCheckedChange={(enabled) => onChange({ ...settings, enabled })}
-            aria-label="Scheduled maintenance"
+            aria-label={t("system:storageScheduledMaintenance")}
             data-testid="storage-scheduling-enabled"
             data-settings-dirty={enabledDirty}
           />
@@ -66,8 +68,8 @@ function ScheduleSection({ settings, savedSettings, pending, onChange }: PolicyS
       />
       <div className="grid min-w-0 grid-cols-1 gap-3 pt-3 sm:grid-cols-2">
         <NumberField
-          label="Check every (hours)"
-          help="How often Kandev checks whether scheduled maintenance is due. A check that finds Kandev busy is skipped and tried again at the next interval."
+          label={t("system:storageCheckIntervalLabel")}
+          help={t("system:storageCheckIntervalHelp")}
           value={settings.check_interval_hours}
           min={1}
           max={168}
@@ -77,8 +79,8 @@ function ScheduleSection({ settings, savedSettings, pending, onChange }: PolicyS
           isDirty={intervalDirty}
         />
         <NumberField
-          label="Require idle for (minutes)"
-          help="Scheduled cleanup starts only after no task, shell command, test, setup, cleanup, or image build has used managed resources for this long. Run now does not wait for this timer, but it still refuses to run while resources are active."
+          label={t("system:storageIdleLabel")}
+          help={t("system:storageIdleHelp")}
           value={settings.idle_for_minutes}
           min={1}
           max={1440}
@@ -93,6 +95,7 @@ function ScheduleSection({ settings, savedSettings, pending, onChange }: PolicyS
 }
 
 function WorkspaceSection({ settings, savedSettings, pending, onChange }: PolicySectionProps) {
+  const { t } = useTranslation();
   const workspacesDirty = settingIsDirty(
     settings,
     savedSettings,
@@ -107,28 +110,28 @@ function WorkspaceSection({ settings, savedSettings, pending, onChange }: Policy
   return (
     <PolicySection
       sectionId="workspaces"
-      title="Workspaces and containers"
-      description="Reclaim resources that Kandev can positively identify as no longer in use."
+      title={t("system:storageWorkspacesTitle")}
+      description={t("system:storageWorkspacesDescription")}
       isDirty={workspacesDirty || graceDirty || containersDirty}
     >
       <SettingRow
-        title="Orphan task workspaces"
-        description="Move confirmed orphan workspaces to quarantine."
-        help="Kandev only selects a task workspace after inventory confirms that no active task, environment, session, or protected worktree uses it. The workspace is moved to quarantine first, where it can be restored before permanent deletion."
+        title={t("system:storageOrphanWorkspaces")}
+        description={t("system:storageOrphanWorkspacesDescription")}
+        help={t("system:storageOrphanWorkspacesHelp")}
         control={
           <Switch
             checked={settings.workspaces.enabled}
             disabled={pending}
             onCheckedChange={(enabled) => onChange({ ...settings, workspaces: { enabled } })}
-            aria-label="Clean orphan task workspaces"
+            aria-label={t("system:storageCleanOrphanWorkspacesAria")}
             data-settings-dirty={workspacesDirty}
           />
         }
       />
       <div className="grid min-w-0 grid-cols-1 gap-3 py-3 sm:grid-cols-2">
         <NumberField
-          label="Wait before orphaning (hours)"
-          help="A workspace must be unused for at least this long before it can be classified as an orphan. Increasing this value keeps old workspaces longer before they enter quarantine."
+          label={t("system:storageOrphanGraceLabel")}
+          help={t("system:storageOrphanGraceHelp")}
           value={settings.orphan_grace_hours}
           min={24}
           max={2160}
@@ -139,15 +142,15 @@ function WorkspaceSection({ settings, savedSettings, pending, onChange }: Policy
         />
       </div>
       <SettingRow
-        title="Kandev containers"
-        description="Remove stopped, unused containers created and labeled by Kandev."
-        help="Only stopped containers labeled as Kandev-managed are considered, and inventory must confirm they are no longer needed. Running containers and unrelated Docker containers are never removed by this option."
+        title={t("system:storageKandevContainers")}
+        description={t("system:storageContainersDescription")}
+        help={t("system:storageContainersHelp")}
         control={
           <Switch
             checked={settings.kandev_containers.enabled}
             disabled={pending}
             onCheckedChange={(enabled) => onChange({ ...settings, kandev_containers: { enabled } })}
-            aria-label="Clean Kandev containers"
+            aria-label={t("system:storageCleanContainersAria")}
             data-settings-dirty={containersDirty}
           />
         }
@@ -169,22 +172,22 @@ function AdoptionField({
   pending: boolean;
   enabled: boolean;
 }) {
+  const { t } = useTranslation();
   let disabledReason: string | undefined;
-  if (pending) disabledReason = "Wait for the current storage action to finish.";
-  else if (!enabled) disabledReason = "Enable the managed Go cache first.";
-  else if (!path.trim()) disabledReason = "Enter an absolute cache path first.";
+  if (pending) disabledReason = t("system:storageActionPending");
+  else if (!enabled) disabledReason = t("system:storageEnableGoCacheFirst");
+  else if (!path.trim()) disabledReason = t("system:storageEnterCachePathFirst");
+  const fieldLabel = t("system:storageExternalGoCache");
   return (
     <div className="min-w-0 space-y-2 pt-3">
       <div className="flex items-center gap-1">
-        <Label htmlFor="storage-adoption-path">External Go cache</Label>
-        <StorageSettingHelp label="External Go cache">
-          Adoption gives Kandev explicit permission to rotate this existing cache. Kandev never
-          cleans a default user cache or another path unless you adopt that exact absolute path and
-          confirm the destructive access.
+        <Label htmlFor="storage-adoption-path">{fieldLabel}</Label>
+        <StorageSettingHelp label={fieldLabel}>
+          {t("system:storageExternalGoCacheHelp")}
         </StorageSettingHelp>
       </div>
       <p className="text-xs text-muted-foreground">
-        Optionally allow Kandev to maintain an existing host cache outside its managed path.
+        {t("system:storageExternalGoCacheDescription")}
       </p>
       <div className="flex min-w-0 flex-col gap-2 sm:flex-row">
         <Input
@@ -202,7 +205,7 @@ function AdoptionField({
           onClick={onOpen}
           data-testid="storage-go-cache-adopt"
         >
-          Adopt cache
+          {t("system:storageAdoptCache")}
         </StorageActionButton>
       </div>
     </div>
@@ -223,6 +226,7 @@ function GoCacheSection({
   setAdoptionPath: (path: string) => void;
   onOpenAdoption: () => void;
 }) {
+  const { t } = useTranslation();
   const enabledDirty = settingIsDirty(settings, savedSettings, (value) => value.go_cache.enabled);
   const maxBytesDirty = settingIsDirty(
     settings,
@@ -232,14 +236,16 @@ function GoCacheSection({
   return (
     <PolicySection
       sectionId="go-cache"
-      title="Go build cache"
-      description="Use and trim a Kandev-owned cache for new host-local Go executions."
+      title={t("system:storageGoBuildCache")}
+      description={t("system:storageGoCacheSectionDescription")}
       isDirty={enabledDirty || maxBytesDirty}
     >
       <SettingRow
-        title="Managed Go cache"
-        description={`New host-local executions use ${capabilities.managed_go_cache_path}.`}
-        help="When enabled, Kandev gives new local task processes a dedicated Go build cache and may rotate it during maintenance when it exceeds the maximum. Turning this off stops using the managed cache for new executions but does not delete it."
+        title={t("system:storageManagedGoCache")}
+        description={t("system:storageManagedGoCacheDescription", {
+          path: capabilities.managed_go_cache_path,
+        })}
+        help={t("system:storageManagedGoCacheHelp")}
         control={
           <Switch
             checked={settings.go_cache.enabled}
@@ -247,7 +253,7 @@ function GoCacheSection({
             onCheckedChange={(enabled) =>
               onChange({ ...settings, go_cache: { ...settings.go_cache, enabled } })
             }
-            aria-label="Enable managed Go cache"
+            aria-label={t("system:storageEnableManagedGoCacheAria")}
             data-testid="storage-go-cache-enabled"
             data-settings-dirty={enabledDirty}
           />
@@ -255,8 +261,8 @@ function GoCacheSection({
       />
       <div className="grid min-w-0 grid-cols-1 gap-3 pt-3 sm:grid-cols-2">
         <NumberField
-          label="Maximum cache size (GB)"
-          help="This is a cleanup trigger, not a hard quota. The cache may grow past this size while tasks are active. Maintenance rotates the owned cache into quarantine and recreates an empty cache after the limit is exceeded."
+          label={t("system:storageGoCacheMaxLabel")}
+          help={t("system:storageGoCacheMaxHelp")}
           value={bytesToGigabytes(settings.go_cache.max_bytes)}
           min={1}
           disabled={pending || !settings.go_cache.enabled}
@@ -296,15 +302,16 @@ function DockerBuildCacheSettings({
   disabledReason?: string;
   updateDocker: (docker: DockerSettings) => void;
 }) {
+  const { t } = useTranslation();
   const enabledDirty = docker.build_cache_enabled !== savedDocker.build_cache_enabled;
   const keepBytesDirty = docker.build_cache_keep_bytes !== savedDocker.build_cache_keep_bytes;
   const unusedHoursDirty = docker.build_cache_unused_hours !== savedDocker.build_cache_unused_hours;
   return (
     <>
       <SettingRow
-        title="Docker build cache"
-        description="Remove old build cache while retaining the configured amount."
-        help="Uses Docker's age and storage filters to remove old build cache. It does not run docker system prune, does not remove volumes globally, and remains disabled until the dedicated-daemon acknowledgment is confirmed."
+        title={t("system:storageDockerBuildCache")}
+        description={t("system:storageDockerBuildCacheDescription")}
+        help={t("system:storageDockerBuildCacheHelp")}
         control={
           <Switch
             checked={docker.build_cache_enabled}
@@ -312,7 +319,7 @@ function DockerBuildCacheSettings({
             onCheckedChange={(build_cache_enabled) =>
               updateDocker({ ...docker, build_cache_enabled })
             }
-            aria-label="Clean Docker build cache"
+            aria-label={t("system:storageCleanDockerBuildCacheAria")}
             data-testid="storage-docker-build-cache"
             data-settings-dirty={enabledDirty}
           />
@@ -320,8 +327,8 @@ function DockerBuildCacheSettings({
       />
       <div className="grid min-w-0 grid-cols-1 gap-3 py-3 sm:grid-cols-2">
         <NumberField
-          label="Build cache to retain (GB)"
-          help="Docker keeps approximately this much build cache when pruning eligible records. A larger value preserves more reusable build layers but reclaims less disk space."
+          label={t("system:storageBuildCacheKeepLabel")}
+          help={t("system:storageBuildCacheKeepHelp")}
           value={bytesToGigabytes(docker.build_cache_keep_bytes)}
           min={1}
           disabled={Boolean(disabledReason) || !docker.build_cache_enabled}
@@ -335,8 +342,8 @@ function DockerBuildCacheSettings({
           isDirty={keepBytesDirty}
         />
         <NumberField
-          label="Build cache must be unused for (hours)"
-          help="Only build cache records older than this unused-age threshold are eligible. Increasing it protects recent build layers for longer."
+          label={t("system:storageBuildCacheUnusedLabel")}
+          help={t("system:storageBuildCacheUnusedHelp")}
           value={docker.build_cache_unused_hours}
           min={24}
           max={2562047}
@@ -363,14 +370,15 @@ function DockerImageSettings({
   disabledReason?: string;
   updateDocker: (docker: DockerSettings) => void;
 }) {
+  const { t } = useTranslation();
   const enabledDirty = docker.unused_images_enabled !== savedDocker.unused_images_enabled;
   const hoursDirty = docker.unused_images_hours !== savedDocker.unused_images_hours;
   return (
     <>
       <SettingRow
-        title="Unused Docker images"
-        description="Remove old images that no container uses."
-        help="Removes an image only when no running or stopped container references it and it is older than the configured age. This is daemon-wide and therefore requires the dedicated-daemon acknowledgment."
+        title={t("system:storageUnusedDockerImages")}
+        description={t("system:storageUnusedImagesDescription")}
+        help={t("system:storageUnusedImagesHelp")}
         control={
           <Switch
             checked={docker.unused_images_enabled}
@@ -378,7 +386,7 @@ function DockerImageSettings({
             onCheckedChange={(unused_images_enabled) =>
               updateDocker({ ...docker, unused_images_enabled })
             }
-            aria-label="Clean unused Docker images"
+            aria-label={t("system:storageCleanUnusedImagesAria")}
             data-testid="storage-docker-unused-images"
             data-settings-dirty={enabledDirty}
           />
@@ -386,8 +394,8 @@ function DockerImageSettings({
       />
       <div className="grid min-w-0 grid-cols-1 gap-3 pt-3 sm:grid-cols-2">
         <NumberField
-          label="Image must be unused for (hours)"
-          help="An image must be unused by every container and older than this age before Kandev can remove it. Increasing the value keeps old images available for longer."
+          label={t("system:storageUnusedImagesHoursLabel")}
+          help={t("system:storageUnusedImagesHoursHelp")}
           value={docker.unused_images_hours}
           min={24}
           max={2562047}
@@ -409,32 +417,33 @@ function DockerSection({
   onChange,
   onOpenDedicated,
 }: PolicySectionProps & { onOpenDedicated: () => void }) {
+  const { t } = useTranslation();
   const dockerDirty = JSON.stringify(settings.docker) !== JSON.stringify(savedSettings.docker);
   const dedicatedDirty =
     settings.docker.dedicated_daemon_acknowledged !==
     savedSettings.docker.dedicated_daemon_acknowledged;
   const unavailable = capabilities.docker_available
     ? undefined
-    : "Docker is unavailable on the configured host.";
+    : t("system:storageDockerUnavailable");
   const disabledReason =
-    (pending ? "Wait for the current storage action to finish." : undefined) ??
+    (pending ? t("system:storageActionPending") : undefined) ??
     unavailable ??
     (!settings.docker.dedicated_daemon_acknowledged
-      ? "Acknowledge a dedicated Docker daemon first."
+      ? t("system:storageAcknowledgeDedicatedFirst")
       : undefined);
   const updateDocker = (docker: StorageMaintenanceSettings["docker"]) =>
     onChange({ ...settings, docker });
   return (
     <PolicySection
       sectionId="docker"
-      title="Docker cleanup"
-      description="Optional daemon-wide cleanup. Enable it only when this Docker daemon is dedicated to Kandev."
+      title={t("system:storageDockerTitle")}
+      description={t("system:storageDockerDescription")}
       isDirty={dockerDirty}
     >
       <SettingRow
-        title="Dedicated Docker daemon"
-        description="Confirm that unrelated workloads do not share this Docker daemon."
-        help="Build cache and image ownership cannot be attributed reliably to Kandev. This acknowledgment unlocks daemon-wide cleanup and should only be enabled when the configured Docker daemon is used exclusively by Kandev. Kandev never performs a volume-wide prune."
+        title={t("system:storageDedicatedDaemon")}
+        description={t("system:storageDedicatedDaemonDescription")}
+        help={t("system:storageDedicatedDaemonHelp")}
         control={
           <Switch
             checked={settings.docker.dedicated_daemon_acknowledged}
@@ -443,16 +452,14 @@ function DockerSection({
               if (checked) onOpenDedicated();
               else onChange(settingsWithDockerAcknowledgement(settings, false));
             }}
-            aria-label="Dedicated Docker daemon"
+            aria-label={t("system:storageDedicatedDaemon")}
             data-testid="storage-docker-dedicated"
             data-settings-dirty={dedicatedDirty}
           />
         }
       />
       {unavailable && (
-        <p className="py-2 text-xs text-amber-600">
-          Docker is unavailable; Docker cleanup options cannot run on this host.
-        </p>
+        <p className="py-2 text-xs text-amber-600">{t("system:storageDockerUnavailableNotice")}</p>
       )}
       <DockerBuildCacheSettings
         docker={settings.docker}
@@ -472,6 +479,7 @@ function DockerSection({
 }
 
 function QuarantineSection({ settings, savedSettings, pending, onChange }: PolicySectionProps) {
+  const { t } = useTranslation();
   const retentionDirty = settingIsDirty(
     settings,
     savedSettings,
@@ -480,14 +488,14 @@ function QuarantineSection({ settings, savedSettings, pending, onChange }: Polic
   return (
     <PolicySection
       sectionId="quarantine"
-      title="Quarantine safety"
-      description="Keep recoverable resources for a grace period before permanent deletion."
+      title={t("system:storageQuarantineSafetyTitle")}
+      description={t("system:storageQuarantineSafetyDescription")}
       isDirty={retentionDirty}
     >
       <div className="grid min-w-0 grid-cols-1 gap-3 sm:grid-cols-2">
         <NumberField
-          label="Keep quarantined items for (hours)"
-          help="Cleanup first moves orphan workspaces and rotated Go caches into Kandev's trash area instead of deleting them immediately. During this retention period you can restore an item. After the deadline, a later maintenance run may permanently delete it."
+          label={t("system:storageQuarantineRetentionLabel")}
+          help={t("system:storageQuarantineRetentionHelp")}
           value={settings.quarantine_retention_hours}
           min={24}
           max={2160}
@@ -511,6 +519,7 @@ export function StoragePolicyCard({
   onChange,
   onAdopt,
 }: Props) {
+  const { t } = useTranslation();
   const [dockerDialogOpen, setDockerDialogOpen] = useState(false);
   const [adoptionDialogOpen, setAdoptionDialogOpen] = useState(false);
   const savedAdoptionPath = savedSettings.go_cache.adopted_path;
@@ -528,10 +537,8 @@ export function StoragePolicyCard({
   return (
     <section className="min-w-0 space-y-4" data-testid="storage-policy-card">
       <div>
-        <h2 className="text-base font-medium">Maintenance policy</h2>
-        <p className="text-xs text-muted-foreground">
-          Choose what Kandev may reclaim automatically and the safety limits it must follow.
-        </p>
+        <h2 className="text-base font-medium">{t("system:storagePolicyTitle")}</h2>
+        <p className="text-xs text-muted-foreground">{t("system:storagePolicyDescription")}</p>
       </div>
       <div className="space-y-3">
         <ScheduleSection
diff --git a/apps/web/components/settings/system/storage/storage-quarantine-card.test.tsx b/apps/web/components/settings/system/storage/storage-quarantine-card.test.tsx
index 21264aae82..ef8ba45b49 100644
--- a/apps/web/components/settings/system/storage/storage-quarantine-card.test.tsx
+++ b/apps/web/components/settings/system/storage/storage-quarantine-card.test.tsx
@@ -2,6 +2,7 @@ import type { ReactNode } from "react";
 import { cleanup, render, screen } from "@testing-library/react";
 import { TooltipProvider } from "@kandev/ui/tooltip";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { formatDateTime } from "@/lib/i18n/formats";
 import type { StorageQuarantineEntry } from "@/lib/types/system";
 import { StorageQuarantineCard } from "./storage-quarantine-card";
 
@@ -10,14 +11,28 @@ vi.mock("@/hooks/domains/system/use-system-jobs", () => ({
   useSystemJobs: () => [],
 }));
 
-afterEach(cleanup);
+afterEach(() => {
+  cleanup();
+  // Unconditional, so a failing assertion inside a fake-timer test cannot leak
+  // frozen time into the rest of the worker.
+  vi.useRealTimers();
+});
+
+const QUARANTINED_AT = "2026-07-23T12:00:00Z";
+const DELETE_AFTER = "2026-08-23T12:00:00Z";
 
 function Providers({ children }: { children: ReactNode }) {
   return <TooltipProvider>{children}</TooltipProvider>;
 }
 
 function renderCard(
-  props: { entries?: StorageQuarantineEntry[]; loading?: boolean; error?: string | null } = {},
+  props: {
+    entries?: StorageQuarantineEntry[];
+    loading?: boolean;
+    error?: string | null;
+    schedulingEnabled?: boolean;
+    checkIntervalHours?: number;
+  } = {},
 ) {
   return render(
     <StorageQuarantineCard
@@ -63,8 +78,8 @@ describe("StorageQuarantineCard", () => {
         quarantine_path: "/var/trash/cache-1",
         size_bytes: 2 * 1024 ** 3,
         state: "quarantined",
-        quarantined_at: "2026-07-23T12:00:00Z",
-        delete_after: "2026-08-23T12:00:00Z",
+        quarantined_at: QUARANTINED_AT,
+        delete_after: DELETE_AFTER,
         last_error: "",
         metadata: {},
       },
@@ -75,8 +90,8 @@ describe("StorageQuarantineCard", () => {
         quarantine_path: "/var/trash/workspace-1",
         size_bytes: 1024 ** 3,
         state: "quarantined",
-        quarantined_at: "2026-07-23T12:00:00Z",
-        delete_after: "2026-08-23T12:00:00Z",
+        quarantined_at: QUARANTINED_AT,
+        delete_after: DELETE_AFTER,
         last_error: "",
         metadata: {},
       },
@@ -88,4 +103,90 @@ describe("StorageQuarantineCard", () => {
       "Total quarantined: 3 GB",
     );
   });
+
+  // The eligible/protected counts are two separate plural messages joined, and
+  // the protected row is a <Trans> whose <1> addresses its <time> child
+  // positionally. Both reassemble silently into fragments if they drift, so
+  // each assertion is on the whole reconstructed sentence.
+  it("reads the counts and the retention deadline as whole sentences", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(QUARANTINED_AT));
+    const entries = [
+      {
+        id: "workspace-1",
+        resource_type: "task_workspace",
+        original_path: "/var/tasks/workspace-1",
+        quarantine_path: "/var/trash/workspace-1",
+        size_bytes: 1024 ** 3,
+        state: "quarantined",
+        quarantined_at: QUARANTINED_AT,
+        delete_after: DELETE_AFTER,
+        last_error: "",
+        metadata: {},
+      },
+    ] satisfies StorageQuarantineEntry[];
+
+    renderCard({ entries });
+
+    const deadline = formatDateTime(DELETE_AFTER);
+    expect(screen.getByTestId("storage-quarantine-workspace-1").textContent).toContain(
+      `Protected until ${deadline}`,
+    );
+    expect(screen.getByText("Trash: /var/trash/workspace-1")).toBeTruthy();
+    expect(screen.getByText(/eligible now · 1 protected$/).textContent).toContain(
+      "0 eligible now · 1 protected",
+    );
+  });
+});
+
+describe("StorageQuarantineCard resource types and schedule copy", () => {
+  // `resource_type` is a wire enum that used to reach the badge as
+  // `replace("_", " ")`. Both mapped values and the fallback for a value a newer
+  // backend might add need covering — the fallback is unreachable through the
+  // TypeScript union, so it is only exercised by casting past it.
+  it("labels every quarantined resource type, falling back to the raw token", () => {
+    const entry = (id: string, resourceType: string): StorageQuarantineEntry =>
+      ({
+        id,
+        resource_type: resourceType,
+        original_path: `/var/${id}`,
+        quarantine_path: `/var/trash/${id}`,
+        size_bytes: 1024 ** 3,
+        state: "quarantined",
+        quarantined_at: QUARANTINED_AT,
+        delete_after: DELETE_AFTER,
+        last_error: "",
+        metadata: {},
+      }) as unknown as StorageQuarantineEntry;
+
+    renderCard({
+      entries: [
+        entry("workspace-1", "task_workspace"),
+        entry("cache-1", "go_cache"),
+        entry("future-1", "object_store_cache"),
+      ],
+    });
+
+    expect(screen.getByTestId("storage-quarantine-workspace-1").textContent).toContain(
+      "task workspace",
+    );
+    expect(screen.getByTestId("storage-quarantine-cache-1").textContent).toContain("go cache");
+    // Multiple underscores, so a single-pattern `replace` fails this.
+    expect(screen.getByTestId("storage-quarantine-future-1").textContent).toContain(
+      "object store cache",
+    );
+  });
+
+  it("agrees the schedule copy with the interval", () => {
+    renderCard({ schedulingEnabled: true, checkIntervalHours: 1 });
+    expect(screen.getByTestId("storage-quarantine-schedule-copy").textContent).toContain(
+      "(every 1 hour when the idle gate allows it)",
+    );
+
+    cleanup();
+    renderCard({ schedulingEnabled: true, checkIntervalHours: 24 });
+    expect(screen.getByTestId("storage-quarantine-schedule-copy").textContent).toContain(
+      "(every 24 hours when the idle gate allows it)",
+    );
+  });
 });
diff --git a/apps/web/components/settings/system/storage/storage-quarantine-card.tsx b/apps/web/components/settings/system/storage/storage-quarantine-card.tsx
index b6de4969bd..61d10b4bd7 100644
--- a/apps/web/components/settings/system/storage/storage-quarantine-card.tsx
+++ b/apps/web/components/settings/system/storage/storage-quarantine-card.tsx
@@ -5,7 +5,7 @@ import { Badge } from "@kandev/ui/badge";
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@kandev/ui/card";
 import { Spinner } from "@kandev/ui/spinner";
 import { IconRestore, IconTrash } from "@tabler/icons-react";
-import { useTranslation } from "react-i18next";
+import { Trans, useTranslation } from "react-i18next";
 import type { StorageQuarantineEntry, StorageQuarantinePurgeScope } from "@/lib/types/system";
 import { JobProgressIndicator } from "../job-progress-indicator";
 import { PermanentDeleteDialog, QuarantinePurgeDialog } from "./storage-confirmation-dialogs";
@@ -22,6 +22,28 @@ import {
 
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 
+/**
+ * `resource_type` is a wire enum. It used to be rendered as
+ * `replace("_", " ")`, which is English-shaped by accident; each value now
+ * resolves through the catalog and falls back to the raw token so an unknown
+ * type from a newer backend still shows something.
+ */
+const RESOURCE_TYPE_LABEL_KEYS: Record<StorageQuarantineEntry["resource_type"], string> = {
+  task_workspace: "system:storageResourceTypeTaskWorkspace",
+  go_cache: "system:storageResourceTypeGoCache",
+};
+
+function resourceTypeLabel(
+  t: (key: string) => string,
+  resourceType: StorageQuarantineEntry["resource_type"],
+): string {
+  const key = RESOURCE_TYPE_LABEL_KEYS[resourceType];
+  // `replaceAll`, not `replace`: the original single-pattern call only reached
+  // the first underscore, so a future `some_new_resource_type` would have
+  // rendered as "some new_resource_type".
+  return key ? t(key) : resourceType.replaceAll("_", " ");
+}
+
 type Props = {
   entries: StorageQuarantineEntry[];
   loading?: boolean;
@@ -50,32 +72,34 @@ function QuarantineEntryRow({
   onRestore: (id: string) => Promise<void>;
   onDelete: (entry: StorageQuarantineEntry) => void;
 }) {
+  const { t } = useTranslation();
   const eligible = isQuarantineEligible(entry, now);
+  const deadline = formatQuarantineDeadline(entry);
   return (
     <div className="min-w-0 rounded-lg border p-3" data-testid={`storage-quarantine-${entry.id}`}>
       <div className="flex min-w-0 flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
         <div className="min-w-0 space-y-1">
           <div className="flex flex-wrap items-center gap-2">
-            <Badge variant="outline">{entry.resource_type.replace("_", " ")}</Badge>
+            <Badge variant="outline">{resourceTypeLabel(t, entry.resource_type)}</Badge>
             <span className="text-xs text-muted-foreground">
               {formatGigabytes(entry.size_bytes)}
             </span>
           </div>
+          {/* Both paths are API data and are never routed through the catalog. */}
           <p className="break-all font-mono text-xs">{entry.original_path}</p>
           <p className="break-all text-[11px] text-muted-foreground">
-            Trash: {entry.quarantine_path}
+            {t("system:storageTrashPath", { path: entry.quarantine_path })}
           </p>
           {entry.last_error && (
             <p className="break-words text-xs text-red-500">{entry.last_error}</p>
           )}
           <p className="text-xs text-muted-foreground">
             {eligible ? (
-              <span className="text-emerald-600">Eligible now</span>
+              <span className="text-emerald-600">{t("system:storageEligibleNow")}</span>
             ) : (
-              <>
-                Protected until{" "}
-                <time dateTime={entry.delete_after}>{formatQuarantineDeadline(entry)}</time>
-              </>
+              <Trans i18nKey="system:storageProtectedUntil" values={{ deadline }}>
+                Protected until <time dateTime={entry.delete_after}>{deadline}</time>
+              </Trans>
             )}
           </p>
         </div>
@@ -86,18 +110,18 @@ function QuarantineEntryRow({
             onClick={() => void onRestore(entry.id)}
             data-testid={`storage-quarantine-${entry.id}-restore`}
           >
-            <IconRestore className="size-4" /> Restore
+            <IconRestore className="size-4" /> {t("system:storageRestore")}
           </StorageActionButton>
           <StorageActionButton
             variant="destructive"
             disabledReason={
               disabledReason ??
-              (eligible ? undefined : `Retention ends ${formatQuarantineDeadline(entry)}.`)
+              (eligible ? undefined : t("system:storageRetentionEnds", { deadline }))
             }
             onClick={() => onDelete(entry)}
             data-testid={`storage-quarantine-${entry.id}-delete`}
           >
-            <IconTrash className="size-4" /> Delete
+            <IconTrash className="size-4" /> {t("system:storageDelete")}
           </StorageActionButton>
         </div>
       </div>
@@ -131,17 +155,15 @@ function QuarantineHeader({
     <CardHeader>
       <div className="flex min-w-0 flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
         <CardTitle className="flex items-center gap-1 text-base">
-          Quarantine
-          <StorageSettingHelp label="Quarantine">
-            Quarantine is Kandev's recoverable holding area. Orphan task workspaces and rotated Go
-            caches are moved here before deletion. You can restore an item during its retention
-            period; after the deadline, a later maintenance run may permanently delete it.
+          {t("system:storageQuarantineHeading")}
+          <StorageSettingHelp label={t("system:storageQuarantineHeading")}>
+            {t("system:storageQuarantineHelp")}
           </StorageSettingHelp>
         </CardTitle>
         <JobProgressIndicator
           kind="storage-quarantine-delete"
           jobId={deleteJobId}
-          successLabel="Deletion complete"
+          successLabel={t("system:storageDeletionComplete")}
           testId="storage-delete-job"
         />
       </div>
@@ -152,12 +174,12 @@ function QuarantineHeader({
           disabled={counts.eligible === 0 || entries.length === 0}
           disabledReason={
             bulkDisabledReason ??
-            (counts.eligible === 0 ? "No quarantine entries are eligible yet." : undefined)
+            (counts.eligible === 0 ? t("system:storageNoEligibleEntries") : undefined)
           }
           onClick={() => onPurge("eligible")}
           data-testid="storage-quarantine-clear-eligible"
         >
-          Clear eligible
+          {t("system:storageClearEligible")}
         </StorageActionButton>
         <StorageActionButton
           variant="destructive"
@@ -167,23 +189,23 @@ function QuarantineHeader({
           onClick={() => onPurge("all")}
           data-testid="storage-quarantine-force-clear"
         >
-          Force clear all
+          {t("system:storageForceClearAll")}
         </StorageActionButton>
       </div>
       <CardDescription>
-        Cleanup moves recoverable data here first instead of deleting it immediately. Restore an
-        item if you still need it, or delete it permanently when you are certain. {counts.eligible}{" "}
-        eligible now · {counts.protected} protected
+        {t("system:storageQuarantineCardDescription")}{" "}
+        {t("system:storageQuarantineEligibleCount", { count: counts.eligible })} ·{" "}
+        {t("system:storageQuarantineProtectedCount", { count: counts.protected })}
       </CardDescription>
       {showTotal && (
         <p className="text-xs font-medium" data-testid="storage-quarantine-total">
-          {t("settings:storageQuarantineTotal", { size: formatGigabytes(totalBytes) })}
+          {t("system:storageQuarantineTotal", { size: formatGigabytes(totalBytes) })}
         </p>
       )}
       <p className="text-xs text-muted-foreground" data-testid="storage-quarantine-schedule-copy">
         {schedulingEnabled
-          ? `Eligible entries are removed by the first successful maintenance run after their deadline (every ${checkIntervalHours} hours when the idle gate allows it).`
-          : "Automatic quarantine cleanup is off. Run maintenance manually or use a quarantine action when you are ready."}
+          ? t("system:storageQuarantineScheduleOn", { count: checkIntervalHours })
+          : t("system:storageQuarantineScheduleOff")}
       </p>
     </CardHeader>
   );
@@ -211,19 +233,19 @@ function QuarantineContent({
     return (
       <div className="flex items-center gap-2 text-sm text-muted-foreground">
         <Spinner className="size-4" data-testid="storage-quarantine-spinner" />
-        {t("settings:storageQuarantineLoading")}
+        {t("system:storageQuarantineLoading")}
       </div>
     );
   }
   if (error) {
     return (
       <p className="break-words text-sm text-destructive" data-testid="storage-quarantine-error">
-        {t("settings:storageSectionUnavailable")}: {error}
+        {t("system:storageSectionUnavailable")}: {error}
       </p>
     );
   }
   if (entries.length === 0) {
-    return <p className="text-sm text-muted-foreground">{t("settings:storageQuarantineEmpty")}</p>;
+    return <p className="text-sm text-muted-foreground">{t("system:storageQuarantineEmpty")}</p>;
   }
   return entries.map((entry) => (
     <QuarantineEntryRow
@@ -251,6 +273,7 @@ export function StorageQuarantineCard({
   onClearEligible,
   onForceClearAll,
 }: Props) {
+  const { t } = useTranslation();
   const [deleteEntry, setDeleteEntry] = useState<StorageQuarantineEntry | null>(null);
   const [purgeScope, setPurgeScope] = useState<StorageQuarantinePurgeScope | null>(null);
   const [now, setNow] = useState(() => new Date());
@@ -268,7 +291,7 @@ export function StorageQuarantineCard({
   const counts = quarantineCounts(entries, now);
   const totalBytes = quarantineTotalBytes(entries);
   const bulkDisabledReason =
-    disabledReason ?? (deleteJobActive ? "A quarantine cleanup is still running." : undefined);
+    disabledReason ?? (deleteJobActive ? t("system:storageQuarantineCleanupRunning") : undefined);
   return (
     <Card className="min-w-0" data-testid="storage-quarantine-card">
       <QuarantineHeader
diff --git a/apps/web/components/settings/system/storage/storage-quarantine.ts b/apps/web/components/settings/system/storage/storage-quarantine.ts
index 1664584609..cf276f4ade 100644
--- a/apps/web/components/settings/system/storage/storage-quarantine.ts
+++ b/apps/web/components/settings/system/storage/storage-quarantine.ts
@@ -1,3 +1,4 @@
+import { formatDateTime } from "@/lib/i18n/formats";
 import type { StorageQuarantineEntry } from "@/lib/types/system";
 
 export function quarantineDeleteAfter(entry: StorageQuarantineEntry): Date {
@@ -25,8 +26,7 @@ export function quarantineCounts(entries: StorageQuarantineEntry[], now = new Da
 }
 
 export function formatQuarantineDeadline(entry: StorageQuarantineEntry): string {
-  return quarantineDeleteAfter(entry).toLocaleString(undefined, {
-    dateStyle: "medium",
-    timeStyle: "short",
-  });
+  // The active i18next locale, not the browser's: the two can disagree once the
+  // user picks a language in Settings.
+  return formatDateTime(quarantineDeleteAfter(entry));
 }
diff --git a/apps/web/components/settings/system/storage/storage-run-history.tsx b/apps/web/components/settings/system/storage/storage-run-history.tsx
index 0165646c71..3fea699fa5 100644
--- a/apps/web/components/settings/system/storage/storage-run-history.tsx
+++ b/apps/web/components/settings/system/storage/storage-run-history.tsx
@@ -3,11 +3,12 @@ import { Badge } from "@kandev/ui/badge";
 import { Card, CardContent, CardHeader, CardTitle } from "@kandev/ui/card";
 import { Spinner } from "@kandev/ui/spinner";
 import { useTranslation } from "react-i18next";
+import { formatDateTime } from "@/lib/i18n/formats";
 import type { StorageMaintenanceRun } from "@/lib/types/system";
 
 function dateLabel(value: string): string {
   const parsed = new Date(value);
-  return Number.isNaN(parsed.getTime()) ? value : parsed.toLocaleString();
+  return Number.isNaN(parsed.getTime()) ? value : formatDateTime(parsed);
 }
 
 export function StorageRunHistory({
@@ -19,11 +20,12 @@ export function StorageRunHistory({
   loading?: boolean;
   error?: string | null;
 }) {
+  const { t } = useTranslation();
   const content = <StorageRunHistoryContent runs={runs} loading={loading} error={error} />;
   return (
     <Card className="min-w-0" data-testid="storage-run-history">
       <CardHeader>
-        <CardTitle className="text-base">Maintenance history</CardTitle>
+        <CardTitle className="text-base">{t("system:storageMaintenanceHistory")}</CardTitle>
       </CardHeader>
       <CardContent>{content}</CardContent>
     </Card>
@@ -44,19 +46,19 @@ function StorageRunHistoryContent({
     return (
       <div className="flex items-center gap-2 text-sm text-muted-foreground">
         <Spinner className="size-4" data-testid="storage-run-history-spinner" />
-        {t("settings:storageHistoryLoading")}
+        {t("system:storageHistoryLoading")}
       </div>
     );
   }
   if (error) {
     return (
       <p className="break-words text-sm text-destructive" data-testid="storage-run-history-error">
-        {t("settings:storageSectionUnavailable")}: {error}
+        {t("system:storageSectionUnavailable")}: {error}
       </p>
     );
   }
   if (runs.length === 0) {
-    return <p className="text-sm text-muted-foreground">{t("settings:storageHistoryEmpty")}</p>;
+    return <p className="text-sm text-muted-foreground">{t("system:storageHistoryEmpty")}</p>;
   }
   return (
     <Accordion type="multiple">
diff --git a/apps/web/components/settings/system/storage/storage-setting-help.tsx b/apps/web/components/settings/system/storage/storage-setting-help.tsx
index 35ca4992e6..9b93d96997 100644
--- a/apps/web/components/settings/system/storage/storage-setting-help.tsx
+++ b/apps/web/components/settings/system/storage/storage-setting-help.tsx
@@ -4,8 +4,10 @@ import { useState } from "react";
 import { Button } from "@kandev/ui/button";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@kandev/ui/tooltip";
 import { IconInfoCircle } from "@tabler/icons-react";
+import { useTranslation } from "react-i18next";
 
 export function StorageSettingHelp({ label, children }: { label: string; children: string }) {
+  const { t } = useTranslation();
   const [open, setOpen] = useState(false);
   return (
     <Tooltip open={open} onOpenChange={setOpen}>
@@ -15,7 +17,7 @@ export function StorageSettingHelp({ label, children }: { label: string; childre
           variant="ghost"
           size="icon-sm"
           className="size-11 shrink-0 cursor-help text-muted-foreground sm:size-7"
-          aria-label={`More information about ${label}`}
+          aria-label={t("system:storageMoreInformationAbout", { label })}
           onClick={() => setOpen((current) => !current)}
         >
           <IconInfoCircle className="size-4" />
diff --git a/apps/web/eslint.i18n.options.mjs b/apps/web/eslint.i18n.options.mjs
index 532833e8a9..84d886c8c3 100644
--- a/apps/web/eslint.i18n.options.mjs
+++ b/apps/web/eslint.i18n.options.mjs
@@ -520,4 +520,45 @@ export const i18nGuardFiles = [
   "components/model-config-selector.tsx",
   "components/settings/host-shell-dialog.tsx",
   "components/settings/pty-terminal-dialog.tsx",
+  // Settings → System → Storage: the route and the whole
+  // `components/settings/system/storage` directory, plus the page's own hook.
+  // The other eight System routes and the cards they render from
+  // `components/settings/system/*.tsx` are NOT migrated, which is why this stops
+  // at the `storage/` subdirectory.
+  //
+  // Four `.ts` entries hold no JSX, so `mode: "jsx-only"` never inspects them;
+  // the entries record that they are migrated and only the pseudo-locale can
+  // prove it stays that way. `use-storage-maintenance.ts` is the load-bearing
+  // one — it owns nine toast titles and the refresh-error message, none of which
+  // lint can ever see. It imports the module-level `t` rather than the hook so
+  // each string resolves when the callback fires. `storage-quarantine.ts` and
+  // `storage-totals.ts` carry no copy (the first now formats its deadline
+  // through `lib/i18n/formats` instead of the browser locale).
+  //
+  // Deliberately left in English, none of it copy:
+  //   - The type-to-confirm phrases `DEDICATED` / `ADOPT` / `DELETE` /
+  //     `DELETE ELIGIBLE` / `DELETE ALL NOW` in `storage-confirmation-dialogs`.
+  //     They are a string-literal union compared with `===` to enable the
+  //     confirm button, so translating one makes that dialog impossible to
+  //     satisfy. They travel as an interpolated value into both the visible
+  //     sentence and the input's aria-label.
+  //   - `storage-units.ts` in full. `B` / `GB`, `-` and `<0.01 GB` are units and
+  //     numeric formatting, not prose, which is why it is absent from this list
+  //     rather than listed with a note.
+  //   - `run.state` and `run.trigger` in `storage-run-history.tsx`. They are raw
+  //     API enum tokens rendered verbatim beside the run's raw JSON result —
+  //     `skipped_busy` is the proof — so they are values, not copy.
+  //   - Every filesystem path: the adopted/managed Go cache paths, the quarantine
+  //     `original_path` / `quarantine_path`, the Docker host, and the
+  //     `/root/.cache/go-build` placeholder. All are interpolated as values so
+  //     the pseudo-locale cannot turn them into dead pointers.
+  //   - `StorageBusyResource.label`, which the backend renders.
+  "app/settings/system/storage/**/*.{ts,tsx}",
+  "components/settings/system/storage/**/*.{ts,tsx}",
+  "hooks/domains/system/use-storage-maintenance.ts",
+  // The shell every System route renders. It takes title/description/actions as
+  // props and holds no literals of its own, so listing it costs nothing today
+  // and pins that contract for the sibling migration of the other eight routes,
+  // which will land their copy on top of it.
+  "components/settings/system/system-page-shell.tsx",
 ];
diff --git a/apps/web/hooks/domains/system/use-storage-maintenance.ts b/apps/web/hooks/domains/system/use-storage-maintenance.ts
index f4d3000efe..9fbdc5a000 100644
--- a/apps/web/hooks/domains/system/use-storage-maintenance.ts
+++ b/apps/web/hooks/domains/system/use-storage-maintenance.ts
@@ -12,6 +12,12 @@ import {
 import { useAppStore } from "@/components/state-provider";
 import { useToast } from "@/components/toast-provider";
 import { ApiError } from "@/lib/api/client";
+// The module-level `t`, not `useTranslation`: every string below is produced
+// inside an imperative callback (a toast, a refresh error), so resolving at call
+// time is both correct and keeps `t` out of the callbacks' dependency arrays —
+// a `t` dep on `useTerminalJobRefresh` would re-issue its network reload on a
+// locale switch. Never call it at module scope; that would freeze the boot locale.
+import { t } from "@/lib/i18n";
 import {
   adoptStorageGoCache,
   analyzeStorage,
@@ -126,7 +132,7 @@ function useStorageActionRunner() {
       } catch (requestError) {
         const message = messageFromError(requestError);
         setError(message);
-        toast({ title: "Storage action failed", description: message, variant: "error" });
+        toast({ title: t("system:storageActionFailed"), description: message, variant: "error" });
         if (rethrow) throw requestError;
       } finally {
         setPendingActions((current) => current.filter(({ id }) => id !== pendingActionId));
@@ -152,7 +158,7 @@ function useStoragePolicyActions(
         async () => {
           await saveStorageSettings(settings, confirmation);
           await reload(["policy"]);
-          toast({ title: "Storage policy saved", variant: "success" });
+          toast({ title: t("system:storageToastPolicySaved"), variant: "success" });
         },
         true,
       );
@@ -166,7 +172,7 @@ function useStoragePolicyActions(
       return perform("adopt", async () => {
         const response = await adoptStorageGoCache(path);
         setPolicy(response);
-        toast({ title: "Go build cache adopted", variant: "success" });
+        toast({ title: t("system:storageToastCacheAdopted"), variant: "success" });
       });
     },
     [clearBusy, perform, setPolicy, toast],
@@ -187,7 +193,7 @@ function useStorageDeleteAction(
       return perform("delete", async () => {
         const accepted = await deleteStorageQuarantine(id);
         setDeleteJobId(accepted.job_id);
-        toast({ title: "Permanent deletion started", variant: "success" });
+        toast({ title: t("system:storageToastDeletionStarted"), variant: "success" });
       });
     },
     [clearBusy, perform, setDeleteJobId, toast],
@@ -209,8 +215,8 @@ function useStorageBulkDeleteAction(
         toast({
           title:
             scope === "eligible"
-              ? "Eligible quarantine cleanup started"
-              : "Forced quarantine cleanup started",
+              ? t("system:storageToastEligiblePurgeStarted")
+              : t("system:storageToastForcedPurgeStarted"),
           variant: "success",
         });
       });
@@ -237,7 +243,7 @@ function useStorageActions(reload: Reload, setPolicy: (policy: StoragePolicyResp
     return perform("analyze", async () => {
       const accepted = await analyzeStorage();
       setAnalysisJobId(accepted.job_id);
-      toast({ title: "Storage analysis started", variant: "success" });
+      toast({ title: t("system:storageToastAnalysisStarted"), variant: "success" });
     });
   }, [clearBusy, perform, toast]);
 
@@ -249,7 +255,7 @@ function useStorageActions(reload: Reload, setPolicy: (policy: StoragePolicyResp
         try {
           const accepted = await runStorageMaintenance(resources);
           setCleanupJobId(accepted.job_id);
-          toast({ title: "Storage maintenance started", variant: "success" });
+          toast({ title: t("system:storageToastMaintenanceStarted"), variant: "success" });
         } catch (error) {
           const nextBusy = busyStateFromError(error, resources);
           if (nextBusy) {
@@ -271,7 +277,7 @@ function useStorageActions(reload: Reload, setPolicy: (policy: StoragePolicyResp
       try {
         const accepted = await runStorageMaintenance(resources, true);
         setCleanupJobId(accepted.job_id);
-        toast({ title: "Storage maintenance started", variant: "success" });
+        toast({ title: t("system:storageToastMaintenanceStarted"), variant: "success" });
       } catch (error) {
         const nextBusy = busyStateFromError(error, resources);
         if (nextBusy) {
@@ -289,7 +295,7 @@ function useStorageActions(reload: Reload, setPolicy: (policy: StoragePolicyResp
       return perform("restore", async () => {
         await restoreStorageQuarantine(id);
         await reload(["quarantine"]);
-        toast({ title: "Quarantined resource restored", variant: "success" });
+        toast({ title: t("system:storageToastQuarantineRestored"), variant: "success" });
       });
     },
     [clearBusy, perform, reload, toast],
@@ -333,7 +339,9 @@ function useTerminalJobRefresh(reload: Reload, setError: SetStorageError, job?:
         setError((current) => (current === resolvedError ? null : current));
       } catch (requestError) {
         if (cancelled) return;
-        refreshError = `Refresh storage data: ${messageFromError(requestError)}`;
+        refreshError = t("system:storageRefreshFailed", {
+          message: messageFromError(requestError),
+        });
         setError(refreshError);
         attempts += 1;
         if (attempts >= MAX_TERMINAL_REFRESH_ATTEMPTS) return;
diff --git a/apps/web/src/locales/en/settings.json b/apps/web/src/locales/en/settings.json
index 730ac32b49..3aa0aa00dc 100644
--- a/apps/web/src/locales/en/settings.json
+++ b/apps/web/src/locales/en/settings.json
@@ -331,18 +331,6 @@
   "supportedEditors": "Supported Editors",
   "supportsPlaceholders": "Supports placeholders: {{placeholders}}",
   "systemDefault": "System default",
-  "storageLoadingData": "Loading storage data…",
-  "storageAdoptionPending": "Wait for Go cache adoption to finish.",
-  "storagePolicyLoadingBlock": "Wait for storage settings to finish loading.",
-  "storageActionPending": "Wait for the current storage action to finish.",
-  "storageHistoryLoading": "Loading maintenance history…",
-  "storageHistoryEmpty": "No storage maintenance runs yet.",
-  "storageQuarantineLoading": "Loading quarantine…",
-  "storageQuarantineEmpty": "No restorable quarantined resources.",
-  "storageQuarantineTotal": "Total quarantined: {{size}}",
-  "storageSectionUnavailable": "This storage section could not be loaded",
-  "storageTotalCounted": "Total counted: {{size}}",
-  "storageTotalPartial": "Partial measurement",
   "systemLoad1Min": "System load (1 min)",
   "taskActions": "Task Actions",
   "taskOverview": "Task overview",
diff --git a/apps/web/src/locales/en/system.json b/apps/web/src/locales/en/system.json
new file mode 100644
index 0000000000..a38f938df9
--- /dev/null
+++ b/apps/web/src/locales/en/system.json
@@ -0,0 +1,183 @@
+{
+  "storageTitle": "Storage",
+  "storageDescription": "Review disk use and reclaim space from Kandev-owned workspaces, caches, and Docker resources whenever your installation needs it.",
+
+  "storageLoadingData": "Loading storage data…",
+  "storageSectionUnavailable": "This storage section could not be loaded",
+  "storageAdoptionPending": "Wait for Go cache adoption to finish.",
+  "storagePolicyLoadingBlock": "Wait for storage settings to finish loading.",
+  "storageActionPending": "Wait for the current storage action to finish.",
+
+  "storageActionsTitle": "Reclaim disk space safely",
+  "storageActionsDescription": "Analyze for a read-only snapshot, or run the enabled cleanup rules when you want to recover space immediately.",
+  "storageAnalyze": "Analyze",
+  "storageAnalyzing": "Analyzing...",
+  "storageAnalysisComplete": "Analysis complete",
+  "storageAnalysisFailed": "Analysis failed",
+  "storageAnalysisRunning": "Storage analysis is still running.",
+  "storageRunNow": "Run now",
+  "storageCleaning": "Cleaning...",
+  "storageCleanupComplete": "Cleanup complete",
+  "storageCleanupFailed": "Cleanup failed",
+  "storageCleanupRunning": "Storage cleanup is still running.",
+  "storageActionFailed": "Storage action failed",
+  "storageBusyTitle": "Storage cleanup found active Kandev work",
+  "storageBusyIntro": "Cleanup may disrupt the following work:",
+  "storageBusyForceHint": "Running cleanup anyway may disrupt this active work.",
+  "storageRunAnyway": "Run anyway",
+
+  "storageAnalysisTitle": "Storage analysis",
+  "storageAnalysisDescription": "A read-only breakdown of current usage and reclaimable space. Run Analyze occasionally to refresh these estimates; it never deletes or moves anything.",
+  "storageDockerUnavailableBadge": "Docker unavailable",
+  "storageLastAnalyzed": "Last analyzed {{time}}",
+  "storageTotalCounted": "Total counted: {{size}}",
+  "storageTotalPartial": "Partial measurement",
+  "storageUnavailableValue": "Unavailable",
+  "storageTaskWorkspaces": "Task workspaces",
+  "storageWorkspacesDetail": "{{reclaimable}} reclaimable after the grace period · {{active}} active",
+  "storageQuarantinedResources": "Quarantined resources",
+  "storageQuarantineUnmeasured": "Quarantine usage could not be measured",
+  "storageQuarantineMovedAside_one": "{{count}} item moved aside for recovery before permanent deletion",
+  "storageQuarantineMovedAside_other": "{{count}} items moved aside for recovery before permanent deletion",
+  "storageDockerUnmeasured": "Docker usage could not be measured",
+  "storageKandevContainers": "Kandev containers",
+  "storageManagedContainerCount_one": "{{count}} managed container",
+  "storageManagedContainerCount_other": "{{count}} managed containers",
+  "storageGoBuildCache": "Go build cache",
+  "storageUserGoBuildCache": "User Go build cache",
+  "storageDockerImageLayers": "Docker image layers",
+  "storageDefaultDockerHost": "Default Docker host",
+  "storageDockerBuildCache": "Docker build cache",
+  "storageUnusedDockerImages": "Unused Docker images",
+  "storageUnusedImagesDetail": "Unused by every container and older than the configured age",
+  "storageCleanGoCache": "Clean Go cache",
+  "storageGoCacheNotOwned": "Only a Kandev-owned Go build cache can be cleaned.",
+  "storageGoCacheBelowLimit": "The Go build cache is below its configured size limit.",
+
+  "storagePolicyTitle": "Maintenance policy",
+  "storagePolicyDescription": "Choose what Kandev may reclaim automatically and the safety limits it must follow.",
+  "storageMoreInformationAbout": "More information about {{label}}",
+
+  "storageScheduleTitle": "Schedule",
+  "storageScheduleDescription": "Controls when automatic maintenance is allowed to start. Manual actions remain available when scheduling is off.",
+  "storageScheduledMaintenance": "Scheduled maintenance",
+  "storageScheduledMaintenanceDescription": "Periodically reclaim disk space using the enabled resource rules.",
+  "storageScheduledMaintenanceHelp": "When enabled, Kandev checks this policy at the configured interval and starts only after Kandev has been idle for the required period. Turning it off does not disable Analyze or Run now.",
+  "storageCheckIntervalLabel": "Check every (hours)",
+  "storageCheckIntervalHelp": "How often Kandev checks whether scheduled maintenance is due. A check that finds Kandev busy is skipped and tried again at the next interval.",
+  "storageIdleLabel": "Require idle for (minutes)",
+  "storageIdleHelp": "Scheduled cleanup starts only after no task, shell command, test, setup, cleanup, or image build has used managed resources for this long. Run now does not wait for this timer, but it still refuses to run while resources are active.",
+
+  "storageWorkspacesTitle": "Workspaces and containers",
+  "storageWorkspacesDescription": "Reclaim resources that Kandev can positively identify as no longer in use.",
+  "storageOrphanWorkspaces": "Orphan task workspaces",
+  "storageOrphanWorkspacesDescription": "Move confirmed orphan workspaces to quarantine.",
+  "storageOrphanWorkspacesHelp": "Kandev only selects a task workspace after inventory confirms that no active task, environment, session, or protected worktree uses it. The workspace is moved to quarantine first, where it can be restored before permanent deletion.",
+  "storageCleanOrphanWorkspacesAria": "Clean orphan task workspaces",
+  "storageOrphanGraceLabel": "Wait before orphaning (hours)",
+  "storageOrphanGraceHelp": "A workspace must be unused for at least this long before it can be classified as an orphan. Increasing this value keeps old workspaces longer before they enter quarantine.",
+  "storageContainersDescription": "Remove stopped, unused containers created and labeled by Kandev.",
+  "storageContainersHelp": "Only stopped containers labeled as Kandev-managed are considered, and inventory must confirm they are no longer needed. Running containers and unrelated Docker containers are never removed by this option.",
+  "storageCleanContainersAria": "Clean Kandev containers",
+
+  "storageGoCacheSectionDescription": "Use and trim a Kandev-owned cache for new host-local executions.",
+  "storageManagedGoCache": "Managed Go cache",
+  "storageManagedGoCacheDescription": "New host-local executions use {{path}}.",
+  "storageManagedGoCacheHelp": "When enabled, Kandev gives new local task processes a dedicated Go build cache and may rotate it during maintenance when it exceeds the maximum. Turning this off stops using the managed cache for new executions but does not delete it.",
+  "storageEnableManagedGoCacheAria": "Enable managed Go cache",
+  "storageGoCacheMaxLabel": "Maximum cache size (GB)",
+  "storageGoCacheMaxHelp": "This is a cleanup trigger, not a hard quota. The cache may grow past this size while tasks are active. Maintenance rotates the owned cache into quarantine and recreates an empty cache after the limit is exceeded.",
+  "storageExternalGoCache": "External Go cache",
+  "storageExternalGoCacheHelp": "Adoption gives Kandev explicit permission to rotate this existing cache. Kandev never cleans a default user cache or another path unless you adopt that exact absolute path and confirm the destructive access.",
+  "storageExternalGoCacheDescription": "Optionally allow Kandev to maintain an existing host cache outside its managed path.",
+  "storageEnableGoCacheFirst": "Enable the managed Go cache first.",
+  "storageEnterCachePathFirst": "Enter an absolute cache path first.",
+  "storageAdoptCache": "Adopt cache",
+
+  "storageDockerTitle": "Docker cleanup",
+  "storageDockerDescription": "Optional daemon-wide cleanup. Enable it only when this Docker daemon is dedicated to Kandev.",
+  "storageDockerUnavailable": "Docker is unavailable on the configured host.",
+  "storageDockerUnavailableNotice": "Docker is unavailable; Docker cleanup options cannot run on this host.",
+  "storageAcknowledgeDedicatedFirst": "Acknowledge a dedicated Docker daemon first.",
+  "storageDedicatedDaemon": "Dedicated Docker daemon",
+  "storageDedicatedDaemonDescription": "Confirm that unrelated workloads do not share this Docker daemon.",
+  "storageDedicatedDaemonHelp": "Build cache and image ownership cannot be attributed reliably to Kandev. This acknowledgment unlocks daemon-wide cleanup and should only be enabled when the configured Docker daemon is used exclusively by Kandev. Kandev never performs a volume-wide prune.",
+  "storageDockerBuildCacheDescription": "Remove old build cache while retaining the configured amount.",
+  "storageDockerBuildCacheHelp": "Uses Docker's age and storage filters to remove old build cache. It does not run docker system prune, does not remove volumes globally, and remains disabled until the dedicated-daemon acknowledgment is confirmed.",
+  "storageCleanDockerBuildCacheAria": "Clean Docker build cache",
+  "storageBuildCacheKeepLabel": "Build cache to retain (GB)",
+  "storageBuildCacheKeepHelp": "Docker keeps approximately this much build cache when pruning eligible records. A larger value preserves more reusable build layers but reclaims less disk space.",
+  "storageBuildCacheUnusedLabel": "Build cache must be unused for (hours)",
+  "storageBuildCacheUnusedHelp": "Only build cache records older than this unused-age threshold are eligible. Increasing it protects recent build layers for longer.",
+  "storageUnusedImagesDescription": "Remove old images that no container uses.",
+  "storageUnusedImagesHelp": "Removes an image only when no running or stopped container references it and it is older than the configured age. This is daemon-wide and therefore requires the dedicated-daemon acknowledgment.",
+  "storageCleanUnusedImagesAria": "Clean unused Docker images",
+  "storageUnusedImagesHoursLabel": "Image must be unused for (hours)",
+  "storageUnusedImagesHoursHelp": "An image must be unused by every container and older than this age before Kandev can remove it. Increasing the value keeps old images available for longer.",
+
+  "storageQuarantineSafetyTitle": "Quarantine safety",
+  "storageQuarantineSafetyDescription": "Keep recoverable resources for a grace period before permanent deletion.",
+  "storageQuarantineRetentionLabel": "Keep quarantined items for (hours)",
+  "storageQuarantineRetentionHelp": "Cleanup first moves orphan workspaces and rotated Go caches into Kandev's trash area instead of deleting them immediately. During this retention period you can restore an item. After the deadline, a later maintenance run may permanently delete it.",
+
+  "storageTypeToConfirm": "Type <1>{{phrase}}</1> to continue.",
+  "storageTypeToConfirmAria": "Type {{phrase}} to confirm",
+  "storageDedicatedDialogTitle": "Use this dedicated Docker daemon",
+  "storageDedicatedDialogDescription": "Build-cache and unused-image cleanup affect the entire configured daemon, including resources created outside Kandev. Only acknowledge a daemon dedicated to this installation.",
+  "storageAcknowledgeDaemon": "Acknowledge daemon",
+  "storageAdoptDialogTitle": "Adopt an external Go build cache",
+  "storageAdoptDialogDescription": "Kandev will be allowed to rotate and quarantine the existing cache at {{path}}. This path must be absolute and on the same filesystem as Kandev trash.",
+  "storageAdoptDialogFallbackPath": "the selected path",
+  "storageDeleteDialogTitle": "Permanently delete quarantined data",
+  "storageDeleteDialogDescription": "This cannot be undone. Kandev will permanently remove {{path}}.",
+  "storageDeleteDialogFallbackPath": "the selected quarantine entry",
+  "storageDeletePermanently": "Delete permanently",
+  "storageClearEligibleDialogTitle": "Clear eligible quarantine",
+  "storageForceClearDialogTitle": "Force clear all quarantine",
+  "storagePurgeEligibleCount_one": "This will permanently remove {{count}} eligible item.",
+  "storagePurgeEligibleCount_other": "This will permanently remove {{count}} eligible items.",
+  "storagePurgeProtectedCount_one": "{{count}} protected item remains until its retention deadline.",
+  "storagePurgeProtectedCount_other": "{{count}} protected items remain until their retention deadlines.",
+  "storageForceClearDescription": "This attempts to permanently remove every quarantined item immediately and cannot be undone for entries that succeed. Failed entries may remain visible and retryable.",
+
+  "storageQuarantineHeading": "Quarantine",
+  "storageQuarantineHelp": "Quarantine is Kandev's recoverable holding area. Orphan task workspaces and rotated Go caches are moved here before deletion. You can restore an item during its retention period; after the deadline, a later maintenance run may permanently delete it.",
+  "storageQuarantineCardDescription": "Cleanup moves recoverable data here first instead of deleting it immediately. Restore an item if you still need it, or delete it permanently when you are certain.",
+  "storageQuarantineEligibleCount_one": "{{count}} eligible now",
+  "storageQuarantineEligibleCount_other": "{{count}} eligible now",
+  "storageQuarantineProtectedCount_one": "{{count}} protected",
+  "storageQuarantineProtectedCount_other": "{{count}} protected",
+  "storageQuarantineScheduleOn_one": "Eligible entries are removed by the first successful maintenance run after their deadline (every {{count}} hour when the idle gate allows it).",
+  "storageQuarantineScheduleOn_other": "Eligible entries are removed by the first successful maintenance run after their deadline (every {{count}} hours when the idle gate allows it).",
+  "storageQuarantineScheduleOff": "Automatic quarantine cleanup is off. Run maintenance manually or use a quarantine action when you are ready.",
+  "storageQuarantineTotal": "Total quarantined: {{size}}",
+  "storageQuarantineLoading": "Loading quarantine…",
+  "storageQuarantineEmpty": "No restorable quarantined resources.",
+  "storageNoEligibleEntries": "No quarantine entries are eligible yet.",
+  "storageQuarantineCleanupRunning": "A quarantine cleanup is still running.",
+  "storageClearEligible": "Clear eligible",
+  "storageForceClearAll": "Force clear all",
+  "storageDeletionComplete": "Deletion complete",
+  "storageResourceTypeTaskWorkspace": "task workspace",
+  "storageResourceTypeGoCache": "go cache",
+  "storageTrashPath": "Trash: {{path}}",
+  "storageEligibleNow": "Eligible now",
+  "storageProtectedUntil": "Protected until <1>{{deadline}}</1>",
+  "storageRestore": "Restore",
+  "storageDelete": "Delete",
+  "storageRetentionEnds": "Retention ends {{deadline}}.",
+
+  "storageMaintenanceHistory": "Maintenance history",
+  "storageHistoryLoading": "Loading maintenance history…",
+  "storageHistoryEmpty": "No storage maintenance runs yet.",
+
+  "storageToastPolicySaved": "Storage policy saved",
+  "storageToastCacheAdopted": "Go build cache adopted",
+  "storageToastDeletionStarted": "Permanent deletion started",
+  "storageToastEligiblePurgeStarted": "Eligible quarantine cleanup started",
+  "storageToastForcedPurgeStarted": "Forced quarantine cleanup started",
+  "storageToastAnalysisStarted": "Storage analysis started",
+  "storageToastMaintenanceStarted": "Storage maintenance started",
+  "storageToastQuarantineRestored": "Quarantined resource restored",
+  "storageRefreshFailed": "Refresh storage data: {{message}}"
+}
diff --git a/apps/web/src/locales/pseudo/settings.json b/apps/web/src/locales/pseudo/settings.json
index 5be437bf6e..f66fc1984a 100644
--- a/apps/web/src/locales/pseudo/settings.json
+++ b/apps/web/src/locales/pseudo/settings.json
@@ -331,18 +331,6 @@
   "supportedEditors": "Śũƥƥōŕţēď Ēďĩţōŕś",
   "supportsPlaceholders": "Śũƥƥōŕţś ƥĺàćēĥōĺďēŕś: {{placeholders}}",
   "systemDefault": "Śŷśţēḿ ďēƒàũĺţ",
-  "storageLoadingData": "Ĺōàďĩńĝ śţōŕàĝē ďàţà…",
-  "storageAdoptionPending": "Ŵàĩţ ƒōŕ Ĝō ćàćĥē àďōƥţĩōń ţō ƒĩńĩśĥ.",
-  "storagePolicyLoadingBlock": "Ŵàĩţ ƒōŕ śţōŕàĝē śēţţĩńĝś ţō ƒĩńĩśĥ ĺōàďĩńĝ.",
-  "storageActionPending": "Ŵàĩţ ƒōŕ ţĥē ćũŕŕēńţ śţōŕàĝē àćţĩōń ţō ƒĩńĩśĥ.",
-  "storageHistoryLoading": "Ĺōàďĩńĝ ḿàĩńţēńàńćē ĥĩśţōŕŷ…",
-  "storageHistoryEmpty": "Ńō śţōŕàĝē ḿàĩńţēńàńćē ŕũńś ŷēţ.",
-  "storageQuarantineLoading": "Ĺōàďĩńĝ qũàŕàńţĩńē…",
-  "storageQuarantineEmpty": "Ńō ŕēśţōŕàƀĺē qũàŕàńţĩńēď ŕēśōũŕćēś.",
-  "storageQuarantineTotal": "Ţōţàĺ qũàŕàńţĩńēď: {{size}}",
-  "storageSectionUnavailable": "Ţĥĩś śţōŕàĝē śēćţĩōń ćōũĺď ńōţ ƀē ĺōàďēď",
-  "storageTotalCounted": "Ţōţàĺ ćōũńţēď: {{size}}",
-  "storageTotalPartial": "Ƥàŕţĩàĺ ḿēàśũŕēḿēńţ",
   "systemLoad1Min": "Śŷśţēḿ ĺōàď (1 ḿĩń)",
   "taskActions": "Ţàśķ Àćţĩōńś",
   "taskOverview": "Ţàśķ ōvēŕvĩēŵ",
diff --git a/apps/web/src/locales/pseudo/system.json b/apps/web/src/locales/pseudo/system.json
new file mode 100644
index 0000000000..5487b1aad4
--- /dev/null
+++ b/apps/web/src/locales/pseudo/system.json
@@ -0,0 +1,170 @@
+{
+  "storageTitle": "Śţōŕàĝē",
+  "storageDescription": "Ŕēvĩēŵ ďĩśķ ũśē àńď ŕēćĺàĩḿ śƥàćē ƒŕōḿ Ķàńďēv-ōŵńēď ŵōŕķśƥàćēś, ćàćĥēś, àńď Ďōćķēŕ ŕēśōũŕćēś ŵĥēńēvēŕ ŷōũŕ ĩńśţàĺĺàţĩōń ńēēďś ĩţ.",
+  "storageLoadingData": "Ĺōàďĩńĝ śţōŕàĝē ďàţà…",
+  "storageSectionUnavailable": "Ţĥĩś śţōŕàĝē śēćţĩōń ćōũĺď ńōţ ƀē ĺōàďēď",
+  "storageAdoptionPending": "Ŵàĩţ ƒōŕ Ĝō ćàćĥē àďōƥţĩōń ţō ƒĩńĩśĥ.",
+  "storagePolicyLoadingBlock": "Ŵàĩţ ƒōŕ śţōŕàĝē śēţţĩńĝś ţō ƒĩńĩśĥ ĺōàďĩńĝ.",
+  "storageActionPending": "Ŵàĩţ ƒōŕ ţĥē ćũŕŕēńţ śţōŕàĝē àćţĩōń ţō ƒĩńĩśĥ.",
+  "storageActionsTitle": "Ŕēćĺàĩḿ ďĩśķ śƥàćē śàƒēĺŷ",
+  "storageActionsDescription": "Àńàĺŷźē ƒōŕ à ŕēàď-ōńĺŷ śńàƥśĥōţ, ōŕ ŕũń ţĥē ēńàƀĺēď ćĺēàńũƥ ŕũĺēś ŵĥēń ŷōũ ŵàńţ ţō ŕēćōvēŕ śƥàćē ĩḿḿēďĩàţēĺŷ.",
+  "storageAnalyze": "Àńàĺŷźē",
+  "storageAnalyzing": "Àńàĺŷźĩńĝ...",
+  "storageAnalysisComplete": "Àńàĺŷśĩś ćōḿƥĺēţē",
+  "storageAnalysisFailed": "Àńàĺŷśĩś ƒàĩĺēď",
+  "storageAnalysisRunning": "Śţōŕàĝē àńàĺŷśĩś ĩś śţĩĺĺ ŕũńńĩńĝ.",
+  "storageRunNow": "Ŕũń ńōŵ",
+  "storageCleaning": "Ćĺēàńĩńĝ...",
+  "storageCleanupComplete": "Ćĺēàńũƥ ćōḿƥĺēţē",
+  "storageCleanupFailed": "Ćĺēàńũƥ ƒàĩĺēď",
+  "storageCleanupRunning": "Śţōŕàĝē ćĺēàńũƥ ĩś śţĩĺĺ ŕũńńĩńĝ.",
+  "storageActionFailed": "Śţōŕàĝē àćţĩōń ƒàĩĺēď",
+  "storageBusyTitle": "Śţōŕàĝē ćĺēàńũƥ ƒōũńď àćţĩvē Ķàńďēv ŵōŕķ",
+  "storageBusyIntro": "Ćĺēàńũƥ ḿàŷ ďĩśŕũƥţ ţĥē ƒōĺĺōŵĩńĝ ŵōŕķ:",
+  "storageBusyForceHint": "Ŕũńńĩńĝ ćĺēàńũƥ àńŷŵàŷ ḿàŷ ďĩśŕũƥţ ţĥĩś àćţĩvē ŵōŕķ.",
+  "storageRunAnyway": "Ŕũń àńŷŵàŷ",
+  "storageAnalysisTitle": "Śţōŕàĝē àńàĺŷśĩś",
+  "storageAnalysisDescription": "À ŕēàď-ōńĺŷ ƀŕēàķďōŵń ōƒ ćũŕŕēńţ ũśàĝē àńď ŕēćĺàĩḿàƀĺē śƥàćē. Ŕũń Àńàĺŷźē ōććàśĩōńàĺĺŷ ţō ŕēƒŕēśĥ ţĥēśē ēśţĩḿàţēś; ĩţ ńēvēŕ ďēĺēţēś ōŕ ḿōvēś àńŷţĥĩńĝ.",
+  "storageDockerUnavailableBadge": "Ďōćķēŕ ũńàvàĩĺàƀĺē",
+  "storageLastAnalyzed": "Ĺàśţ àńàĺŷźēď {{time}}",
+  "storageTotalCounted": "Ţōţàĺ ćōũńţēď: {{size}}",
+  "storageTotalPartial": "Ƥàŕţĩàĺ ḿēàśũŕēḿēńţ",
+  "storageUnavailableValue": "Ũńàvàĩĺàƀĺē",
+  "storageTaskWorkspaces": "Ţàśķ ŵōŕķśƥàćēś",
+  "storageWorkspacesDetail": "{{reclaimable}} ŕēćĺàĩḿàƀĺē àƒţēŕ ţĥē ĝŕàćē ƥēŕĩōď · {{active}} àćţĩvē",
+  "storageQuarantinedResources": "Qũàŕàńţĩńēď ŕēśōũŕćēś",
+  "storageQuarantineUnmeasured": "Qũàŕàńţĩńē ũśàĝē ćōũĺď ńōţ ƀē ḿēàśũŕēď",
+  "storageQuarantineMovedAside_one": "{{count}} ĩţēḿ ḿōvēď àśĩďē ƒōŕ ŕēćōvēŕŷ ƀēƒōŕē ƥēŕḿàńēńţ ďēĺēţĩōń",
+  "storageQuarantineMovedAside_other": "{{count}} ĩţēḿś ḿōvēď àśĩďē ƒōŕ ŕēćōvēŕŷ ƀēƒōŕē ƥēŕḿàńēńţ ďēĺēţĩōń",
+  "storageDockerUnmeasured": "Ďōćķēŕ ũśàĝē ćōũĺď ńōţ ƀē ḿēàśũŕēď",
+  "storageKandevContainers": "Ķàńďēv ćōńţàĩńēŕś",
+  "storageManagedContainerCount_one": "{{count}} ḿàńàĝēď ćōńţàĩńēŕ",
+  "storageManagedContainerCount_other": "{{count}} ḿàńàĝēď ćōńţàĩńēŕś",
+  "storageGoBuildCache": "Ĝō ƀũĩĺď ćàćĥē",
+  "storageUserGoBuildCache": "Ũśēŕ Ĝō ƀũĩĺď ćàćĥē",
+  "storageDockerImageLayers": "Ďōćķēŕ ĩḿàĝē ĺàŷēŕś",
+  "storageDefaultDockerHost": "Ďēƒàũĺţ Ďōćķēŕ ĥōśţ",
+  "storageDockerBuildCache": "Ďōćķēŕ ƀũĩĺď ćàćĥē",
+  "storageUnusedDockerImages": "Ũńũśēď Ďōćķēŕ ĩḿàĝēś",
+  "storageUnusedImagesDetail": "Ũńũśēď ƀŷ ēvēŕŷ ćōńţàĩńēŕ àńď ōĺďēŕ ţĥàń ţĥē ćōńƒĩĝũŕēď àĝē",
+  "storageCleanGoCache": "Ćĺēàń Ĝō ćàćĥē",
+  "storageGoCacheNotOwned": "Ōńĺŷ à Ķàńďēv-ōŵńēď Ĝō ƀũĩĺď ćàćĥē ćàń ƀē ćĺēàńēď.",
+  "storageGoCacheBelowLimit": "Ţĥē Ĝō ƀũĩĺď ćàćĥē ĩś ƀēĺōŵ ĩţś ćōńƒĩĝũŕēď śĩźē ĺĩḿĩţ.",
+  "storagePolicyTitle": "Ḿàĩńţēńàńćē ƥōĺĩćŷ",
+  "storagePolicyDescription": "Ćĥōōśē ŵĥàţ Ķàńďēv ḿàŷ ŕēćĺàĩḿ àũţōḿàţĩćàĺĺŷ àńď ţĥē śàƒēţŷ ĺĩḿĩţś ĩţ ḿũśţ ƒōĺĺōŵ.",
+  "storageMoreInformationAbout": "Ḿōŕē ĩńƒōŕḿàţĩōń àƀōũţ {{label}}",
+  "storageScheduleTitle": "Śćĥēďũĺē",
+  "storageScheduleDescription": "Ćōńţŕōĺś ŵĥēń àũţōḿàţĩć ḿàĩńţēńàńćē ĩś àĺĺōŵēď ţō śţàŕţ. Ḿàńũàĺ àćţĩōńś ŕēḿàĩń àvàĩĺàƀĺē ŵĥēń śćĥēďũĺĩńĝ ĩś ōƒƒ.",
+  "storageScheduledMaintenance": "Śćĥēďũĺēď ḿàĩńţēńàńćē",
+  "storageScheduledMaintenanceDescription": "Ƥēŕĩōďĩćàĺĺŷ ŕēćĺàĩḿ ďĩśķ śƥàćē ũśĩńĝ ţĥē ēńàƀĺēď ŕēśōũŕćē ŕũĺēś.",
+  "storageScheduledMaintenanceHelp": "Ŵĥēń ēńàƀĺēď, Ķàńďēv ćĥēćķś ţĥĩś ƥōĺĩćŷ àţ ţĥē ćōńƒĩĝũŕēď ĩńţēŕvàĺ àńď śţàŕţś ōńĺŷ àƒţēŕ Ķàńďēv ĥàś ƀēēń ĩďĺē ƒōŕ ţĥē ŕēqũĩŕēď ƥēŕĩōď. Ţũŕńĩńĝ ĩţ ōƒƒ ďōēś ńōţ ďĩśàƀĺē Àńàĺŷźē ōŕ Ŕũń ńōŵ.",
+  "storageCheckIntervalLabel": "Ćĥēćķ ēvēŕŷ (ĥōũŕś)",
+  "storageCheckIntervalHelp": "Ĥōŵ ōƒţēń Ķàńďēv ćĥēćķś ŵĥēţĥēŕ śćĥēďũĺēď ḿàĩńţēńàńćē ĩś ďũē. À ćĥēćķ ţĥàţ ƒĩńďś Ķàńďēv ƀũśŷ ĩś śķĩƥƥēď àńď ţŕĩēď àĝàĩń àţ ţĥē ńēxţ ĩńţēŕvàĺ.",
+  "storageIdleLabel": "Ŕēqũĩŕē ĩďĺē ƒōŕ (ḿĩńũţēś)",
+  "storageIdleHelp": "Śćĥēďũĺēď ćĺēàńũƥ śţàŕţś ōńĺŷ àƒţēŕ ńō ţàśķ, śĥēĺĺ ćōḿḿàńď, ţēśţ, śēţũƥ, ćĺēàńũƥ, ōŕ ĩḿàĝē ƀũĩĺď ĥàś ũśēď ḿàńàĝēď ŕēśōũŕćēś ƒōŕ ţĥĩś ĺōńĝ. Ŕũń ńōŵ ďōēś ńōţ ŵàĩţ ƒōŕ ţĥĩś ţĩḿēŕ, ƀũţ ĩţ śţĩĺĺ ŕēƒũśēś ţō ŕũń ŵĥĩĺē ŕēśōũŕćēś àŕē àćţĩvē.",
+  "storageWorkspacesTitle": "Ŵōŕķśƥàćēś àńď ćōńţàĩńēŕś",
+  "storageWorkspacesDescription": "Ŕēćĺàĩḿ ŕēśōũŕćēś ţĥàţ Ķàńďēv ćàń ƥōśĩţĩvēĺŷ ĩďēńţĩƒŷ àś ńō ĺōńĝēŕ ĩń ũśē.",
+  "storageOrphanWorkspaces": "Ōŕƥĥàń ţàśķ ŵōŕķśƥàćēś",
+  "storageOrphanWorkspacesDescription": "Ḿōvē ćōńƒĩŕḿēď ōŕƥĥàń ŵōŕķśƥàćēś ţō qũàŕàńţĩńē.",
+  "storageOrphanWorkspacesHelp": "Ķàńďēv ōńĺŷ śēĺēćţś à ţàśķ ŵōŕķśƥàćē àƒţēŕ ĩńvēńţōŕŷ ćōńƒĩŕḿś ţĥàţ ńō àćţĩvē ţàśķ, ēńvĩŕōńḿēńţ, śēśśĩōń, ōŕ ƥŕōţēćţēď ŵōŕķţŕēē ũśēś ĩţ. Ţĥē ŵōŕķśƥàćē ĩś ḿōvēď ţō qũàŕàńţĩńē ƒĩŕśţ, ŵĥēŕē ĩţ ćàń ƀē ŕēśţōŕēď ƀēƒōŕē ƥēŕḿàńēńţ ďēĺēţĩōń.",
+  "storageCleanOrphanWorkspacesAria": "Ćĺēàń ōŕƥĥàń ţàśķ ŵōŕķśƥàćēś",
+  "storageOrphanGraceLabel": "Ŵàĩţ ƀēƒōŕē ōŕƥĥàńĩńĝ (ĥōũŕś)",
+  "storageOrphanGraceHelp": "À ŵōŕķśƥàćē ḿũśţ ƀē ũńũśēď ƒōŕ àţ ĺēàśţ ţĥĩś ĺōńĝ ƀēƒōŕē ĩţ ćàń ƀē ćĺàśśĩƒĩēď àś àń ōŕƥĥàń. Ĩńćŕēàśĩńĝ ţĥĩś vàĺũē ķēēƥś ōĺď ŵōŕķśƥàćēś ĺōńĝēŕ ƀēƒōŕē ţĥēŷ ēńţēŕ qũàŕàńţĩńē.",
+  "storageContainersDescription": "Ŕēḿōvē śţōƥƥēď, ũńũśēď ćōńţàĩńēŕś ćŕēàţēď àńď ĺàƀēĺēď ƀŷ Ķàńďēv.",
+  "storageContainersHelp": "Ōńĺŷ śţōƥƥēď ćōńţàĩńēŕś ĺàƀēĺēď àś Ķàńďēv-ḿàńàĝēď àŕē ćōńśĩďēŕēď, àńď ĩńvēńţōŕŷ ḿũśţ ćōńƒĩŕḿ ţĥēŷ àŕē ńō ĺōńĝēŕ ńēēďēď. Ŕũńńĩńĝ ćōńţàĩńēŕś àńď ũńŕēĺàţēď Ďōćķēŕ ćōńţàĩńēŕś àŕē ńēvēŕ ŕēḿōvēď ƀŷ ţĥĩś ōƥţĩōń.",
+  "storageCleanContainersAria": "Ćĺēàń Ķàńďēv ćōńţàĩńēŕś",
+  "storageGoCacheSectionDescription": "Ũśē àńď ţŕĩḿ à Ķàńďēv-ōŵńēď ćàćĥē ƒōŕ ńēŵ ĥōśţ-ĺōćàĺ ēxēćũţĩōńś.",
+  "storageManagedGoCache": "Ḿàńàĝēď Ĝō ćàćĥē",
+  "storageManagedGoCacheDescription": "Ńēŵ ĥōśţ-ĺōćàĺ ēxēćũţĩōńś ũśē {{path}}.",
+  "storageManagedGoCacheHelp": "Ŵĥēń ēńàƀĺēď, Ķàńďēv ĝĩvēś ńēŵ ĺōćàĺ ţàśķ ƥŕōćēśśēś à ďēďĩćàţēď Ĝō ƀũĩĺď ćàćĥē àńď ḿàŷ ŕōţàţē ĩţ ďũŕĩńĝ ḿàĩńţēńàńćē ŵĥēń ĩţ ēxćēēďś ţĥē ḿàxĩḿũḿ. Ţũŕńĩńĝ ţĥĩś ōƒƒ śţōƥś ũśĩńĝ ţĥē ḿàńàĝēď ćàćĥē ƒōŕ ńēŵ ēxēćũţĩōńś ƀũţ ďōēś ńōţ ďēĺēţē ĩţ.",
+  "storageEnableManagedGoCacheAria": "Ēńàƀĺē ḿàńàĝēď Ĝō ćàćĥē",
+  "storageGoCacheMaxLabel": "Ḿàxĩḿũḿ ćàćĥē śĩźē (ĜƁ)",
+  "storageGoCacheMaxHelp": "Ţĥĩś ĩś à ćĺēàńũƥ ţŕĩĝĝēŕ, ńōţ à ĥàŕď qũōţà. Ţĥē ćàćĥē ḿàŷ ĝŕōŵ ƥàśţ ţĥĩś śĩźē ŵĥĩĺē ţàśķś àŕē àćţĩvē. Ḿàĩńţēńàńćē ŕōţàţēś ţĥē ōŵńēď ćàćĥē ĩńţō qũàŕàńţĩńē àńď ŕēćŕēàţēś àń ēḿƥţŷ ćàćĥē àƒţēŕ ţĥē ĺĩḿĩţ ĩś ēxćēēďēď.",
+  "storageExternalGoCache": "Ēxţēŕńàĺ Ĝō ćàćĥē",
+  "storageExternalGoCacheHelp": "Àďōƥţĩōń ĝĩvēś Ķàńďēv ēxƥĺĩćĩţ ƥēŕḿĩśśĩōń ţō ŕōţàţē ţĥĩś ēxĩśţĩńĝ ćàćĥē. Ķàńďēv ńēvēŕ ćĺēàńś à ďēƒàũĺţ ũśēŕ ćàćĥē ōŕ àńōţĥēŕ ƥàţĥ ũńĺēśś ŷōũ àďōƥţ ţĥàţ ēxàćţ àƀśōĺũţē ƥàţĥ àńď ćōńƒĩŕḿ ţĥē ďēśţŕũćţĩvē àććēśś.",
+  "storageExternalGoCacheDescription": "Ōƥţĩōńàĺĺŷ àĺĺōŵ Ķàńďēv ţō ḿàĩńţàĩń àń ēxĩśţĩńĝ ĥōśţ ćàćĥē ōũţśĩďē ĩţś ḿàńàĝēď ƥàţĥ.",
+  "storageEnableGoCacheFirst": "Ēńàƀĺē ţĥē ḿàńàĝēď Ĝō ćàćĥē ƒĩŕśţ.",
+  "storageEnterCachePathFirst": "Ēńţēŕ àń àƀśōĺũţē ćàćĥē ƥàţĥ ƒĩŕśţ.",
+  "storageAdoptCache": "Àďōƥţ ćàćĥē",
+  "storageDockerTitle": "Ďōćķēŕ ćĺēàńũƥ",
+  "storageDockerDescription": "Ōƥţĩōńàĺ ďàēḿōń-ŵĩďē ćĺēàńũƥ. Ēńàƀĺē ĩţ ōńĺŷ ŵĥēń ţĥĩś Ďōćķēŕ ďàēḿōń ĩś ďēďĩćàţēď ţō Ķàńďēv.",
+  "storageDockerUnavailable": "Ďōćķēŕ ĩś ũńàvàĩĺàƀĺē ōń ţĥē ćōńƒĩĝũŕēď ĥōśţ.",
+  "storageDockerUnavailableNotice": "Ďōćķēŕ ĩś ũńàvàĩĺàƀĺē; Ďōćķēŕ ćĺēàńũƥ ōƥţĩōńś ćàńńōţ ŕũń ōń ţĥĩś ĥōśţ.",
+  "storageAcknowledgeDedicatedFirst": "Àćķńōŵĺēďĝē à ďēďĩćàţēď Ďōćķēŕ ďàēḿōń ƒĩŕśţ.",
+  "storageDedicatedDaemon": "Ďēďĩćàţēď Ďōćķēŕ ďàēḿōń",
+  "storageDedicatedDaemonDescription": "Ćōńƒĩŕḿ ţĥàţ ũńŕēĺàţēď ŵōŕķĺōàďś ďō ńōţ śĥàŕē ţĥĩś Ďōćķēŕ ďàēḿōń.",
+  "storageDedicatedDaemonHelp": "Ɓũĩĺď ćàćĥē àńď ĩḿàĝē ōŵńēŕśĥĩƥ ćàńńōţ ƀē àţţŕĩƀũţēď ŕēĺĩàƀĺŷ ţō Ķàńďēv. Ţĥĩś àćķńōŵĺēďĝḿēńţ ũńĺōćķś ďàēḿōń-ŵĩďē ćĺēàńũƥ àńď śĥōũĺď ōńĺŷ ƀē ēńàƀĺēď ŵĥēń ţĥē ćōńƒĩĝũŕēď Ďōćķēŕ ďàēḿōń ĩś ũśēď ēxćĺũśĩvēĺŷ ƀŷ Ķàńďēv. Ķàńďēv ńēvēŕ ƥēŕƒōŕḿś à vōĺũḿē-ŵĩďē ƥŕũńē.",
+  "storageDockerBuildCacheDescription": "Ŕēḿōvē ōĺď ƀũĩĺď ćàćĥē ŵĥĩĺē ŕēţàĩńĩńĝ ţĥē ćōńƒĩĝũŕēď àḿōũńţ.",
+  "storageDockerBuildCacheHelp": "Ũśēś Ďōćķēŕ'ś àĝē àńď śţōŕàĝē ƒĩĺţēŕś ţō ŕēḿōvē ōĺď ƀũĩĺď ćàćĥē. Ĩţ ďōēś ńōţ ŕũń ďōćķēŕ śŷśţēḿ ƥŕũńē, ďōēś ńōţ ŕēḿōvē vōĺũḿēś ĝĺōƀàĺĺŷ, àńď ŕēḿàĩńś ďĩśàƀĺēď ũńţĩĺ ţĥē ďēďĩćàţēď-ďàēḿōń àćķńōŵĺēďĝḿēńţ ĩś ćōńƒĩŕḿēď.",
+  "storageCleanDockerBuildCacheAria": "Ćĺēàń Ďōćķēŕ ƀũĩĺď ćàćĥē",
+  "storageBuildCacheKeepLabel": "Ɓũĩĺď ćàćĥē ţō ŕēţàĩń (ĜƁ)",
+  "storageBuildCacheKeepHelp": "Ďōćķēŕ ķēēƥś àƥƥŕōxĩḿàţēĺŷ ţĥĩś ḿũćĥ ƀũĩĺď ćàćĥē ŵĥēń ƥŕũńĩńĝ ēĺĩĝĩƀĺē ŕēćōŕďś. À ĺàŕĝēŕ vàĺũē ƥŕēśēŕvēś ḿōŕē ŕēũśàƀĺē ƀũĩĺď ĺàŷēŕś ƀũţ ŕēćĺàĩḿś ĺēśś ďĩśķ śƥàćē.",
+  "storageBuildCacheUnusedLabel": "Ɓũĩĺď ćàćĥē ḿũśţ ƀē ũńũśēď ƒōŕ (ĥōũŕś)",
+  "storageBuildCacheUnusedHelp": "Ōńĺŷ ƀũĩĺď ćàćĥē ŕēćōŕďś ōĺďēŕ ţĥàń ţĥĩś ũńũśēď-àĝē ţĥŕēśĥōĺď àŕē ēĺĩĝĩƀĺē. Ĩńćŕēàśĩńĝ ĩţ ƥŕōţēćţś ŕēćēńţ ƀũĩĺď ĺàŷēŕś ƒōŕ ĺōńĝēŕ.",
+  "storageUnusedImagesDescription": "Ŕēḿōvē ōĺď ĩḿàĝēś ţĥàţ ńō ćōńţàĩńēŕ ũśēś.",
+  "storageUnusedImagesHelp": "Ŕēḿōvēś àń ĩḿàĝē ōńĺŷ ŵĥēń ńō ŕũńńĩńĝ ōŕ śţōƥƥēď ćōńţàĩńēŕ ŕēƒēŕēńćēś ĩţ àńď ĩţ ĩś ōĺďēŕ ţĥàń ţĥē ćōńƒĩĝũŕēď àĝē. Ţĥĩś ĩś ďàēḿōń-ŵĩďē àńď ţĥēŕēƒōŕē ŕēqũĩŕēś ţĥē ďēďĩćàţēď-ďàēḿōń àćķńōŵĺēďĝḿēńţ.",
+  "storageCleanUnusedImagesAria": "Ćĺēàń ũńũśēď Ďōćķēŕ ĩḿàĝēś",
+  "storageUnusedImagesHoursLabel": "Ĩḿàĝē ḿũśţ ƀē ũńũśēď ƒōŕ (ĥōũŕś)",
+  "storageUnusedImagesHoursHelp": "Àń ĩḿàĝē ḿũśţ ƀē ũńũśēď ƀŷ ēvēŕŷ ćōńţàĩńēŕ àńď ōĺďēŕ ţĥàń ţĥĩś àĝē ƀēƒōŕē Ķàńďēv ćàń ŕēḿōvē ĩţ. Ĩńćŕēàśĩńĝ ţĥē vàĺũē ķēēƥś ōĺď ĩḿàĝēś àvàĩĺàƀĺē ƒōŕ ĺōńĝēŕ.",
+  "storageQuarantineSafetyTitle": "Qũàŕàńţĩńē śàƒēţŷ",
+  "storageQuarantineSafetyDescription": "Ķēēƥ ŕēćōvēŕàƀĺē ŕēśōũŕćēś ƒōŕ à ĝŕàćē ƥēŕĩōď ƀēƒōŕē ƥēŕḿàńēńţ ďēĺēţĩōń.",
+  "storageQuarantineRetentionLabel": "Ķēēƥ qũàŕàńţĩńēď ĩţēḿś ƒōŕ (ĥōũŕś)",
+  "storageQuarantineRetentionHelp": "Ćĺēàńũƥ ƒĩŕśţ ḿōvēś ōŕƥĥàń ŵōŕķśƥàćēś àńď ŕōţàţēď Ĝō ćàćĥēś ĩńţō Ķàńďēv'ś ţŕàśĥ àŕēà ĩńśţēàď ōƒ ďēĺēţĩńĝ ţĥēḿ ĩḿḿēďĩàţēĺŷ. Ďũŕĩńĝ ţĥĩś ŕēţēńţĩōń ƥēŕĩōď ŷōũ ćàń ŕēśţōŕē àń ĩţēḿ. Àƒţēŕ ţĥē ďēàďĺĩńē, à ĺàţēŕ ḿàĩńţēńàńćē ŕũń ḿàŷ ƥēŕḿàńēńţĺŷ ďēĺēţē ĩţ.",
+  "storageTypeToConfirm": "Ţŷƥē <1>{{phrase}}</1> ţō ćōńţĩńũē.",
+  "storageTypeToConfirmAria": "Ţŷƥē {{phrase}} ţō ćōńƒĩŕḿ",
+  "storageDedicatedDialogTitle": "Ũśē ţĥĩś ďēďĩćàţēď Ďōćķēŕ ďàēḿōń",
+  "storageDedicatedDialogDescription": "Ɓũĩĺď-ćàćĥē àńď ũńũśēď-ĩḿàĝē ćĺēàńũƥ àƒƒēćţ ţĥē ēńţĩŕē ćōńƒĩĝũŕēď ďàēḿōń, ĩńćĺũďĩńĝ ŕēśōũŕćēś ćŕēàţēď ōũţśĩďē Ķàńďēv. Ōńĺŷ àćķńōŵĺēďĝē à ďàēḿōń ďēďĩćàţēď ţō ţĥĩś ĩńśţàĺĺàţĩōń.",
+  "storageAcknowledgeDaemon": "Àćķńōŵĺēďĝē ďàēḿōń",
+  "storageAdoptDialogTitle": "Àďōƥţ àń ēxţēŕńàĺ Ĝō ƀũĩĺď ćàćĥē",
+  "storageAdoptDialogDescription": "Ķàńďēv ŵĩĺĺ ƀē àĺĺōŵēď ţō ŕōţàţē àńď qũàŕàńţĩńē ţĥē ēxĩśţĩńĝ ćàćĥē àţ {{path}}. Ţĥĩś ƥàţĥ ḿũśţ ƀē àƀśōĺũţē àńď ōń ţĥē śàḿē ƒĩĺēśŷśţēḿ àś Ķàńďēv ţŕàśĥ.",
+  "storageAdoptDialogFallbackPath": "ţĥē śēĺēćţēď ƥàţĥ",
+  "storageDeleteDialogTitle": "Ƥēŕḿàńēńţĺŷ ďēĺēţē qũàŕàńţĩńēď ďàţà",
+  "storageDeleteDialogDescription": "Ţĥĩś ćàńńōţ ƀē ũńďōńē. Ķàńďēv ŵĩĺĺ ƥēŕḿàńēńţĺŷ ŕēḿōvē {{path}}.",
+  "storageDeleteDialogFallbackPath": "ţĥē śēĺēćţēď qũàŕàńţĩńē ēńţŕŷ",
+  "storageDeletePermanently": "Ďēĺēţē ƥēŕḿàńēńţĺŷ",
+  "storageClearEligibleDialogTitle": "Ćĺēàŕ ēĺĩĝĩƀĺē qũàŕàńţĩńē",
+  "storageForceClearDialogTitle": "Ƒōŕćē ćĺēàŕ àĺĺ qũàŕàńţĩńē",
+  "storagePurgeEligibleCount_one": "Ţĥĩś ŵĩĺĺ ƥēŕḿàńēńţĺŷ ŕēḿōvē {{count}} ēĺĩĝĩƀĺē ĩţēḿ.",
+  "storagePurgeEligibleCount_other": "Ţĥĩś ŵĩĺĺ ƥēŕḿàńēńţĺŷ ŕēḿōvē {{count}} ēĺĩĝĩƀĺē ĩţēḿś.",
+  "storagePurgeProtectedCount_one": "{{count}} ƥŕōţēćţēď ĩţēḿ ŕēḿàĩńś ũńţĩĺ ĩţś ŕēţēńţĩōń ďēàďĺĩńē.",
+  "storagePurgeProtectedCount_other": "{{count}} ƥŕōţēćţēď ĩţēḿś ŕēḿàĩń ũńţĩĺ ţĥēĩŕ ŕēţēńţĩōń ďēàďĺĩńēś.",
+  "storageForceClearDescription": "Ţĥĩś àţţēḿƥţś ţō ƥēŕḿàńēńţĺŷ ŕēḿōvē ēvēŕŷ qũàŕàńţĩńēď ĩţēḿ ĩḿḿēďĩàţēĺŷ àńď ćàńńōţ ƀē ũńďōńē ƒōŕ ēńţŕĩēś ţĥàţ śũććēēď. Ƒàĩĺēď ēńţŕĩēś ḿàŷ ŕēḿàĩń vĩśĩƀĺē àńď ŕēţŕŷàƀĺē.",
+  "storageQuarantineHeading": "Qũàŕàńţĩńē",
+  "storageQuarantineHelp": "Qũàŕàńţĩńē ĩś Ķàńďēv'ś ŕēćōvēŕàƀĺē ĥōĺďĩńĝ àŕēà. Ōŕƥĥàń ţàśķ ŵōŕķśƥàćēś àńď ŕōţàţēď Ĝō ćàćĥēś àŕē ḿōvēď ĥēŕē ƀēƒōŕē ďēĺēţĩōń. Ŷōũ ćàń ŕēśţōŕē àń ĩţēḿ ďũŕĩńĝ ĩţś ŕēţēńţĩōń ƥēŕĩōď; àƒţēŕ ţĥē ďēàďĺĩńē, à ĺàţēŕ ḿàĩńţēńàńćē ŕũń ḿàŷ ƥēŕḿàńēńţĺŷ ďēĺēţē ĩţ.",
+  "storageQuarantineCardDescription": "Ćĺēàńũƥ ḿōvēś ŕēćōvēŕàƀĺē ďàţà ĥēŕē ƒĩŕśţ ĩńśţēàď ōƒ ďēĺēţĩńĝ ĩţ ĩḿḿēďĩàţēĺŷ. Ŕēśţōŕē àń ĩţēḿ ĩƒ ŷōũ śţĩĺĺ ńēēď ĩţ, ōŕ ďēĺēţē ĩţ ƥēŕḿàńēńţĺŷ ŵĥēń ŷōũ àŕē ćēŕţàĩń.",
+  "storageQuarantineEligibleCount_one": "{{count}} ēĺĩĝĩƀĺē ńōŵ",
+  "storageQuarantineEligibleCount_other": "{{count}} ēĺĩĝĩƀĺē ńōŵ",
+  "storageQuarantineProtectedCount_one": "{{count}} ƥŕōţēćţēď",
+  "storageQuarantineProtectedCount_other": "{{count}} ƥŕōţēćţēď",
+  "storageQuarantineScheduleOn_one": "Ēĺĩĝĩƀĺē ēńţŕĩēś àŕē ŕēḿōvēď ƀŷ ţĥē ƒĩŕśţ śũććēśśƒũĺ ḿàĩńţēńàńćē ŕũń àƒţēŕ ţĥēĩŕ ďēàďĺĩńē (ēvēŕŷ {{count}} ĥōũŕ ŵĥēń ţĥē ĩďĺē ĝàţē àĺĺōŵś ĩţ).",
+  "storageQuarantineScheduleOn_other": "Ēĺĩĝĩƀĺē ēńţŕĩēś àŕē ŕēḿōvēď ƀŷ ţĥē ƒĩŕśţ śũććēśśƒũĺ ḿàĩńţēńàńćē ŕũń àƒţēŕ ţĥēĩŕ ďēàďĺĩńē (ēvēŕŷ {{count}} ĥōũŕś ŵĥēń ţĥē ĩďĺē ĝàţē àĺĺōŵś ĩţ).",
+  "storageQuarantineScheduleOff": "Àũţōḿàţĩć qũàŕàńţĩńē ćĺēàńũƥ ĩś ōƒƒ. Ŕũń ḿàĩńţēńàńćē ḿàńũàĺĺŷ ōŕ ũśē à qũàŕàńţĩńē àćţĩōń ŵĥēń ŷōũ àŕē ŕēàďŷ.",
+  "storageQuarantineTotal": "Ţōţàĺ qũàŕàńţĩńēď: {{size}}",
+  "storageQuarantineLoading": "Ĺōàďĩńĝ qũàŕàńţĩńē…",
+  "storageQuarantineEmpty": "Ńō ŕēśţōŕàƀĺē qũàŕàńţĩńēď ŕēśōũŕćēś.",
+  "storageNoEligibleEntries": "Ńō qũàŕàńţĩńē ēńţŕĩēś àŕē ēĺĩĝĩƀĺē ŷēţ.",
+  "storageQuarantineCleanupRunning": "À qũàŕàńţĩńē ćĺēàńũƥ ĩś śţĩĺĺ ŕũńńĩńĝ.",
+  "storageClearEligible": "Ćĺēàŕ ēĺĩĝĩƀĺē",
+  "storageForceClearAll": "Ƒōŕćē ćĺēàŕ àĺĺ",
+  "storageDeletionComplete": "Ďēĺēţĩōń ćōḿƥĺēţē",
+  "storageResourceTypeTaskWorkspace": "ţàśķ ŵōŕķśƥàćē",
+  "storageResourceTypeGoCache": "ĝō ćàćĥē",
+  "storageTrashPath": "Ţŕàśĥ: {{path}}",
+  "storageEligibleNow": "Ēĺĩĝĩƀĺē ńōŵ",
+  "storageProtectedUntil": "Ƥŕōţēćţēď ũńţĩĺ <1>{{deadline}}</1>",
+  "storageRestore": "Ŕēśţōŕē",
+  "storageDelete": "Ďēĺēţē",
+  "storageRetentionEnds": "Ŕēţēńţĩōń ēńďś {{deadline}}.",
+  "storageMaintenanceHistory": "Ḿàĩńţēńàńćē ĥĩśţōŕŷ",
+  "storageHistoryLoading": "Ĺōàďĩńĝ ḿàĩńţēńàńćē ĥĩśţōŕŷ…",
+  "storageHistoryEmpty": "Ńō śţōŕàĝē ḿàĩńţēńàńćē ŕũńś ŷēţ.",
+  "storageToastPolicySaved": "Śţōŕàĝē ƥōĺĩćŷ śàvēď",
+  "storageToastCacheAdopted": "Ĝō ƀũĩĺď ćàćĥē àďōƥţēď",
+  "storageToastDeletionStarted": "Ƥēŕḿàńēńţ ďēĺēţĩōń śţàŕţēď",
+  "storageToastEligiblePurgeStarted": "Ēĺĩĝĩƀĺē qũàŕàńţĩńē ćĺēàńũƥ śţàŕţēď",
+  "storageToastForcedPurgeStarted": "Ƒōŕćēď qũàŕàńţĩńē ćĺēàńũƥ śţàŕţēď",
+  "storageToastAnalysisStarted": "Śţōŕàĝē àńàĺŷśĩś śţàŕţēď",
+  "storageToastMaintenanceStarted": "Śţōŕàĝē ḿàĩńţēńàńćē śţàŕţēď",
+  "storageToastQuarantineRestored": "Qũàŕàńţĩńēď ŕēśōũŕćē ŕēśţōŕēď",
+  "storageRefreshFailed": "Ŕēƒŕēśĥ śţōŕàĝē ďàţà: {{message}}"
+}