From c5e2acf30b42a2921a31fa491ad85575e3524c28 Mon Sep 17 00:00:00 2001
From: Vigneshraj Sekar Babu <vignesh.raj47@gmail.com>
Date: Fri, 9 Oct 2026 15:36:17 -0700
Subject: [PATCH 1/2] chore: update sites api types

Regenerated with pnpm generate:api; only the Sites types this change
uses are committed.
---
 src/lib/generated/listSitesParams.ts   | 3 +++
 src/lib/generated/listSitesView.ts     | 1 +
 src/lib/generated/site.ts              | 7 +++++++
 src/lib/generated/sitePermissions.ts   | 1 +
 src/lib/generated/siteStatus.ts        | 1 +
 src/lib/generated/sitesCapabilities.ts | 5 +++++
 tests/sites.test.ts                    | 1 +
 7 files changed, 19 insertions(+)

diff --git a/src/lib/generated/listSitesParams.ts b/src/lib/generated/listSitesParams.ts
index 0065661..d46093d 100644
--- a/src/lib/generated/listSitesParams.ts
+++ b/src/lib/generated/listSitesParams.ts
@@ -8,6 +8,9 @@
 import type { ListSitesView } from './listSitesView.js';
 
 export type ListSitesParams = {
+/**
+ * deleted lists the caller's deleted sites that can still be restored.
+ */
 view?: ListSitesView;
 q?: string;
 /**
diff --git a/src/lib/generated/listSitesView.ts b/src/lib/generated/listSitesView.ts
index 8d3ba8a..d62d5a4 100644
--- a/src/lib/generated/listSitesView.ts
+++ b/src/lib/generated/listSitesView.ts
@@ -14,4 +14,5 @@ export const ListSitesView = {
   mine: 'mine',
   public: 'public',
   all: 'all',
+  deleted: 'deleted',
 } as const;
diff --git a/src/lib/generated/site.ts b/src/lib/generated/site.ts
index 8e2a9b5..4132820 100644
--- a/src/lib/generated/site.ts
+++ b/src/lib/generated/site.ts
@@ -34,6 +34,13 @@ export interface Site {
   updatedAt: string | null;
   /** @nullable */
   expiresAt: string | null;
+  /** @nullable */
+  deletedAt: string | null;
+  /**
+   * Last moment a deleted site can be restored; null unless the site is deleted.
+   * @nullable
+   */
+  restorableUntil: string | null;
   /** @minimum 0 */
   fileCount: number;
   /** @minimum 0 */
diff --git a/src/lib/generated/sitePermissions.ts b/src/lib/generated/sitePermissions.ts
index ea48c03..38ae1a5 100644
--- a/src/lib/generated/sitePermissions.ts
+++ b/src/lib/generated/sitePermissions.ts
@@ -11,4 +11,5 @@ export type SitePermissions = {
   canEdit: boolean;
   canDelete: boolean;
   canChangeVisibility: boolean;
+  canRestore: boolean;
 };
diff --git a/src/lib/generated/siteStatus.ts b/src/lib/generated/siteStatus.ts
index 58b466d..30df403 100644
--- a/src/lib/generated/siteStatus.ts
+++ b/src/lib/generated/siteStatus.ts
@@ -14,4 +14,5 @@ export const SiteStatus = {
   active: 'active',
   deleted: 'deleted',
   expired: 'expired',
+  purged: 'purged',
 } as const;
diff --git a/src/lib/generated/sitesCapabilities.ts b/src/lib/generated/sitesCapabilities.ts
index 4bb8acd..e1ac9d7 100644
--- a/src/lib/generated/sitesCapabilities.ts
+++ b/src/lib/generated/sitesCapabilities.ts
@@ -15,4 +15,9 @@ export interface SitesCapabilities {
   defaultVisibility: SitesCapabilitiesDefaultVisibility;
   allowedVisibilities: SitesCapabilitiesAllowedVisibilitiesItem[];
   upload: SitesCapabilitiesUpload;
+  /**
+   * Days a deleted site stays restorable before its content is purged.
+   * @minimum 0
+   */
+  deletedRetentionDays: number;
 }
diff --git a/tests/sites.test.ts b/tests/sites.test.ts
index 6668b9f..c60cdec 100644
--- a/tests/sites.test.ts
+++ b/tests/sites.test.ts
@@ -12,6 +12,7 @@ const capabilities: SitesCapabilities = {
   defaultVisibility: 'public',
   allowedVisibilities: ['public'],
   upload: { maxUploadBytes: 100, maxExtractedBytes: 100, maxFiles: 3, allowedExtensions: ['html'] },
+  deletedRetentionDays: 30,
 };
 afterEach(() => vi.unstubAllGlobals());
 function mockResponse(data: unknown) {

From 872ab70351836e989dc1dddcaad75393996a6d7f Mon Sep 17 00:00:00 2001
From: Vigneshraj Sekar Babu <vignesh.raj47@gmail.com>
Date: Fri, 9 Oct 2026 15:36:43 -0700
Subject: [PATCH 2/2] feat(sites): add restore command and deleted listing

Add lfc sites restore <id> and lfc sites list --deleted, show how long
deleted sites are kept (from sites capabilities), and point delete output
at restore. The delete prompt only promises a restore window when the
server reports one.
---
 README.md                   |   6 +-
 src/commands/llms.ts        |   5 +-
 src/commands/sites.ts       |  72 ++++++++++++++++++--
 src/lib/api.ts              |   7 ++
 src/lib/sites.ts            |  12 +++-
 tests/sites-command.test.ts | 127 +++++++++++++++++++++++++++++++++++-
 tests/sites.test.ts         |  24 ++++++-
 7 files changed, 240 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index 0839331..6df5c4d 100644
--- a/README.md
+++ b/README.md
@@ -159,7 +159,7 @@ Runs fully offline (no auth needed) except `--repo/--branch`. Exit codes: `0` va
 
 Upload a ZIP, a single HTML file, or a directory (auto-zipped) and get a stable URL back:
 
-User and personal-key uploads are private by default. Service-key uploads default to public for automation. An explicit unsupported visibility is rejected before upload. Only the owner can replace, extend, delete, or change visibility. Public sites allow anyone with the link to view them.
+User and personal-key uploads are private by default. Service-key uploads default to public for automation. An explicit unsupported visibility is rejected before upload. Only the owner can replace, extend, delete, restore, or change visibility. Public sites allow anyone with the link to view them.
 
 Use `openUrl` for a stable opening link. Visibility changes keep the Site ID and content URL; saved copies cannot be recalled. Named-user sharing is not included in this version.
 
@@ -176,7 +176,9 @@ lfc sites get a1b2c3d4e5
 lfc sites update a1b2c3d4e5 ./dist       # replace content (new version)
 lfc sites visibility a1b2c3d4e5 private --yes
 lfc sites extend a1b2c3d4e5              # push out the TTL/expiry
-lfc sites delete a1b2c3d4e5 --yes
+lfc sites delete a1b2c3d4e5 --yes       # recoverable until its restore deadline
+lfc sites list --deleted                 # your deleted sites that can still be restored
+lfc sites restore a1b2c3d4e5             # same id and URL as before
 ```
 
 Directory uploads honor default ignores such as `.git`, `node_modules`, `.DS_Store`, `.next/cache`, `dist/.cache`, and `coverage`.
diff --git a/src/commands/llms.ts b/src/commands/llms.ts
index 6a63dcf..274973d 100644
--- a/src/commands/llms.ts
+++ b/src/commands/llms.ts
@@ -152,12 +152,13 @@ Static sites:
 
     lfc sites create <file-or-dir> [--name <label>] [--visibility private|public]
     # User uploads default to private. Add --visibility public --yes to publish.
-    lfc sites list [--mine | --public]
+    lfc sites list [--mine | --public | --deleted]   # --deleted shows your restorable deleted sites
     lfc sites get <id>
     lfc sites update <id> <file-or-dir>
     lfc sites visibility <id> <private|public> --yes  # keeps the content URL
     lfc sites extend <id>                              # push out the expiry
-    lfc sites delete <id> --yes
+    lfc sites delete <id> --yes                        # recoverable until restorableUntil
+    lfc sites restore <id>                             # undo a delete; same id and URL
 
 ## Recipes for common agent tasks
 
diff --git a/src/commands/sites.ts b/src/commands/sites.ts
index b28de51..3a4dbba 100644
--- a/src/commands/sites.ts
+++ b/src/commands/sites.ts
@@ -6,7 +6,7 @@ import pc from 'picocolors';
 
 import { runAction, type Ctx } from '../lib/context.js';
 import { formatAge, formatBytes, link, printJson, renderTable, statusColor } from '../lib/output.js';
-import { siteListView, validateSiteVisibility } from '../lib/sites.js';
+import { describeRetention, siteListView, validateSiteVisibility } from '../lib/sites.js';
 import type { Site, SitesCapabilities, SiteVisibility } from '../lib/types.js';
 import { prepareSiteUpload, type PreparedSiteUpload } from '../lib/zip.js';
 
@@ -19,6 +19,14 @@ async function uploadForm(upload: PreparedSiteUpload, name?: string, visibility?
   return form;
 }
 
+async function retentionDays(ctx: Ctx): Promise<number | undefined> {
+  try {
+    return (await ctx.api.getSitesCapabilities()).deletedRetentionDays;
+  } catch {
+    return undefined;
+  }
+}
+
 async function prepareUpload(ctx: Ctx, target: string, capabilities?: SitesCapabilities): Promise<PreparedSiteUpload> {
   return prepareSiteUpload(target, capabilities ?? (await ctx.api.getSitesCapabilities()));
 }
@@ -69,13 +77,20 @@ export function registerSitesCommands(program: Command): void {
     .command('list')
     .description('List hosted sites')
     .option('-m, --mine', 'only sites owned by this identity')
+    .option(
+      '--deleted',
+      'list your deleted sites that can still be restored (implies --mine; cannot be combined with --public)',
+    )
     .option('--public', 'only public sites')
     .option('--search <query>', 'search site name or id')
     .option('-p, --page <n>', 'page number', v => Number(v), 1)
     .option('-n, --limit <n>', 'items per page', v => Number(v), 25)
     .action(
       runAction(
-        async (ctx, opts: { mine?: boolean; public?: boolean; search?: string; page: number; limit: number }) => {
+        async (
+          ctx,
+          opts: { mine?: boolean; public?: boolean; deleted?: boolean; search?: string; page: number; limit: number },
+        ) => {
           const view = siteListView(opts);
           const { items, pagination } = await ctx.api.listSites({
             page: opts.page,
@@ -87,6 +102,22 @@ export function registerSitesCommands(program: Command): void {
             printJson({ sites: items, pagination });
             return;
           }
+          if (opts.deleted) {
+            const retention = describeRetention(await retentionDays(ctx));
+            if (items.length === 0) {
+              process.stdout.write(pc.dim(`No recently deleted sites. ${retention}\n`));
+              return;
+            }
+            const deletedRows = items.map(s => [
+              pc.bold(s.id),
+              s.name ?? '',
+              s.deletedAt ? formatAge(s.deletedAt) : '',
+              s.restorableUntil ? new Date(s.restorableUntil).toLocaleString() : '',
+            ]);
+            process.stdout.write(renderTable(['id', 'name', 'deleted', 'restorable until'], deletedRows) + '\n');
+            process.stdout.write(pc.dim(`${retention} Restore with: lfc sites restore <id>\n`));
+            return;
+          }
           if (items.length === 0) {
             process.stdout.write(pc.dim('No sites found.\n'));
             return;
@@ -214,7 +245,7 @@ export function registerSitesCommands(program: Command): void {
 
   sites
     .command('delete <siteId>')
-    .description('Delete a hosted site')
+    .description('Delete a hosted site (recoverable with `lfc sites restore` until its restore deadline)')
     .option('-y, --yes', 'skip the confirmation prompt')
     .action(
       runAction(async (ctx, siteId: string, opts: { yes?: boolean }) => {
@@ -223,7 +254,16 @@ export function registerSitesCommands(program: Command): void {
           throw new Error('Your current access does not allow you to delete this site.');
         if (!opts.yes) {
           if (!process.stdin.isTTY) throw new Error('Refusing to delete without --yes in non-interactive mode');
-          const ok = await clack.confirm({ message: `Delete site ${siteId}? Its URL stops working immediately.` });
+          const days = await retentionDays(ctx);
+          const restoreNote =
+            days === undefined
+              ? ''
+              : days === 0
+                ? ' It is removed at the next cleanup.'
+                : ` You can restore it for ${days} ${days === 1 ? 'day' : 'days'}.`;
+          const ok = await clack.confirm({
+            message: `Delete site ${siteId}? Its URL stops working immediately.${restoreNote}`,
+          });
           if (ok !== true) {
             process.stderr.write('Aborted.\n');
             return;
@@ -231,9 +271,31 @@ export function registerSitesCommands(program: Command): void {
         }
         const site = await ctx.api.deleteSite(siteId, current.accessRevision);
         if (ctx.json) printJson(site);
-        else process.stderr.write(`${pc.green('✓')} Deleted site ${siteId}\n`);
+        else {
+          process.stderr.write(`${pc.green('✓')} Deleted site ${siteId}\n`);
+          if (site.restorableUntil)
+            process.stderr.write(
+              `  Restore it with ${pc.bold(`lfc sites restore ${siteId}`)} until ${new Date(site.restorableUntil).toLocaleString()}.\n`,
+            );
+        }
+      }),
+    );
+
+  sites
+    .command('restore <siteId>')
+    .description('Restore a deleted site (same id and URL) while it is still restorable')
+    .action(
+      runAction(async (ctx, siteId: string) => {
+        // GET /sites/{id} returns 404 for deleted sites, so the revision comes from the deleted list.
+        const { items } = await ctx.api.listSites({ page: 1, limit: 100, view: 'deleted', q: siteId });
+        const current = items.find(s => s.id === siteId);
+        if (!current) throw new Error('Site not found or no longer restorable.');
+        if (!current.permissions.canRestore)
+          throw new Error('Your current access does not allow you to restore this site.');
+        printSite(ctx, await ctx.api.restoreSite(siteId, current.accessRevision), 'Restored');
       }),
     );
+
   sites
     .command('visibility <siteId> <visibility>')
     .description('Publish a site or make it private (keeps its content URL)')
diff --git a/src/lib/api.ts b/src/lib/api.ts
index 8ab81e1..f0de85f 100644
--- a/src/lib/api.ts
+++ b/src/lib/api.ts
@@ -294,6 +294,13 @@ export class ApiClient {
     return (env.data as { site: Site }).site;
   }
 
+  async restoreSite(siteId: string, expectedAccessRevision?: number): Promise<Site> {
+    const env = await this.request<{ site: Site }>('POST', `/api/v2/sites/${encodeURIComponent(siteId)}/restore`, {
+      query: { expectedAccessRevision },
+    });
+    return (env.data as { site: Site }).site;
+  }
+
   async extendSite(siteId: string, expectedAccessRevision?: number): Promise<Site> {
     const env = await this.request<{ site: Site }>('POST', `/api/v2/sites/${encodeURIComponent(siteId)}/extend`, {
       query: { expectedAccessRevision },
diff --git a/src/lib/sites.ts b/src/lib/sites.ts
index 1ca3db1..29a87bc 100644
--- a/src/lib/sites.ts
+++ b/src/lib/sites.ts
@@ -1,7 +1,11 @@
 import type { ListSitesView } from './generated/index.js';
 import type { SitesCapabilities, SiteVisibility } from './types.js';
 
-export function siteListView(opts: { mine?: boolean; public?: boolean }): ListSitesView {
+export function siteListView(opts: { mine?: boolean; public?: boolean; deleted?: boolean }): ListSitesView {
+  if (opts.deleted) {
+    if (opts.public) throw new Error('--deleted and --public cannot be combined.');
+    return 'deleted';
+  }
   if (opts.mine && opts.public) throw new Error('--mine and --public cannot be combined.');
   return opts.mine ? 'mine' : opts.public ? 'public' : 'all';
 }
@@ -9,3 +13,9 @@ export function validateSiteVisibility(visibility: SiteVisibility | undefined, c
   if (visibility && !capabilities.allowedVisibilities.includes(visibility))
     throw new Error(`Visibility ${visibility} is not supported for this credential. No files were uploaded.`);
 }
+
+export function describeRetention(days: number | undefined): string {
+  if (days === undefined) return "Deleted sites can be restored until they're permanently removed.";
+  if (days === 0) return 'Deleted sites are permanently removed at the next cleanup.';
+  return `Deleted sites are kept for ${days} ${days === 1 ? 'day' : 'days'}, then permanently removed.`;
+}
diff --git a/tests/sites-command.test.ts b/tests/sites-command.test.ts
index a931d4c..469ecc3 100644
--- a/tests/sites-command.test.ts
+++ b/tests/sites-command.test.ts
@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { Command } from 'commander';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi, type MockInstance } from 'vitest';
 
 import { registerSitesCommands } from '../src/commands/sites.js';
 
@@ -12,13 +12,17 @@ const api = vi.hoisted(() => ({
   getSitesCapabilities: vi.fn(),
   setSiteVisibility: vi.fn(),
   createSite: vi.fn(),
+  listSites: vi.fn(),
+  deleteSite: vi.fn(),
+  restoreSite: vi.fn(),
 }));
+const ctxState = vi.hoisted(() => ({ json: true }));
 const prompts = vi.hoisted(() => ({ confirm: vi.fn() }));
 vi.mock('../src/lib/context.js', () => ({
   runAction:
     (action: (ctx: unknown, ...args: unknown[]) => Promise<void>) =>
     (...args: unknown[]) =>
-      action({ api, json: true }, ...args.slice(0, -1)),
+      action({ api, json: ctxState.json }, ...args.slice(0, -1)),
 }));
 vi.mock('../src/lib/output.js', async importOriginal => ({
   ...(await importOriginal<typeof import('../src/lib/output.js')>()),
@@ -122,3 +126,122 @@ describe('create', () => {
     expect(api.createSite).toHaveBeenCalledTimes(1);
   });
 });
+
+describe('restore, delete and list --deleted', () => {
+  let stderr: MockInstance<typeof process.stderr.write>;
+  beforeEach(() => {
+    stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+  });
+  afterEach(() => {
+    stderr.mockRestore();
+    ctxState.json = true;
+  });
+  async function runArgs(...args: string[]) {
+    const command = new Command();
+    registerSitesCommands(command);
+    await command.parseAsync(['sites', ...args], { from: 'user' });
+  }
+
+  it('restores a deleted site using the revision from the deleted list', async () => {
+    api.listSites.mockResolvedValue({
+      items: [{ id: 'gone', accessRevision: 4, permissions: { canRestore: true } }],
+    });
+    api.restoreSite.mockResolvedValue({ id: 'gone', openUrl: 'https://x/gone', permissions: {} });
+    await runArgs('restore', 'gone');
+    expect(api.listSites).toHaveBeenCalledWith(expect.objectContaining({ view: 'deleted', q: 'gone' }));
+    expect(api.restoreSite).toHaveBeenCalledWith('gone', 4);
+    expect(api.getSite).not.toHaveBeenCalled();
+  });
+
+  it('fails when the site is not in the deleted list', async () => {
+    api.listSites.mockResolvedValue({ items: [{ id: 'other', accessRevision: 1, permissions: { canRestore: true } }] });
+    await expect(runArgs('restore', 'gone')).rejects.toThrow('no longer restorable');
+    expect(api.restoreSite).not.toHaveBeenCalled();
+  });
+
+  it('does not restore when canRestore is false', async () => {
+    api.listSites.mockResolvedValue({ items: [{ id: 'gone', accessRevision: 1, permissions: { canRestore: false } }] });
+    await expect(runArgs('restore', 'gone')).rejects.toThrow('current access');
+    expect(api.restoreSite).not.toHaveBeenCalled();
+  });
+
+  it('lists deleted sites with view=deleted and implies mine', async () => {
+    api.listSites.mockResolvedValue({ items: [], pagination: undefined });
+    await runArgs('list', '--deleted', '--mine');
+    expect(api.listSites).toHaveBeenCalledWith(expect.objectContaining({ view: 'deleted' }));
+  });
+
+  it('shows the retention period with the deleted list', async () => {
+    ctxState.json = false;
+    const stdout = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    api.getSitesCapabilities.mockResolvedValue({ deletedRetentionDays: 30 });
+    api.listSites.mockResolvedValue({
+      items: [
+        {
+          id: 'gone',
+          name: 'Old plan',
+          deletedAt: '2030-01-01T00:00:00.000Z',
+          restorableUntil: '2030-01-31T00:00:00.000Z',
+          permissions: { canRestore: true },
+        },
+      ],
+    });
+    await runArgs('list', '--deleted');
+    const written = stdout.mock.calls.map(c => String(c[0])).join('');
+    stdout.mockRestore();
+    expect(written).toContain('Deleted sites are kept for 30 days, then permanently removed.');
+    expect(written).toContain('lfc sites restore <id>');
+  });
+
+  it('still lists deleted sites when capabilities cannot be loaded', async () => {
+    ctxState.json = false;
+    const stdout = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    api.getSitesCapabilities.mockRejectedValue(new Error('unavailable'));
+    api.listSites.mockResolvedValue({ items: [] });
+    await runArgs('list', '--deleted');
+    const written = stdout.mock.calls.map(c => String(c[0])).join('');
+    stdout.mockRestore();
+    expect(written).toContain(
+      "No recently deleted sites. Deleted sites can be restored until they're permanently removed.",
+    );
+  });
+
+  it('rejects --deleted with --public', async () => {
+    await expect(runArgs('list', '--deleted', '--public')).rejects.toThrow('cannot be combined');
+    expect(api.listSites).not.toHaveBeenCalled();
+  });
+
+  it('only promises a restore window in the delete prompt when the server reports one', async () => {
+    ctxState.json = false;
+    const tty = process.stdin.isTTY;
+    Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+    api.getSite.mockResolvedValue({ id: 'owned', accessRevision: 7, permissions: { canDelete: true } });
+    api.deleteSite.mockResolvedValue({ id: 'owned', restorableUntil: null });
+    prompts.confirm.mockResolvedValue(true);
+    try {
+      api.getSitesCapabilities.mockResolvedValue({ deletedRetentionDays: 30 });
+      await runArgs('delete', 'owned');
+      expect(prompts.confirm).toHaveBeenLastCalledWith(
+        expect.objectContaining({ message: expect.stringContaining('You can restore it for 30 days.') }),
+      );
+      api.getSitesCapabilities.mockRejectedValue(new Error('unavailable'));
+      await runArgs('delete', 'owned');
+      expect(prompts.confirm).toHaveBeenLastCalledWith(
+        expect.objectContaining({ message: 'Delete site owned? Its URL stops working immediately.' }),
+      );
+    } finally {
+      Object.defineProperty(process.stdin, 'isTTY', { value: tty, configurable: true });
+    }
+  });
+
+  it('tells the user how to restore after delete', async () => {
+    ctxState.json = false;
+    api.getSite.mockResolvedValue({ id: 'owned', accessRevision: 7, permissions: { canDelete: true } });
+    api.deleteSite.mockResolvedValue({ id: 'owned', restorableUntil: '2030-01-01T00:00:00.000Z' });
+    await runArgs('delete', 'owned', '--yes');
+    expect(api.deleteSite).toHaveBeenCalledWith('owned', 7);
+    const written = stderr.mock.calls.map(c => String(c[0])).join('');
+    expect(written).toContain('lfc sites restore owned');
+    expect(written).not.toMatch(/permanent/i);
+  });
+});
diff --git a/tests/sites.test.ts b/tests/sites.test.ts
index c60cdec..7dd2837 100644
--- a/tests/sites.test.ts
+++ b/tests/sites.test.ts
@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { ApiClient } from '../src/lib/api.js';
-import { siteListView, validateSiteVisibility } from '../src/lib/sites.js';
+import { describeRetention, siteListView, validateSiteVisibility } from '../src/lib/sites.js';
 import type { SitesCapabilities } from '../src/lib/types.js';
 
 vi.mock('../src/lib/auth.js', () => ({ getAccessToken: vi.fn(async () => 'lfc_test_personal_key') }));
@@ -76,4 +76,26 @@ describe('Sites V1 contracts', () => {
     expect((fetchMock.mock.calls[0]![0] as unknown as URL).searchParams.get('expectedAccessRevision')).toBe('8');
     expect((fetchMock.mock.calls[1]![0] as unknown as URL).searchParams.get('expectedAccessRevision')).toBe('9');
   });
+  it('sends the revision on restore', async () => {
+    const fetchMock = mockResponse({ site: { id: 'test' } });
+    await client.restoreSite('test/id', 3);
+    const url = fetchMock.mock.calls[0]![0] as unknown as URL;
+    expect(url.pathname).toBe('/api/v2/sites/test%2Fid/restore');
+    expect(url.searchParams.get('expectedAccessRevision')).toBe('3');
+    expect((fetchMock.mock.calls[0]![1] as RequestInit).method).toBe('POST');
+  });
+  it('maps --deleted to the deleted view', () => {
+    expect(siteListView({ deleted: true })).toBe('deleted');
+    expect(siteListView({ deleted: true, mine: true })).toBe('deleted');
+    expect(() => siteListView({ deleted: true, public: true })).toThrow('cannot be combined');
+  });
+});
+
+describe('describeRetention', () => {
+  it('describes the configured retention window', () => {
+    expect(describeRetention(30)).toBe('Deleted sites are kept for 30 days, then permanently removed.');
+    expect(describeRetention(1)).toContain('kept for 1 day,');
+    expect(describeRetention(0)).toContain('at the next cleanup');
+    expect(describeRetention(undefined)).toContain("until they're permanently removed");
+  });
 });