@nuxtseo/cli 0.1.4 → 0.2.0

package/dist/commands.js

@@ -1,24 +1,64 @@
 import * as prompts from '@clack/prompts';
+import { publicV1BooleanFlagValue } from '@nuxtseo/protocol/v1/core';
 import { defineCommand } from 'citty';
+import { dirname } from 'pathe';
 import { createApiClient, fromStateError, loadApiContext } from './api.js';
 import { openBrowser } from './browser.js';
 import { EXIT_CODE, fail, fromSdkFailure, ok } from './failures.js';
 import { awaitPairingApproval, createCliPairingClient, startPairing } from './pairing.js';
-import { parseAbsolutePageUrl, parseChoice, parseInteger } from './parse.js';
-import { renderAction, renderActionResolution, renderActions, renderContentBrief, renderContentBriefCreated, renderContentBriefs, renderContentDecay, renderDuplicateClusters, renderIndexingDiagnostics, renderKeywordResearch, renderLinkOpportunities, renderMentions, renderPageInspection, renderPageScan, renderPerformance, renderRankingsResearch, renderRecoverableBacklinks, renderResearchOverview, renderSearchAnalytics, renderSearchStatus, renderSerpResearch, renderSites, renderTimeline, renderUsage, } from './render.js';
+import { parseAbsolutePageUrl, parseChoice, parseInteger, parsePageUrlOrPath, parseRatio } from './parse.js';
+import { renderAccountToken, renderAction, renderActionDismissal, renderActionResolution, renderActions, renderAnalytics, renderAnnotation, renderAnnotationDeleted, renderAnnotations, renderAuditChanges, renderBacklinkAnchors, renderBacklinksHistory, renderBacklinksSummary, renderContentBrief, renderContentBriefCreated, renderContentBriefs, renderContentDecay, renderDomainAvailability, renderDomainTraffic, renderDuplicateClusters, renderFieldVitalFindings, renderFieldVitals, renderIndexCohorts, renderIndexingDiagnostics, renderIndexingHistory, renderKeywordResearch, renderLinkOpportunities, renderLinkStructure, renderMentions, renderMonitoredPages, renderPageInspection, renderPageIssues, renderPageScan, renderPerformance, renderRankingsResearch, renderRecoverableBacklinks, renderReferringDomains, renderResearchOverview, renderScanDetail, renderScans, renderSearchAnalytics, renderSearchStatus, renderSerpResearch, renderSitemapAction, renderSitemaps, renderSitemapUrls, renderSites, renderSiteStatus, renderTimeline, renderUrlInspection, renderUsage, } from './render.js';
 import { writeCliResponse, writeDiagnostic, writeOutput, writeProtocolResponse } from './runtime.js';
 import { resolveSite } from './site.js';
+import { installSkill, SKILL_AGENTS } from './skill.js';
 import { clearCredential, getCredentialStatus, readConfig, resolveApiUrl, saveCredential, updateConfig, } from './state/index.js';
 import { VERSION } from './version.js';
+function emit(runtime, globals, value, render) {
+    if (globals.json)
+        writeProtocolResponse(runtime, value);
+    else
+        writeOutput(runtime, render(value));
+}
 function present(runtime, globals, result, render) {
     if (result._tag === 'Err')
         return fromSdkFailure(result.error);
-    if (globals.json)
-        writeProtocolResponse(runtime, result.value);
-    else
-        writeOutput(runtime, render(result.value));
+    emit(runtime, globals, result.value, render);
     return ok(undefined);
 }
+/**
+ * `--all` request cap. One page per request stays the default. `--all` repeats
+ * the same operation and writes one complete envelope per page, so nothing is
+ * merged or renamed. The cap bounds an unattended loop; reaching it exits 9 and
+ * names the resume argument, so a caller never mistakes a stop for an end.
+ */
+export const ALL_PAGES_REQUEST_CAP = 50;
+async function collect(runtime, globals, options) {
+    let position = options.start;
+    for (let request = 1;; request++) {
+        const response = await withSpinner(runtime, options.message, () => options.fetch(position));
+        if (response._tag === 'Err')
+            return fromSdkFailure(response.error);
+        emit(runtime, globals, response.value, options.render);
+        if (!options.all)
+            return ok(undefined);
+        const next = options.next(response.value, position);
+        if (next._tag === 'Done')
+            return ok(undefined);
+        if (request >= ALL_PAGES_REQUEST_CAP) {
+            return fail(EXIT_CODE.pagingCapReached, [
+                `paging_cap_reached: --all stopped after ${ALL_PAGES_REQUEST_CAP} requests.`,
+                `More pages remain. Run the command again with ${next.resume}.`,
+            ].join('\n'), undefined, 'paging_cap_reached');
+        }
+        position = next.position;
+    }
+}
+function offsetPage(cursor) {
+    const offset = cursor.offset + cursor.limit;
+    return cursor.hasMore
+        ? { _tag: 'More', position: { offset }, resume: `--offset ${offset}` }
+        : { _tag: 'Done' };
+}
 async function withSpinner(runtime, message, task) {
     const spinner = runtime.interactive
         ? prompts.spinner({ output: runtime.error, signal: runtime.signal })
@@ -122,8 +162,11 @@ async function login(runtime, globals, options) {
         : await pairInBrowser(runtime, apiUrl.value.apiUrl, { openBrowser: !options.noBrowser });
     if (token._tag === 'Err')
         return token;
+    // Introspection proves the credential and reports what it can do. Listing
+    // Sites proved only that one read succeeded, and read the whole portfolio to
+    // do it.
     const client = createApiClient(apiUrl.value.apiUrl, token.value);
-    const validated = await withSpinner(runtime, 'Validating token', () => client.sites.list({}, { signal: runtime.requestSignal }));
+    const validated = await withSpinner(runtime, 'Validating token', () => client.account.token({}, { signal: runtime.requestSignal }));
     if (validated._tag === 'Err')
         return fromSdkFailure(validated.error);
     const saved = await saveCredential(token.value, { paths: runtime.paths });
@@ -141,10 +184,16 @@ async function login(runtime, globals, options) {
     if (runtime.env.NUXTSEO_TOKEN !== undefined) {
         writeDiagnostic(runtime, 'warning: NUXTSEO_TOKEN remains active and takes precedence over the stored credential.');
     }
-    if (globals.json)
+    if (globals.json) {
         writeProtocolResponse(runtime, validated.value);
-    else
-        writeOutput(runtime, `Logged in. ${validated.value.data.sites.length} Sites accessible. Credential: ${saved.value.storage}.`);
+    }
+    else {
+        writeOutput(runtime, [
+            `Logged in as ${validated.value.data.role} on ${validated.value.data.team.name ?? validated.value.data.team.id}.`,
+            `Credential: ${saved.value.storage}.`,
+            `Scopes: ${validated.value.data.scopes.join(', ')}`,
+        ].join('\n'));
+    }
     return ok(undefined);
 }
 async function logout(runtime, globals) {
@@ -168,18 +217,17 @@ async function whoami(runtime, globals) {
     const api = await loadApiContext(runtime, globals);
     if (api._tag === 'Err')
         return api;
-    const listed = await withSpinner(runtime, 'Checking authentication', () => api.value.client.sites.list({}, { signal: runtime.requestSignal }));
-    if (listed._tag === 'Err')
-        return fromSdkFailure(listed.error);
+    const introspected = await withSpinner(runtime, 'Checking authentication', () => api.value.client.account.token({}, { signal: runtime.requestSignal }));
+    if (introspected._tag === 'Err')
+        return fromSdkFailure(introspected.error);
     if (globals.json) {
-        writeProtocolResponse(runtime, listed.value);
+        writeProtocolResponse(runtime, introspected.value);
     }
     else {
         writeOutput(runtime, [
-            'Authenticated Team API token.',
+            renderAccountToken(introspected.value.data),
             `API: ${api.value.apiUrl}`,
-            `Credential: ${api.value.credentialSource}`,
-            `Accessible Sites: ${listed.value.data.sites.length}`,
+            `Credential source: ${api.value.credentialSource}`,
             `Selected Site: ${api.value.config.siteId ?? 'none'}`,
         ].join('\n'));
     }
@@ -297,21 +345,27 @@ async function usage(runtime, globals, group) {
     const response = await withSpinner(runtime, 'Loading usage', () => api.value.client.account.usage({ query: { group } }, { signal: runtime.requestSignal }));
     return present(runtime, globals, response, renderUsage);
 }
-async function actionsList(runtime, globals, limitInput, offsetInput) {
-    const limit = parseInteger(limitInput, { name: '--limit', minimum: 1, maximum: 25, defaultValue: 10 });
+async function actionsList(runtime, globals, args) {
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 25, defaultValue: 10 });
     if (limit._tag === 'Err')
         return limit;
-    const offset = parseInteger(offsetInput, { name: '--offset', minimum: 0, defaultValue: 0 });
+    const offset = parseInteger(args.offset, { name: '--offset', minimum: 0, defaultValue: 0 });
     if (offset._tag === 'Err')
         return offset;
     const resolved = await apiAndSite(runtime, globals);
     if (resolved._tag === 'Err')
         return resolved;
-    const response = await withSpinner(runtime, 'Loading next actions', () => resolved.value.api.client.actions.list({
-        params: { siteId: resolved.value.siteId },
-        query: { limit: limit.value, offset: offset.value },
-    }, { signal: runtime.requestSignal }));
-    return present(runtime, globals, response, value => renderActions(value.data));
+    return collect(runtime, globals, {
+        all: args.all === true,
+        message: 'Loading next actions',
+        start: { offset: offset.value },
+        fetch: position => resolved.value.api.client.actions.list({
+            params: { siteId: resolved.value.siteId },
+            query: { limit: limit.value, offset: position.offset ?? 0 },
+        }, { signal: runtime.requestSignal }),
+        render: value => renderActions(value.data),
+        next: value => offsetPage(value.data.page),
+    });
 }
 async function actionsShow(runtime, globals, args) {
     const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 100, defaultValue: 50 });
@@ -362,16 +416,22 @@ async function pageInspect(runtime, globals, args) {
     const resolved = await apiAndSite(runtime, globals);
     if (resolved._tag === 'Err')
         return resolved;
-    const response = await withSpinner(runtime, 'Inspecting Page', () => resolved.value.api.client.pages.inspect({
-        params: { siteId: resolved.value.siteId },
-        query: {
-            url: url.value,
-            includeResolved: args.includeResolved ? '1' : '0',
-            limit: limit.value,
-            offset: offset.value,
-        },
-    }, { signal: runtime.requestSignal }));
-    return present(runtime, globals, response, value => renderPageInspection(value.data));
+    return collect(runtime, globals, {
+        all: args.all === true,
+        message: 'Inspecting Page',
+        start: { offset: offset.value },
+        fetch: position => resolved.value.api.client.pages.inspect({
+            params: { siteId: resolved.value.siteId },
+            query: {
+                url: url.value,
+                includeResolved: publicV1BooleanFlagValue(Boolean(args.includeResolved)),
+                limit: limit.value,
+                offset: position.offset ?? 0,
+            },
+        }, { signal: runtime.requestSignal }),
+        render: value => renderPageInspection(value.data),
+        next: value => offsetPage(value.data.observations.pagination),
+    });
 }
 async function pageScan(runtime, globals, rawUrl) {
     const url = parseAbsolutePageUrl(rawUrl);
@@ -411,8 +471,48 @@ async function searchStatus(runtime, globals) {
     }, { signal: runtime.requestSignal }));
     return present(runtime, globals, response, value => renderSearchStatus(value.data));
 }
+const SEARCH_ANALYTICS_VIEWS = [
+    'pages',
+    'keywords',
+    'countries',
+    'devices',
+    'timeseries',
+    'page-detail',
+    'keyword-detail',
+    'analysis',
+];
+/** The views the server pages with `total` and `rows`, so `--all` can walk them. */
+const SEARCH_ANALYTICS_ROW_VIEWS = new Set(['pages', 'keywords', 'countries', 'devices', 'analysis']);
+const SEARCH_ANALYSIS_PRESETS = [
+    'striking-distance',
+    'opportunity',
+    'decay',
+    'zero-click',
+    'non-brand',
+    'brand-only',
+    'movers-rising',
+    'movers-declining',
+];
+const INDEXING_TRANSITION_FIELDS = [
+    'indexStatus',
+    'coverageState',
+    'robotsTxtState',
+    'indexingState',
+    'pageFetchState',
+    'googleCanonical',
+];
+function optionalInteger(input, options) {
+    if (input === undefined)
+        return ok(undefined);
+    return parseInteger(input, { ...options, defaultValue: options.minimum });
+}
+function optionalChoice(input, options) {
+    if (input === undefined)
+        return ok(undefined);
+    return parseChoice(input, options);
+}
 async function searchAnalytics(runtime, globals, args) {
-    const view = parseChoice(args.view, { name: 'view', choices: ['pages', 'keywords'] });
+    const view = parseChoice(args.view, { name: 'view', choices: SEARCH_ANALYTICS_VIEWS });
     if (view._tag === 'Err')
         return view;
     const period = parseChoice(args.period, { name: '--period', choices: ['7d', '28d', '3m', '6m', '12m'], defaultValue: '28d' });
@@ -430,30 +530,100 @@ async function searchAnalytics(runtime, globals, args) {
     const sortDir = parseChoice(args.sortDir, { name: '--sort-dir', choices: ['asc', 'desc'], defaultValue: 'desc' });
     if (sortDir._tag === 'Err')
         return sortDir;
+    const filter = optionalChoice(args.filter, { name: '--filter', choices: ['top-level', 'new', 'lost', 'improving', 'declining'] });
+    if (filter._tag === 'Err')
+        return filter;
+    const preset = optionalChoice(args.preset, { name: '--preset', choices: SEARCH_ANALYSIS_PRESETS });
+    if (preset._tag === 'Err')
+        return preset;
+    const pageUrl = args.pageUrl === undefined ? ok(undefined) : parsePageUrlOrPath(args.pageUrl);
+    if (pageUrl._tag === 'Err')
+        return pageUrl;
+    const minClicks = optionalInteger(args.minClicks, { name: '--min-clicks', minimum: 0 });
+    if (minClicks._tag === 'Err')
+        return minClicks;
+    const maxClicks = optionalInteger(args.maxClicks, { name: '--max-clicks', minimum: 0 });
+    if (maxClicks._tag === 'Err')
+        return maxClicks;
+    const minImpressions = optionalInteger(args.minImpressions, { name: '--min-impressions', minimum: 0 });
+    if (minImpressions._tag === 'Err')
+        return minImpressions;
+    const maxImpressions = optionalInteger(args.maxImpressions, { name: '--max-impressions', minimum: 0 });
+    if (maxImpressions._tag === 'Err')
+        return maxImpressions;
+    const minPosition = optionalInteger(args.minPosition, { name: '--min-position', minimum: 1, maximum: 100 });
+    if (minPosition._tag === 'Err')
+        return minPosition;
+    const maxPosition = optionalInteger(args.maxPosition, { name: '--max-position', minimum: 1, maximum: 100 });
+    if (maxPosition._tag === 'Err')
+        return maxPosition;
+    const maxCtr = args.maxCtr === undefined
+        ? ok(undefined)
+        : parseRatio(args.maxCtr, '--max-ctr');
+    if (maxCtr._tag === 'Err')
+        return maxCtr;
+    // The server rejects these combinations too. Refusing here costs no request
+    // and names the exact missing argument.
+    if (view.value === 'page-detail' && !pageUrl.value)
+        return fail(EXIT_CODE.invalidInput, 'The page-detail view requires --page-url.');
+    if (view.value === 'keyword-detail' && !args.keyword)
+        return fail(EXIT_CODE.invalidInput, 'The keyword-detail view requires --keyword.');
+    if (view.value === 'analysis' && !preset.value)
+        return fail(EXIT_CODE.invalidInput, 'The analysis view requires --preset.');
+    if (view.value === 'analysis' && (preset.value === 'brand-only' || preset.value === 'non-brand') && !args.brandTerms?.trim())
+        return fail(EXIT_CODE.invalidInput, `The ${preset.value} preset requires --brand-terms.`);
+    if (args.all && !SEARCH_ANALYTICS_ROW_VIEWS.has(view.value))
+        return fail(EXIT_CODE.invalidInput, `--all supports only these views: ${[...SEARCH_ANALYTICS_ROW_VIEWS].join(', ')}.`);
     const resolved = await apiAndSite(runtime, globals);
     if (resolved._tag === 'Err')
         return resolved;
-    const response = await withSpinner(runtime, 'Loading Search Console rows', () => resolved.value.api.client.search.queryAnalytics({
-        params: { siteId: resolved.value.siteId },
-        query: {
-            view: view.value,
-            period: period.value,
-            limit: limit.value,
-            page: page.value,
-            search: args.search,
-            sort: sort.value,
-            sortDir: sortDir.value,
+    return collect(runtime, globals, {
+        all: args.all === true,
+        message: 'Loading Search Console rows',
+        start: { page: page.value },
+        fetch: position => resolved.value.api.client.search.queryAnalytics({
+            params: { siteId: resolved.value.siteId },
+            query: {
+                view: view.value,
+                period: period.value,
+                limit: limit.value,
+                page: position.page ?? 1,
+                search: args.search,
+                sort: sort.value,
+                sortDir: sortDir.value,
+                filter: filter.value,
+                pageUrl: pageUrl.value,
+                keyword: args.keyword,
+                preset: preset.value,
+                brandTerms: args.brandTerms,
+                minClicks: minClicks.value,
+                maxClicks: maxClicks.value,
+                minImpressions: minImpressions.value,
+                maxImpressions: maxImpressions.value,
+                minPosition: minPosition.value,
+                maxPosition: maxPosition.value,
+                maxCtr: maxCtr.value,
+            },
+        }, { signal: runtime.requestSignal }),
+        render: value => renderSearchAnalytics(value.data),
+        next: (value, position) => {
+            const data = value.data;
+            if (!('total' in data) || !('rows' in data))
+                return { _tag: 'Done' };
+            const current = position.page ?? 1;
+            if (data.rows.length === 0 || current * limit.value >= data.total)
+                return { _tag: 'Done' };
+            return { _tag: 'More', position: { page: current + 1 }, resume: `--page ${current + 1}` };
         },
-    }, { signal: runtime.requestSignal }));
-    return present(runtime, globals, response, value => renderSearchAnalytics(value.data));
+    });
 }
+/** The two retained-coverage views, declared once so `--help --json` publishes them. */
+const SEARCH_INDEXING_VIEWS = ['summary', 'urls'];
 async function searchIndexing(runtime, globals, args) {
-    const view = parseChoice(args.view, { name: 'view', choices: ['summary', 'urls'] });
+    const view = parseChoice(args.view, { name: 'view', choices: SEARCH_INDEXING_VIEWS });
     if (view._tag === 'Err')
         return view;
-    const status = args.status === undefined
-        ? ok(undefined)
-        : parseChoice(args.status, { name: '--status', choices: ['indexed', 'not_indexed', 'pending'] });
+    const status = optionalChoice(args.status, { name: '--status', choices: ['indexed', 'not_indexed', 'pending'] });
     if (status._tag === 'Err')
         return status;
     const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 500, defaultValue: 50 });
@@ -462,20 +632,62 @@ async function searchIndexing(runtime, globals, args) {
     const offset = parseInteger(args.offset, { name: '--offset', minimum: 0, defaultValue: 0 });
     if (offset._tag === 'Err')
         return offset;
+    if (args.all && view.value !== 'urls')
+        return fail(EXIT_CODE.invalidInput, '--all supports the urls view only.');
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    return collect(runtime, globals, {
+        all: args.all === true,
+        message: 'Loading Search Console indexing',
+        start: { offset: offset.value },
+        fetch: position => resolved.value.api.client.search.readIndexingDiagnostics({
+            params: { siteId: resolved.value.siteId },
+            query: {
+                view: view.value,
+                issue: args.issue,
+                status: status.value,
+                limit: limit.value,
+                offset: position.offset ?? 0,
+            },
+        }, { signal: runtime.requestSignal }),
+        render: value => renderIndexingDiagnostics(value.data),
+        next: value => value.data.view === 'urls'
+            ? offsetPage({ offset: value.data.offset, limit: value.data.limit, hasMore: value.data.hasMore })
+            : { _tag: 'Done' },
+    });
+}
+async function searchIndexHistory(runtime, globals, args) {
+    const url = args.url === undefined ? ok(undefined) : parsePageUrlOrPath(args.url);
+    if (url._tag === 'Err')
+        return url;
+    const field = optionalChoice(args.field, { name: '--field', choices: INDEXING_TRANSITION_FIELDS });
+    if (field._tag === 'Err')
+        return field;
+    const days = parseInteger(args.days, { name: '--days', minimum: 1, maximum: 730, defaultValue: 180 });
+    if (days._tag === 'Err')
+        return days;
     const resolved = await apiAndSite(runtime, globals);
     if (resolved._tag === 'Err')
         return resolved;
-    const response = await withSpinner(runtime, 'Loading Search Console indexing', () => resolved.value.api.client.search.readIndexingDiagnostics({
+    const response = await withSpinner(runtime, 'Loading indexing history', () => resolved.value.api.client.search.readIndexingHistory({
         params: { siteId: resolved.value.siteId },
-        query: {
-            view: view.value,
-            issue: args.issue,
-            status: status.value,
-            limit: limit.value,
-            offset: offset.value,
-        },
+        query: { url: url.value, field: field.value, days: days.value },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderIndexingHistory(value.data));
+}
+async function searchInspect(runtime, globals, rawUrl) {
+    const url = parsePageUrlOrPath(rawUrl);
+    if (url._tag === 'Err')
+        return url;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading URL Inspection', () => resolved.value.api.client.search.readUrlInspection({
+        params: { siteId: resolved.value.siteId },
+        query: { url: url.value },
     }, { signal: runtime.requestSignal }));
-    return present(runtime, globals, response, value => renderIndexingDiagnostics(value.data));
+    return present(runtime, globals, response, value => renderUrlInspection(value.data));
 }
 async function researchOverview(runtime, globals) {
     const resolved = await apiAndSite(runtime, globals);
@@ -579,6 +791,173 @@ async function researchRankings(runtime, globals, args) {
     }, { signal: runtime.requestSignal }));
     return present(runtime, globals, response, value => renderRankingsResearch(value.data));
 }
+const ANALYTICS_VIEWS = [
+    'performance',
+    'top-pages',
+    'source-medium',
+    'key-events',
+    'countries',
+    'devices',
+    'dimension',
+];
+const ANALYTICS_DIMENSIONS = [
+    'date',
+    'page',
+    'hostname',
+    'source',
+    'medium',
+    'campaign',
+    'country',
+    'region',
+    'city',
+    'deviceCategory',
+    'browser',
+    'operatingSystem',
+];
+async function auditChanges(runtime, globals, args) {
+    const from = optionalInteger(args.from, { name: '--from', minimum: 1 });
+    if (from._tag === 'Err')
+        return from;
+    const to = optionalInteger(args.to, { name: '--to', minimum: 1 });
+    if (to._tag === 'Err')
+        return to;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading crawl changes', () => resolved.value.api.client.audit.changes({
+        params: { siteId: resolved.value.siteId },
+        query: { from: from.value, to: to.value },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderAuditChanges(value.data));
+}
+async function auditLinkStructure(runtime, globals) {
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading link structure', () => resolved.value.api.client.audit.linkStructure({
+        params: { siteId: resolved.value.siteId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderLinkStructure(value.data));
+}
+async function sitemapsList(runtime, globals) {
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading sitemaps', () => resolved.value.api.client.sitemaps.list({
+        params: { siteId: resolved.value.siteId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderSitemaps(value.data));
+}
+async function sitemapsUrls(runtime, globals, args) {
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 1000, defaultValue: 500 });
+    if (limit._tag === 'Err')
+        return limit;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    return collect(runtime, globals, {
+        all: args.all === true,
+        message: 'Loading sitemap URLs',
+        start: { cursor: args.cursor },
+        fetch: position => resolved.value.api.client.sitemaps.listUrls({
+            params: { siteId: resolved.value.siteId },
+            query: {
+                generationId: args.generationId,
+                feedpath: args.feedpath,
+                cursor: position.cursor,
+                limit: limit.value,
+            },
+        }, { signal: runtime.requestSignal }),
+        render: value => renderSitemapUrls(value.data),
+        next: (value) => {
+            const cursor = value.data.page.nextCursor;
+            return cursor
+                ? { _tag: 'More', position: { cursor }, resume: `--cursor ${cursor}` }
+                : { _tag: 'Done' };
+        },
+    });
+}
+async function sitemapsAction(runtime, globals, action, rawUrl) {
+    const sitemapUrl = parseAbsolutePageUrl(rawUrl);
+    if (sitemapUrl._tag === 'Err')
+        return sitemapUrl;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const confirmed = await confirmMutation(runtime, globals, `${action === 'submit' ? 'Submit' : 'Delete'} ${sitemapUrl.value} in Search Console?`);
+    if (confirmed._tag === 'Err')
+        return confirmed;
+    if (!confirmed.value) {
+        writeDiagnostic(runtime, 'Mutation cancelled.');
+        return ok(undefined);
+    }
+    const response = await withSpinner(runtime, `Sending the sitemap ${action}`, () => resolved.value.api.client.sitemaps.createAction({
+        params: { siteId: resolved.value.siteId },
+        body: { action, sitemapUrl: sitemapUrl.value },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderSitemapAction(value.data));
+}
+async function analyticsQuery(runtime, globals, args) {
+    const view = parseChoice(args.view, { name: 'view', choices: ANALYTICS_VIEWS });
+    if (view._tag === 'Err')
+        return view;
+    const compare = parseChoice(args.compare, { name: '--compare', choices: ['previous', 'year', 'none'], defaultValue: 'previous' });
+    if (compare._tag === 'Err')
+        return compare;
+    const phase = parseChoice(args.performancePhase, { name: '--phase', choices: ['current', 'prior', 'full'], defaultValue: 'full' });
+    if (phase._tag === 'Err')
+        return phase;
+    const dimension = optionalChoice(args.dimension, { name: '--dimension', choices: ANALYTICS_DIMENSIONS });
+    if (dimension._tag === 'Err')
+        return dimension;
+    if (view.value === 'dimension' && !dimension.value)
+        return fail(EXIT_CODE.invalidInput, 'The dimension view requires --dimension.');
+    const period = args.period?.trim();
+    if (period !== undefined && period.length === 0)
+        return fail(EXIT_CODE.invalidInput, '--period cannot be empty.');
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading Web Analytics', () => resolved.value.api.client.analytics.query({
+        params: { siteId: resolved.value.siteId, view: view.value },
+        query: {
+            period: period ?? '28d',
+            compare: compare.value,
+            stableData: args.stableData ?? true,
+            filters: args.filters,
+            hostScope: args.hostScope ?? true,
+            dimension: dimension.value,
+            performancePhase: phase.value,
+            comparePrior: args.comparePrior ?? true,
+            fresh: args.fresh ?? false,
+        },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderAnalytics(view.value, value.data));
+}
+async function skillInstallCommand(runtime, globals, args) {
+    const agent = parseChoice(args.agent, { name: '--agent', choices: SKILL_AGENTS, defaultValue: 'claude' });
+    if (agent._tag === 'Err')
+        return agent;
+    // The state directory is `<home>/.nuxtseo`, so its parent is the home the
+    // agent directories sit beside.
+    const homeDirectory = dirname(runtime.paths.directory);
+    const installed = await installSkill({ agent: agent.value, homeDirectory, target: args.target });
+    if (installed._tag === 'Err')
+        return installed;
+    if (globals.json) {
+        writeCliResponse(runtime, {
+            _tag: 'CliSkillInstall',
+            schemaVersion: 1,
+            agent: installed.value.agent,
+            source: installed.value.source,
+            destination: installed.value.destination,
+        });
+    }
+    else {
+        writeOutput(runtime, `Installed the nuxtseo-cli skill for ${installed.value.agent} at ${installed.value.destination}.`);
+    }
+    return ok(undefined);
+}
 async function auditContentDecay(runtime, globals) {
     const resolved = await apiAndSite(runtime, globals);
     if (resolved._tag === 'Err')
@@ -645,11 +1024,17 @@ async function contentBriefList(runtime, globals, args) {
     const resolved = await apiAndSite(runtime, globals);
     if (resolved._tag === 'Err')
         return resolved;
-    const response = await withSpinner(runtime, 'Loading Content Briefs', () => resolved.value.api.client.content.listBriefs({
-        params: { siteId: resolved.value.siteId },
-        query: { status: status.value, limit: limit.value, offset: offset.value },
-    }, { signal: runtime.requestSignal }));
-    return present(runtime, globals, response, value => renderContentBriefs(value.data));
+    return collect(runtime, globals, {
+        all: args.all === true,
+        message: 'Loading Content Briefs',
+        start: { offset: offset.value },
+        fetch: position => resolved.value.api.client.content.listBriefs({
+            params: { siteId: resolved.value.siteId },
+            query: { status: status.value, limit: limit.value, offset: position.offset ?? 0 },
+        }, { signal: runtime.requestSignal }),
+        render: value => renderContentBriefs(value.data),
+        next: value => offsetPage(value.data.page),
+    });
 }
 async function contentBriefShow(runtime, globals, briefId) {
     const resolved = await apiAndSite(runtime, globals);
@@ -680,21 +1065,386 @@ async function contentBriefCreate(runtime, globals, args) {
     }, { signal: runtime.requestSignal }));
     return present(runtime, globals, response, value => renderContentBriefCreated(value.data));
 }
-async function backlinksRecoverable(runtime, globals, limitInput, offsetInput) {
-    const limit = parseInteger(limitInput, { name: '--limit', minimum: 1, maximum: 200, defaultValue: 100 });
+const VITALS_FORM_FACTORS = ['phone', 'desktop', 'all'];
+const VITALS_METRICS = ['lcp', 'inp', 'cls'];
+const VITALS_FORM_FACTOR_WIRE = {
+    phone: 'PHONE',
+    desktop: 'DESKTOP',
+    all: 'ALL_FORM_FACTORS',
+};
+/**
+ * CrUX field vitals. This is a different dataset from `nuxtseo performance`,
+ * which reads the stored Lighthouse lab overview (ADR-0129).
+ */
+async function fieldVitals(runtime, globals, args) {
+    const formFactor = parseChoice(args.formFactor, {
+        name: '--form-factor',
+        choices: VITALS_FORM_FACTORS,
+        defaultValue: 'phone',
+    });
+    if (formFactor._tag === 'Err')
+        return formFactor;
+    const url = args.url === undefined
+        ? ok(undefined)
+        : parseAbsolutePageUrl(args.url);
+    if (url._tag === 'Err')
+        return url;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading field vitals', () => resolved.value.api.client.performance.vitals({
+        params: { siteId: resolved.value.siteId },
+        query: {
+            url: url.value,
+            formFactor: VITALS_FORM_FACTOR_WIRE[formFactor.value],
+            view: args.view,
+        },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderFieldVitals(value.data));
+}
+async function fieldVitalFindings(runtime, globals, args) {
+    const metric = args.metric === undefined
+        ? ok(undefined)
+        : parseChoice(args.metric, { name: '--metric', choices: VITALS_METRICS, defaultValue: 'lcp' });
+    if (metric._tag === 'Err')
+        return metric;
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 50, defaultValue: 20 });
+    if (limit._tag === 'Err')
+        return limit;
+    const offset = parseInteger(args.offset, { name: '--offset', minimum: 0, defaultValue: 0 });
+    if (offset._tag === 'Err')
+        return offset;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    return collect(runtime, globals, {
+        all: args.all === true,
+        message: 'Loading field vital findings',
+        start: { offset: offset.value },
+        fetch: position => resolved.value.api.client.performance.vitalFindings({
+            params: { siteId: resolved.value.siteId },
+            query: {
+                metrics: metric.value === undefined ? undefined : [metric.value],
+                onlyFailing: publicV1BooleanFlagValue(args.onlyFailing ?? true),
+                limit: limit.value,
+                offset: position.offset ?? 0,
+            },
+        }, { signal: runtime.requestSignal }),
+        render: value => renderFieldVitalFindings(value.data),
+        next: value => offsetPage({
+            offset: value.data.offset,
+            limit: limit.value,
+            hasMore: value.data.offset + value.data.findings.length < value.data.total,
+        }),
+    });
+}
+async function backlinksSummary(runtime, globals) {
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading Backlinks summary', () => resolved.value.api.client.backlinks.summary({
+        params: { siteId: resolved.value.siteId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderBacklinksSummary(value.data));
+}
+async function backlinksReferringDomains(runtime, globals, args) {
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 1000, defaultValue: 100 });
+    if (limit._tag === 'Err')
+        return limit;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading referring domains', () => resolved.value.api.client.backlinks.referringDomains({
+        params: { siteId: resolved.value.siteId },
+        query: { limit: limit.value },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderReferringDomains(value.data));
+}
+async function backlinksAnchors(runtime, globals, args) {
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 1000, defaultValue: 100 });
     if (limit._tag === 'Err')
         return limit;
-    const offset = parseInteger(offsetInput, { name: '--offset', minimum: 0, defaultValue: 0 });
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading Backlink anchors', () => resolved.value.api.client.backlinks.anchors({
+        params: { siteId: resolved.value.siteId },
+        query: { limit: limit.value },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderBacklinkAnchors(value.data));
+}
+async function backlinksHistory(runtime, globals, args) {
+    if (args.from !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(args.from))
+        return fail(EXIT_CODE.invalidInput, '--from must be a date in YYYY-MM-DD form.', undefined, 'invalid_cli_input');
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading Backlinks history', () => resolved.value.api.client.backlinks.history({
+        params: { siteId: resolved.value.siteId },
+        query: { dateFrom: args.from },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderBacklinksHistory(value.data));
+}
+async function siteStatus(runtime, globals) {
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading Site status', () => resolved.value.api.client.sites.status({
+        params: { siteId: resolved.value.siteId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderSiteStatus(value.data));
+}
+async function actionDismiss(runtime, globals, args) {
+    if (!args.actionId)
+        return fail(EXIT_CODE.invalidInput, 'Pass the action id to dismiss.', undefined, 'invalid_cli_input');
+    if (!args.artifactVersion)
+        return fail(EXIT_CODE.invalidInput, 'Pass --artifact-version, the artifactVersion returned with this action.', undefined, 'invalid_cli_input');
+    const confirmed = await confirmMutation(runtime, globals, `Dismiss action ${args.actionId}? The page stays removed.`);
+    if (confirmed._tag === 'Err')
+        return confirmed;
+    if (!confirmed.value) {
+        writeDiagnostic(runtime, 'Mutation cancelled.');
+        return ok(undefined);
+    }
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Dismissing action', () => resolved.value.api.client.actions.dismiss({
+        params: { siteId: resolved.value.siteId, actionId: args.actionId },
+        body: { artifactVersion: args.artifactVersion },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderActionDismissal(value.data));
+}
+async function pageIssues(runtime, globals, args) {
+    if (args.actionId && (args.source || args.issue))
+        return fail(EXIT_CODE.invalidInput, 'Pass --action-id, or pass --source and --issue, not both.', undefined, 'invalid_cli_input');
+    if (!args.actionId && !(args.source && args.issue))
+        return fail(EXIT_CODE.invalidInput, 'Pass --action-id, or pass both --source and --issue.', undefined, 'invalid_cli_input');
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 200, defaultValue: 100 });
+    if (limit._tag === 'Err')
+        return limit;
+    const offset = parseInteger(args.offset, { name: '--offset', minimum: 0, defaultValue: 0 });
     if (offset._tag === 'Err')
         return offset;
     const resolved = await apiAndSite(runtime, globals);
     if (resolved._tag === 'Err')
         return resolved;
-    const response = await withSpinner(runtime, 'Loading recoverable Backlinks', () => resolved.value.api.client.backlinks.recoverable({
+    return collect(runtime, globals, {
+        all: args.all === true,
+        message: 'Loading Page Issues',
+        start: { offset: offset.value },
+        fetch: position => resolved.value.api.client.pages.issues({
+            params: { siteId: resolved.value.siteId },
+            query: {
+                actionId: args.actionId,
+                source: args.source,
+                issue: args.issue,
+                url: args.url,
+                pathPrefix: args.pathPrefix,
+                includeResolved: publicV1BooleanFlagValue(args.includeResolved === true),
+                limit: limit.value,
+                offset: position.offset ?? 0,
+            },
+        }, { signal: runtime.requestSignal }),
+        render: value => renderPageIssues(value.data),
+        next: value => offsetPage({
+            offset: value.data.offset,
+            limit: limit.value,
+            hasMore: value.data.offset + value.data.issues.length < value.data.total,
+        }),
+    });
+}
+async function performanceScans(runtime, globals, args) {
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 100, defaultValue: 25 });
+    if (limit._tag === 'Err')
+        return limit;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading Scans', () => resolved.value.api.client.performance.scans({
+        params: { siteId: resolved.value.siteId },
+        query: { limit: limit.value },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderScans(value.data));
+}
+async function performanceScanDetail(runtime, globals, scanId) {
+    if (!scanId)
+        return fail(EXIT_CODE.invalidInput, 'Pass the Scan id. List them with `nuxtseo scans list`.', undefined, 'invalid_cli_input');
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading Scan', () => resolved.value.api.client.performance.scanDetail({
+        params: { siteId: resolved.value.siteId, scanId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderScanDetail(value.data));
+}
+async function monitoredPages(runtime, globals) {
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading monitored Pages', () => resolved.value.api.client.performance.monitoredPages({
+        params: { siteId: resolved.value.siteId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderMonitoredPages(value.data));
+}
+async function annotationsList(runtime, globals) {
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading annotations', () => resolved.value.api.client.timeline.listAnnotations({
+        params: { siteId: resolved.value.siteId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderAnnotations(value.data));
+}
+const ANNOTATION_DAY = /^\d{4}-\d{2}-\d{2}$/;
+/**
+ * An optional annotation field on the wire. `note` and `url` are nullable, and
+ * the operation clears one when it is sent as null, so the CLI needs a way to
+ * SAY null. An empty flag value is that way: `--note ""` and `--url ""` clear.
+ * Without it there was no clearing at all, and `--url ""` failed SDK body
+ * validation with exit 2 and no request, which is the opposite of the
+ * operation's own documented behaviour.
+ */
+function annotationField(value) {
+    if (value === undefined)
+        return undefined;
+    // Only an exactly empty value clears. Whitespace is content the server
+    // trims, so treating it as a clear would guess at intent.
+    return value === '' ? null : value;
+}
+async function annotationCreate(runtime, globals, args) {
+    if (!args.date || !ANNOTATION_DAY.test(args.date))
+        return fail(EXIT_CODE.invalidInput, 'Pass --date as YYYY-MM-DD.', undefined, 'invalid_cli_input');
+    if (!args.title)
+        return fail(EXIT_CODE.invalidInput, 'Pass --title, the marker label.', undefined, 'invalid_cli_input');
+    const confirmed = await confirmMutation(runtime, globals, `Place an annotation on ${args.date}: ${args.title}?`);
+    if (confirmed._tag === 'Err')
+        return confirmed;
+    if (!confirmed.value) {
+        writeDiagnostic(runtime, 'Mutation cancelled.');
+        return ok(undefined);
+    }
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Creating annotation', () => resolved.value.api.client.timeline.createAnnotation({
+        params: { siteId: resolved.value.siteId },
+        body: { date: args.date, title: args.title, note: annotationField(args.note) ?? null, url: annotationField(args.url) ?? null },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderAnnotation(value.data));
+}
+async function annotationUpdate(runtime, globals, args) {
+    if (!args.annotationId)
+        return fail(EXIT_CODE.invalidInput, 'Pass the annotation id. List them with `nuxtseo annotations list`.', undefined, 'invalid_cli_input');
+    if (args.date !== undefined && !ANNOTATION_DAY.test(args.date))
+        return fail(EXIT_CODE.invalidInput, '--date must be YYYY-MM-DD.', undefined, 'invalid_cli_input');
+    if (args.date === undefined && args.title === undefined && args.note === undefined && args.url === undefined)
+        return fail(EXIT_CODE.invalidInput, 'Pass at least one of --date, --title, --note or --url.', undefined, 'invalid_cli_input');
+    if (args.title !== undefined && args.title.trim() === '')
+        return fail(EXIT_CODE.invalidInput, '--title cannot be empty. Every annotation needs a label.', undefined, 'invalid_cli_input');
+    const confirmed = await confirmMutation(runtime, globals, `Change annotation ${args.annotationId}?`);
+    if (confirmed._tag === 'Err')
+        return confirmed;
+    if (!confirmed.value) {
+        writeDiagnostic(runtime, 'Mutation cancelled.');
+        return ok(undefined);
+    }
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Updating annotation', () => resolved.value.api.client.timeline.updateAnnotation({
+        params: { siteId: resolved.value.siteId, annotationId: args.annotationId },
+        body: { date: args.date, title: args.title, note: annotationField(args.note), url: annotationField(args.url) },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderAnnotation(value.data));
+}
+async function annotationDelete(runtime, globals, args) {
+    if (!args.annotationId)
+        return fail(EXIT_CODE.invalidInput, 'Pass the annotation id. List them with `nuxtseo annotations list`.', undefined, 'invalid_cli_input');
+    const confirmed = await confirmMutation(runtime, globals, `Delete annotation ${args.annotationId}? This cannot be undone.`);
+    if (confirmed._tag === 'Err')
+        return confirmed;
+    if (!confirmed.value) {
+        writeDiagnostic(runtime, 'Mutation cancelled.');
+        return ok(undefined);
+    }
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Deleting annotation', () => resolved.value.api.client.timeline.deleteAnnotation({
+        params: { siteId: resolved.value.siteId, annotationId: args.annotationId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderAnnotationDeleted(value.data));
+}
+async function searchCohorts(runtime, globals, args) {
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 50, defaultValue: 12 });
+    if (limit._tag === 'Err')
+        return limit;
+    const minPages = parseInteger(args.minPages, { name: '--min-pages', minimum: 1, maximum: 500, defaultValue: 5 });
+    if (minPages._tag === 'Err')
+        return minPages;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading route-family indexing', () => resolved.value.api.client.search.readIndexingCohorts({
+        params: { siteId: resolved.value.siteId },
+        query: { limit: limit.value, minSectionPages: minPages.value },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderIndexCohorts(value.data));
+}
+async function researchDomainTraffic(runtime, globals, domain) {
+    if (!domain)
+        return fail(EXIT_CODE.invalidInput, 'Pass the domain, for example nuxtseo.com.', undefined, 'invalid_cli_input');
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Estimating domain traffic', () => resolved.value.api.client.research.domainTraffic({
+        params: { siteId: resolved.value.siteId },
+        query: { domain },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderDomainTraffic(value.data));
+}
+/** Domains arrive as one comma-separated positional, so the count is explicit and quoting is not needed. */
+async function researchDomainAvailability(runtime, globals, input) {
+    const domains = (input ?? '').split(',').map(value => value.trim()).filter(Boolean);
+    if (domains.length === 0)
+        return fail(EXIT_CODE.invalidInput, 'Pass at least one domain.', undefined, 'invalid_cli_input');
+    if (domains.length > 10)
+        return fail(EXIT_CODE.invalidInput, 'Pass at most 10 domains, comma separated.', undefined, 'invalid_cli_input');
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Checking domain availability', () => resolved.value.api.client.research.domainAvailability({
         params: { siteId: resolved.value.siteId },
-        query: { limit: limit.value, offset: offset.value },
+        query: { domains },
     }, { signal: runtime.requestSignal }));
-    return present(runtime, globals, response, value => renderRecoverableBacklinks(value.data));
+    return present(runtime, globals, response, value => renderDomainAvailability(value.data));
+}
+async function backlinksRecoverable(runtime, globals, args) {
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 200, defaultValue: 100 });
+    if (limit._tag === 'Err')
+        return limit;
+    const offset = parseInteger(args.offset, { name: '--offset', minimum: 0, defaultValue: 0 });
+    if (offset._tag === 'Err')
+        return offset;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    return collect(runtime, globals, {
+        all: args.all === true,
+        message: 'Loading recoverable Backlinks',
+        start: { offset: offset.value },
+        fetch: position => resolved.value.api.client.backlinks.recoverable({
+            params: { siteId: resolved.value.siteId },
+            query: { limit: limit.value, offset: position.offset ?? 0 },
+        }, { signal: runtime.requestSignal }),
+        render: value => renderRecoverableBacklinks(value.data),
+        next: value => offsetPage({
+            offset: value.data.offset,
+            limit: limit.value,
+            hasMore: value.data.offset + value.data.items.length < value.data.total,
+        }),
+    });
 }
 async function mentionsList(runtime, globals, args) {
     const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 200, defaultValue: 100 });
@@ -705,7 +1455,7 @@ async function mentionsList(runtime, globals, args) {
         return resolved;
     const response = await withSpinner(runtime, 'Loading Mentions', () => resolved.value.api.client.mentions.list({
         params: { siteId: resolved.value.siteId },
-        query: { limit: limit.value, includeFiltered: args.includeFiltered ? '1' : '0' },
+        query: { limit: limit.value, includeFiltered: publicV1BooleanFlagValue(Boolean(args.includeFiltered)) },
     }, { signal: runtime.requestSignal }));
     return present(runtime, globals, response, value => renderMentions(value.data));
 }
@@ -718,8 +1468,20 @@ function capture(execution, task, positionalArguments, expectedPositionals) {
         execution.result = await task();
     };
 }
-function positional(name, description) {
-    return { type: 'positional', required: true, valueHint: name, description };
+/**
+ * `options` is the machine-readable list of legal values for a positional that
+ * takes one of a fixed set. `--help --json` publishes it, so the skill-command
+ * gate can check a documented `search indexing summary` against what the binary
+ * really accepts instead of taking the tail on trust.
+ */
+function positional(name, description, options) {
+    return {
+        type: 'positional',
+        required: true,
+        valueHint: name,
+        description,
+        ...(options ? { options: [...options] } : {}),
+    };
 }
 export function createRootCommand(runtime, globals, execution) {
     const sites = defineCommand({
@@ -744,8 +1506,13 @@ export function createRootCommand(runtime, globals, execution) {
                 args: {
                     limit: { type: 'string', description: 'Maximum actions, 1 to 25' },
                     offset: { type: 'string', description: 'Pagination offset' },
+                    all: { type: 'boolean', description: 'Repeat until every page is written; one envelope per page' },
                 },
-                run: ({ args }) => capture(execution, () => actionsList(runtime, globals, args.limit, args.offset), args._, 0)(),
+                run: ({ args }) => capture(execution, () => actionsList(runtime, globals, {
+                    limit: args.limit,
+                    offset: args.offset,
+                    all: args.all,
+                }), args._, 0)(),
             }),
             show: defineCommand({
                 meta: { name: 'show', description: 'Show one action and its evidence' },
@@ -767,6 +1534,17 @@ export function createRootCommand(runtime, globals, execution) {
                 args: { actionId: positional('action-id', 'Action ID') },
                 run: ({ args }) => capture(execution, () => actionsResolve(runtime, globals, args.actionId), args._, 1)(),
             }),
+            dismiss: defineCommand({
+                meta: { name: 'dismiss', description: 'Dismiss a broken-page action so the page stays removed' },
+                args: {
+                    'actionId': positional('action-id', 'Action ID'),
+                    'artifact-version': { type: 'string', description: 'The artifactVersion returned with this action' },
+                },
+                run: ({ args }) => capture(execution, () => actionDismiss(runtime, globals, {
+                    actionId: args.actionId,
+                    artifactVersion: args['artifact-version'],
+                }), args._, 1)(),
+            }),
         },
     });
     const page = defineCommand({
@@ -779,14 +1557,41 @@ export function createRootCommand(runtime, globals, execution) {
                     'include-resolved': { type: 'boolean', description: 'Include resolved observations' },
                     'limit': { type: 'string', description: 'Maximum observations, 1 to 200' },
                     'offset': { type: 'string', description: 'Pagination offset' },
+                    'all': { type: 'boolean', description: 'Repeat until every page is written; one envelope per page' },
                 },
                 run: ({ args }) => capture(execution, () => pageInspect(runtime, globals, {
                     url: args.url,
                     includeResolved: args['include-resolved'],
                     limit: args.limit,
                     offset: args.offset,
+                    all: args.all,
                 }), args._, 1)(),
             }),
+            issues: defineCommand({
+                meta: { name: 'issues', description: 'Browse raw Page Issue rows by action, or by source and issue' },
+                args: {
+                    'action-id': { type: 'string', description: 'Action whose stamped observation keys to browse' },
+                    'source': { type: 'string', description: 'Page Issue source family, for example crawl' },
+                    'issue': { type: 'string', description: 'Source-scoped issue type, for example broken-internal-links' },
+                    'url': { type: 'string', description: 'Exact affected URL' },
+                    'path-prefix': { type: 'string', description: 'Only routes whose path starts with this prefix' },
+                    'include-resolved': { type: 'boolean', description: 'Include closed rows and why they closed' },
+                    'limit': { type: 'string', description: 'Maximum rows, 1 to 200' },
+                    'offset': { type: 'string', description: 'Pagination offset' },
+                    'all': { type: 'boolean', description: 'Repeat until every page is written; one envelope per page' },
+                },
+                run: ({ args }) => capture(execution, () => pageIssues(runtime, globals, {
+                    actionId: args['action-id'],
+                    source: args.source,
+                    issue: args.issue,
+                    url: args.url,
+                    pathPrefix: args['path-prefix'],
+                    includeResolved: args['include-resolved'],
+                    limit: args.limit,
+                    offset: args.offset,
+                    all: args.all,
+                }), args._, 0)(),
+            }),
             scan: defineCommand({
                 meta: { name: 'scan', description: 'Start mobile and desktop Page scans' },
                 args: { url: positional('url', 'Absolute Page URL') },
@@ -795,15 +1600,164 @@ export function createRootCommand(runtime, globals, execution) {
         },
     });
     const backlinks = defineCommand({
-        meta: { name: 'backlinks', description: 'Read stored inbound link evidence' },
+        meta: { name: 'backlinks', description: 'Read inbound link evidence for the Site' },
         subCommands: {
-            recoverable: defineCommand({
+            'summary': defineCommand({
+                meta: { name: 'summary', description: 'Read whole-domain inbound link totals' },
+                run: ({ args }) => capture(execution, () => backlinksSummary(runtime, globals), args._, 0)(),
+            }),
+            'referring-domains': defineCommand({
+                meta: { name: 'referring-domains', description: 'List the domains that link to the Site' },
+                args: {
+                    limit: { type: 'string', description: 'Maximum domains, 1 to 1000' },
+                },
+                run: ({ args }) => capture(execution, () => backlinksReferringDomains(runtime, globals, {
+                    limit: args.limit,
+                }), args._, 0)(),
+            }),
+            'anchors': defineCommand({
+                meta: { name: 'anchors', description: 'List the anchor text of inbound links' },
+                args: {
+                    limit: { type: 'string', description: 'Maximum anchors, 1 to 1000' },
+                },
+                run: ({ args }) => capture(execution, () => backlinksAnchors(runtime, globals, {
+                    limit: args.limit,
+                }), args._, 0)(),
+            }),
+            'history': defineCommand({
+                meta: { name: 'history', description: 'Read the monthly inbound link series' },
+                args: {
+                    from: { type: 'string', description: 'Start date, YYYY-MM-DD' },
+                },
+                run: ({ args }) => capture(execution, () => backlinksHistory(runtime, globals, {
+                    from: args.from,
+                }), args._, 0)(),
+            }),
+            'recoverable': defineCommand({
                 meta: { name: 'recoverable', description: 'List inbound links whose destination is broken' },
                 args: {
                     limit: { type: 'string', description: 'Maximum links, 1 to 200' },
                     offset: { type: 'string', description: 'Pagination offset' },
+                    all: { type: 'boolean', description: 'Repeat until every page is written; one envelope per page' },
+                },
+                run: ({ args }) => capture(execution, () => backlinksRecoverable(runtime, globals, {
+                    limit: args.limit,
+                    offset: args.offset,
+                    all: args.all,
+                }), args._, 0)(),
+            }),
+        },
+    });
+    const vitals = defineCommand({
+        meta: { name: 'vitals', description: 'Read field Core Web Vitals from real-user data' },
+        subCommands: {
+            summary: defineCommand({
+                meta: { name: 'summary', description: 'Read the latest field p75 and its change' },
+                args: {
+                    'url': { type: 'string', description: 'One absolute Page URL; omit for the Site origin' },
+                    'form-factor': { type: 'enum', options: [...VITALS_FORM_FACTORS], description: 'Device class' },
+                },
+                run: ({ args }) => capture(execution, () => fieldVitals(runtime, globals, {
+                    view: 'summary',
+                    url: args.url,
+                    formFactor: args['form-factor'],
+                }), args._, 0)(),
+            }),
+            trend: defineCommand({
+                meta: { name: 'trend', description: 'Read the 25-week field p75 series' },
+                args: {
+                    'url': { type: 'string', description: 'One absolute Page URL; omit for the Site origin' },
+                    'form-factor': { type: 'enum', options: [...VITALS_FORM_FACTORS], description: 'Device class' },
+                },
+                run: ({ args }) => capture(execution, () => fieldVitals(runtime, globals, {
+                    view: 'trend',
+                    url: args.url,
+                    formFactor: args['form-factor'],
+                }), args._, 0)(),
+            }),
+            findings: defineCommand({
+                meta: { name: 'findings', description: 'List failing field vitals with the element and a fix prompt' },
+                args: {
+                    'metric': { type: 'enum', options: [...VITALS_METRICS], description: 'Restrict to one vital' },
+                    'only-failing': { type: 'boolean', default: true, description: 'Keep only failing elements; use --no-only-failing for every element' },
+                    'limit': { type: 'string', description: 'Maximum findings, 1 to 50' },
+                    'offset': { type: 'string', description: 'Pagination offset' },
+                    'all': { type: 'boolean', description: 'Repeat until every page is written; one envelope per page' },
                 },
-                run: ({ args }) => capture(execution, () => backlinksRecoverable(runtime, globals, args.limit, args.offset), args._, 0)(),
+                run: ({ args }) => capture(execution, () => fieldVitalFindings(runtime, globals, {
+                    metric: args.metric,
+                    onlyFailing: args['only-failing'],
+                    limit: args.limit,
+                    offset: args.offset,
+                    all: args.all,
+                }), args._, 0)(),
+            }),
+        },
+    });
+    const scans = defineCommand({
+        meta: { name: 'scans', description: 'Read retained Lighthouse Scans and the Pages behind them' },
+        subCommands: {
+            list: defineCommand({
+                meta: { name: 'list', description: 'List retained Scans, newest first' },
+                args: { limit: { type: 'string', description: 'Maximum Scans, 1 to 100' } },
+                run: ({ args }) => capture(execution, () => performanceScans(runtime, globals, { limit: args.limit }), args._, 0)(),
+            }),
+            show: defineCommand({
+                meta: { name: 'show', description: 'Show one Scan with the failing checks behind its scores' },
+                args: { scanId: positional('scan-id', 'Scan ID') },
+                run: ({ args }) => capture(execution, () => performanceScanDetail(runtime, globals, args.scanId), args._, 1)(),
+            }),
+            pages: defineCommand({
+                meta: { name: 'pages', description: 'List the Pages this Site scans on a schedule' },
+                run: ({ args }) => capture(execution, () => monitoredPages(runtime, globals), args._, 0)(),
+            }),
+        },
+    });
+    const annotations = defineCommand({
+        meta: { name: 'annotations', description: 'Mark what changed on the charts for this Site' },
+        subCommands: {
+            list: defineCommand({
+                meta: { name: 'list', description: 'List the chart annotations for this Site' },
+                run: ({ args }) => capture(execution, () => annotationsList(runtime, globals), args._, 0)(),
+            }),
+            create: defineCommand({
+                meta: { name: 'create', description: 'Place one dated marker on the charts for this Site' },
+                args: {
+                    date: { type: 'string', description: 'Day the change happened, YYYY-MM-DD' },
+                    title: { type: 'string', description: 'Marker label' },
+                    note: { type: 'string', description: 'Optional hover description' },
+                    url: { type: 'string', description: 'Optional http(s) link' },
+                },
+                run: ({ args }) => capture(execution, () => annotationCreate(runtime, globals, {
+                    date: args.date,
+                    title: args.title,
+                    note: args.note,
+                    url: args.url,
+                }), args._, 0)(),
+            }),
+            update: defineCommand({
+                meta: { name: 'update', description: 'Change one annotation' },
+                args: {
+                    annotationId: positional('annotation-id', 'Annotation ID'),
+                    date: { type: 'string', description: 'Day the change happened, YYYY-MM-DD' },
+                    title: { type: 'string', description: 'Marker label' },
+                    note: { type: 'string', description: 'Hover description. Pass an empty string to clear it' },
+                    url: { type: 'string', description: 'http(s) link. Pass an empty string to clear it' },
+                },
+                run: ({ args }) => capture(execution, () => annotationUpdate(runtime, globals, {
+                    annotationId: args.annotationId,
+                    date: args.date,
+                    title: args.title,
+                    note: args.note,
+                    url: args.url,
+                }), args._, 1)(),
+            }),
+            delete: defineCommand({
+                meta: { name: 'delete', description: 'Remove one annotation permanently' },
+                args: { annotationId: positional('annotation-id', 'Annotation ID') },
+                run: ({ args }) => capture(execution, () => annotationDelete(runtime, globals, {
+                    annotationId: args.annotationId,
+                }), args._, 1)(),
             }),
         },
     });
@@ -826,11 +1780,11 @@ export function createRootCommand(runtime, globals, execution) {
     const research = defineCommand({
         meta: { name: 'research', description: 'Read stored and live search research' },
         subCommands: {
-            overview: defineCommand({
+            'overview': defineCommand({
                 meta: { name: 'overview', description: 'Read stored Site metrics and competitor research' },
                 run: ({ args }) => capture(execution, () => researchOverview(runtime, globals), args._, 0)(),
             }),
-            keywords: defineCommand({
+            'keywords': defineCommand({
                 meta: { name: 'keywords', description: 'Find live keyword ideas with volume and difficulty' },
                 args: {
                     'topic': positional('topic', 'Keyword or topic'),
@@ -857,7 +1811,17 @@ export function createRootCommand(runtime, globals, execution) {
                     verbose: args.verbose,
                 }), args._, 1)(),
             }),
-            serp: defineCommand({
+            'domain-traffic': defineCommand({
+                meta: { name: 'domain-traffic', description: 'Estimate the organic search traffic of any domain' },
+                args: { domain: positional('domain', 'Domain, for example nuxtseo.com') },
+                run: ({ args }) => capture(execution, () => researchDomainTraffic(runtime, globals, args.domain), args._, 1)(),
+            }),
+            'domain-availability': defineCommand({
+                meta: { name: 'domain-availability', description: 'Check whether domains are registered, up to 10' },
+                args: { domains: positional('domains', 'Comma-separated domains, up to 10') },
+                run: ({ args }) => capture(execution, () => researchDomainAvailability(runtime, globals, args.domains), args._, 1)(),
+            }),
+            'serp': defineCommand({
                 meta: { name: 'serp', description: 'Analyze one live Google SERP' },
                 args: {
                     'keyword': positional('keyword', 'Keyword'),
@@ -870,7 +1834,7 @@ export function createRootCommand(runtime, globals, execution) {
                     locationCode: args['location-code'],
                 }), args._, 1)(),
             }),
-            rankings: defineCommand({
+            'rankings': defineCommand({
                 meta: { name: 'rankings', description: 'Research live keyword rankings for a domain' },
                 args: {
                     'domain': positional('domain', 'Domain without a protocol'),
@@ -906,6 +1870,21 @@ export function createRootCommand(runtime, globals, execution) {
                 meta: { name: 'link-opportunities', description: 'List internal link opportunities' },
                 run: ({ args }) => capture(execution, () => auditLinkOpportunities(runtime, globals), args._, 0)(),
             }),
+            'link-structure': defineCommand({
+                meta: { name: 'link-structure', description: 'Read template links, dead ends, and generic anchors' },
+                run: ({ args }) => capture(execution, () => auditLinkStructure(runtime, globals), args._, 0)(),
+            }),
+            'changes': defineCommand({
+                meta: { name: 'changes', description: 'Compare the latest crawl with its baseline' },
+                args: {
+                    from: { type: 'string', description: 'Baseline crawl generation' },
+                    to: { type: 'string', description: 'Comparison crawl generation' },
+                },
+                run: ({ args }) => capture(execution, () => auditChanges(runtime, globals, {
+                    from: args.from,
+                    to: args.to,
+                }), args._, 0)(),
+            }),
         },
     });
     const content = defineCommand({
@@ -924,11 +1903,13 @@ export function createRootCommand(runtime, globals, execution) {
                             },
                             limit: { type: 'string', description: 'Maximum Content Briefs, 1 to 100' },
                             offset: { type: 'string', description: 'Pagination offset' },
+                            all: { type: 'boolean', description: 'Repeat until every page is written; one envelope per page' },
                         },
                         run: ({ args }) => capture(execution, () => contentBriefList(runtime, globals, {
                             status: args.status,
                             limit: args.limit,
                             offset: args.offset,
+                            all: args.all,
                         }), args._, 0)(),
                     }),
                     show: defineCommand({
@@ -954,39 +1935,66 @@ export function createRootCommand(runtime, globals, execution) {
     const search = defineCommand({
         meta: { name: 'search', description: 'Read Search Console state' },
         subCommands: {
-            status: defineCommand({
+            'status': defineCommand({
                 meta: { name: 'status', description: 'Read the stored Search Console connection' },
                 run: ({ args }) => capture(execution, () => searchStatus(runtime, globals), args._, 0)(),
             }),
-            analytics: defineCommand({
-                meta: { name: 'analytics', description: 'List Search Console query or Page rows' },
+            'analytics': defineCommand({
+                meta: { name: 'analytics', description: 'Read a Search Console breakdown, trend, detail, or analysis' },
                 args: {
-                    'view': positional('pages-or-keywords', 'pages or keywords'),
+                    'view': positional('view', SEARCH_ANALYTICS_VIEWS.join(', '), SEARCH_ANALYTICS_VIEWS),
                     'period': { type: 'enum', options: ['7d', '28d', '3m', '6m', '12m'], description: 'Search Console period' },
                     'limit': { type: 'string', description: 'Maximum rows, 1 to 100' },
                     'page': { type: 'string', description: 'Result page number' },
+                    'all': { type: 'boolean', description: 'Repeat until every page is written; row views only' },
                     'search': { type: 'string', description: 'Filter rows by text' },
                     'sort': { type: 'enum', options: ['clicks', 'impressions', 'ctr', 'position'], description: 'Sort field' },
                     'sort-dir': { type: 'enum', options: ['asc', 'desc'], description: 'Sort direction' },
+                    'filter': { type: 'enum', options: ['top-level', 'new', 'lost', 'improving', 'declining'], description: 'Row set filter' },
+                    'page-url': { type: 'string', description: 'Page URL or path; required for page-detail' },
+                    'keyword': { type: 'string', description: 'Keyword; required for keyword-detail' },
+                    'preset': { type: 'enum', options: [...SEARCH_ANALYSIS_PRESETS], description: 'Analysis preset; required for analysis' },
+                    'brand-terms': { type: 'string', description: 'Comma separated brand terms; required for brand analysis' },
+                    'min-clicks': { type: 'string', description: 'Minimum clicks' },
+                    'max-clicks': { type: 'string', description: 'Maximum clicks' },
+                    'min-impressions': { type: 'string', description: 'Minimum impressions' },
+                    'max-impressions': { type: 'string', description: 'Maximum impressions' },
+                    'min-position': { type: 'string', description: 'Minimum position, 1 to 100' },
+                    'max-position': { type: 'string', description: 'Maximum position, 1 to 100' },
+                    'max-ctr': { type: 'string', description: 'Maximum click-through rate, 0 to 1' },
                 },
                 run: ({ args }) => capture(execution, () => searchAnalytics(runtime, globals, {
                     view: args.view,
                     period: args.period,
                     limit: args.limit,
                     page: args.page,
+                    all: args.all,
                     search: args.search,
                     sort: args.sort,
                     sortDir: args['sort-dir'],
+                    filter: args.filter,
+                    pageUrl: args['page-url'],
+                    keyword: args.keyword,
+                    preset: args.preset,
+                    brandTerms: args['brand-terms'],
+                    minClicks: args['min-clicks'],
+                    maxClicks: args['max-clicks'],
+                    minImpressions: args['min-impressions'],
+                    maxImpressions: args['max-impressions'],
+                    minPosition: args['min-position'],
+                    maxPosition: args['max-position'],
+                    maxCtr: args['max-ctr'],
                 }), args._, 1)(),
             }),
-            indexing: defineCommand({
+            'indexing': defineCommand({
                 meta: { name: 'indexing', description: 'Read retained Search Console indexing coverage' },
                 args: {
-                    view: positional('summary-or-urls', 'summary or urls'),
+                    view: positional('summary-or-urls', 'summary or urls', SEARCH_INDEXING_VIEWS),
                     issue: { type: 'string', description: 'Filter URLs by issue type' },
                     status: { type: 'enum', options: ['indexed', 'not_indexed', 'pending'], description: 'Filter URLs by indexing status' },
                     limit: { type: 'string', description: 'Maximum URLs, 1 to 500' },
                     offset: { type: 'string', description: 'Pagination offset' },
+                    all: { type: 'boolean', description: 'Repeat until every page is written; the urls view only' },
                 },
                 run: ({ args }) => capture(execution, () => searchIndexing(runtime, globals, {
                     view: args.view,
@@ -994,8 +2002,90 @@ export function createRootCommand(runtime, globals, execution) {
                     status: args.status,
                     limit: args.limit,
                     offset: args.offset,
+                    all: args.all,
                 }), args._, 1)(),
             }),
+            'cohorts': defineCommand({
+                meta: { name: 'cohorts', description: 'Read the not-indexed rate per route family' },
+                args: {
+                    'limit': { type: 'string', description: 'Maximum route families, 1 to 50' },
+                    'min-pages': { type: 'string', description: 'Ignore families under this many crawled pages, 1 to 500' },
+                },
+                run: ({ args }) => capture(execution, () => searchCohorts(runtime, globals, {
+                    limit: args.limit,
+                    minPages: args['min-pages'],
+                }), args._, 0)(),
+            }),
+            'index-history': defineCommand({
+                meta: { name: 'index-history', description: 'Read retained indexing changes and their candidate causes' },
+                args: {
+                    url: { type: 'string', description: 'One Page URL or path; omit for the whole Site' },
+                    field: { type: 'enum', options: [...INDEXING_TRANSITION_FIELDS], description: 'Indexing field to track' },
+                    days: { type: 'string', description: 'Window in days, 1 to 730' },
+                },
+                run: ({ args }) => capture(execution, () => searchIndexHistory(runtime, globals, {
+                    url: args.url,
+                    field: args.field,
+                    days: args.days,
+                }), args._, 0)(),
+            }),
+            'inspect': defineCommand({
+                meta: { name: 'inspect', description: 'Read the latest URL Inspection result for one URL' },
+                args: { url: positional('url', 'Page URL or path') },
+                run: ({ args }) => capture(execution, () => searchInspect(runtime, globals, args.url), args._, 1)(),
+            }),
+        },
+    });
+    const sitemaps = defineCommand({
+        meta: { name: 'sitemaps', description: 'Read and manage Search Console sitemaps' },
+        subCommands: {
+            list: defineCommand({
+                meta: { name: 'list', description: 'List the sitemaps Search Console knows' },
+                run: ({ args }) => capture(execution, () => sitemapsList(runtime, globals), args._, 0)(),
+            }),
+            urls: defineCommand({
+                meta: { name: 'urls', description: 'List sitemap URL membership for one generation' },
+                args: {
+                    'generation-id': { type: 'string', description: 'Pin the read to one upstream generation' },
+                    'feedpath': { type: 'string', description: 'Restrict to one sitemap path' },
+                    'cursor': { type: 'string', description: 'Opaque cursor from a previous response' },
+                    'limit': { type: 'string', description: 'Maximum URLs, 1 to 1000' },
+                    'all': { type: 'boolean', description: 'Repeat until every page is written; one envelope per page' },
+                },
+                run: ({ args }) => capture(execution, () => sitemapsUrls(runtime, globals, {
+                    generationId: args['generation-id'],
+                    feedpath: args.feedpath,
+                    cursor: args.cursor,
+                    limit: args.limit,
+                    all: args.all,
+                }), args._, 0)(),
+            }),
+            submit: defineCommand({
+                meta: { name: 'submit', description: 'Submit one sitemap to Search Console' },
+                args: { url: positional('sitemap-url', 'Absolute sitemap URL') },
+                run: ({ args }) => capture(execution, () => sitemapsAction(runtime, globals, 'submit', args.url), args._, 1)(),
+            }),
+            delete: defineCommand({
+                meta: { name: 'delete', description: 'Delete one sitemap from Search Console' },
+                args: { url: positional('sitemap-url', 'Absolute sitemap URL') },
+                run: ({ args }) => capture(execution, () => sitemapsAction(runtime, globals, 'delete', args.url), args._, 1)(),
+            }),
+        },
+    });
+    const skill = defineCommand({
+        meta: { name: 'skill', description: 'Install the packaged coding agent skill' },
+        subCommands: {
+            install: defineCommand({
+                meta: { name: 'install', description: 'Copy the nuxtseo-cli skill into an agent skill directory' },
+                args: {
+                    agent: { type: 'enum', options: [...SKILL_AGENTS], description: 'Agent skill directory; default claude' },
+                    target: { type: 'string', description: 'Write into this directory instead' },
+                },
+                run: ({ args }) => capture(execution, () => skillInstallCommand(runtime, globals, {
+                    agent: args.agent,
+                    target: args.target,
+                }), args._, 0)(),
+            }),
         },
     });
     const timeline = defineCommand({
@@ -1086,8 +2176,44 @@ export function createRootCommand(runtime, globals, execution) {
                 meta: { name: 'performance', description: 'Read the stored Site performance overview' },
                 run: ({ args }) => capture(execution, () => performance(runtime, globals), args._, 0)(),
             }),
+            annotations,
             research,
+            scans,
             search,
+            sitemaps,
+            status: defineCommand({
+                meta: { name: 'status', description: 'Read the Site assessment and the one thing to do next' },
+                run: ({ args }) => capture(execution, () => siteStatus(runtime, globals), args._, 0)(),
+            }),
+            vitals,
+            analytics: defineCommand({
+                meta: { name: 'analytics', description: 'Read Web Analytics for the selected Site' },
+                args: {
+                    'view': positional('view', ANALYTICS_VIEWS.join(', ')),
+                    'period': { type: 'string', description: 'Analytics period, for example 28d' },
+                    'compare': { type: 'enum', options: ['previous', 'year', 'none'], description: 'Comparison window' },
+                    'dimension': { type: 'enum', options: [...ANALYTICS_DIMENSIONS], description: 'Breakdown dimension; required for the dimension view' },
+                    'filters': { type: 'string', description: 'JSON array of dimension filters' },
+                    'phase': { type: 'enum', options: ['current', 'prior', 'full'], description: 'Performance phase' },
+                    'stable-data': { type: 'boolean', default: true, description: 'Exclude unstable recent days; use --no-stable-data to include them' },
+                    'host-scope': { type: 'boolean', default: true, description: 'Restrict to the Site host; use --no-host-scope to include every host' },
+                    'compare-prior': { type: 'boolean', default: true, description: 'Include the prior window; use --no-compare-prior to skip it' },
+                    'fresh': { type: 'boolean', description: 'Bypass the server cache' },
+                },
+                run: ({ args }) => capture(execution, () => analyticsQuery(runtime, globals, {
+                    view: args.view,
+                    period: args.period,
+                    compare: args.compare,
+                    dimension: args.dimension,
+                    filters: args.filters,
+                    performancePhase: args.phase,
+                    stableData: args['stable-data'],
+                    hostScope: args['host-scope'],
+                    comparePrior: args['compare-prior'],
+                    fresh: args.fresh,
+                }), args._, 1)(),
+            }),
+            skill,
             timeline,
         },
     });