@prenta/core 5.5.0 → 5.6.0

package/dist/api/routes/seo.js

@@ -1396,40 +1396,11 @@ export function registerSeoRoutes(router) {
     router.post('/seo/issues/:id/reopen', (request, params) => setIssueStatus(request, params.id, 'open').catch((e) => internalError(e)));
     /** Load the audit entity + collection for an issue's linked document. */
     async function loadIssueFixContext(issue) {
-        if (!issue.entityId) {
-            return { error: errorResponse('This issue is not linked to a content item.', 422) };
-        }
-        const doc = await db().document.findFirst({
-            where: { id: issue.entityId, deletedAt: null },
-            select: {
-                id: true,
-                collection: true,
-                title: true,
-                slug: true,
-                data: true,
-                structuredData: true,
-                plainText: true,
-                publishedAt: true,
-                updatedAt: true,
-            },
-        });
-        if (!doc)
-            return { error: errorResponse('Content not found', 404) };
-        const { documentToAuditEntity, frontEndContentCollectionTypes } = await import('../../seo/audit-runner.js');
-        const { applySeoOverrides, getSeoOverrides } = await import('../../seo/config-store.js');
-        const collectionTypes = frontEndContentCollectionTypes(getPrentaConfig());
-        const overrides = await getSeoOverrides(db()).catch(() => null);
-        const mergedConfig = applySeoOverrides(getPrentaConfig(), overrides);
-        const entity = documentToAuditEntity(doc, collectionTypes, mergedConfig?.seo);
-        if (issue.entityType && entity.entityType !== issue.entityType) {
-            return { error: errorResponse('Issue entity type does not match the linked document.', 409) };
-        }
-        return {
-            collection: doc.collection,
-            entity,
-            updatedAt: doc.updatedAt instanceof Date ? doc.updatedAt : new Date(doc.updatedAt),
-            siteSeo: mergedConfig?.seo,
-        };
+        const { loadIssueFixContext: load } = await import('../../seo/issue-fix-apply.js');
+        const loaded = await load(db(), issue);
+        if (!loaded.ok)
+            return { error: errorResponse(loaded.message, loaded.status) };
+        return loaded.ctx;
     }
     router.post('/seo/issues/:id/suggest-fix', async (request, params) => {
         try {
@@ -1480,12 +1451,31 @@ export function registerSeoRoutes(router) {
                 }
             }
             const { suggestIssueFix } = await import('../../seo/issue-fix.js');
-            const { pendingFixToMetadata } = await import('../../seo/issue-fix-ai.js');
+            const { pendingFixToMetadata, scoreFixBrandAlignment } = await import('../../seo/issue-fix-ai.js');
             const result = await suggestIssueFix(issueInput, fixCtx, aiDeps);
             const existingMeta = asRecord(issue.metadata);
-            const nextMetadata = result.cacheForApply
-                ? { ...existingMeta, ...pendingFixToMetadata(result.suggestion) }
-                : { ...existingMeta, pendingFix: null };
+            let nextMetadata;
+            if (result.cacheForApply) {
+                // Deterministic brand-voice score stamped at generation (no LLM call)
+                // so the proposals inbox can badge it without re-scoring.
+                const { getAIConfig } = await import('../../ai/config-store.js');
+                const brandVoice = await getAIConfig(db())
+                    .then((c) => c.settings.brandVoice)
+                    .catch((err) => {
+                    // Fail open: an unreadable AI config must not cost a working suggestion.
+                    console.warn('[seo/suggest-fix] AI config unavailable for brand alignment', err);
+                    return undefined;
+                });
+                nextMetadata = {
+                    ...existingMeta,
+                    ...pendingFixToMetadata(result.suggestion, {
+                        brandAlignment: scoreFixBrandAlignment(result.suggestion.changes, brandVoice),
+                    }),
+                };
+            }
+            else {
+                nextMetadata = { ...existingMeta, pendingFix: null };
+            }
             await db().seoIssue.update({
                 where: { id: issue.id },
                 data: { metadata: nextMetadata },
@@ -1507,353 +1497,192 @@ export function registerSeoRoutes(router) {
             if (!hasModel(db(), 'seoIssue'))
                 return modelNotAvailable('SeoIssue');
             const body = (await request.json().catch(() => ({})));
+            const { applyIssueFix, VERIFY_FAILED_MESSAGE } = await import('../../seo/issue-fix-apply.js');
+            const result = await applyIssueFix(db(), {
+                issueId: params.id,
+                fingerprint: body?.fingerprint,
+                actor: { userId: auth.session.userId, role: auth.session.role },
+            });
+            switch (result.status) {
+                case 'applied':
+                    return json({ data: { issue: seoIssueToApi(result.issue), applied: result.applied } });
+                case 'stale':
+                    return errorResponse(result.reason, 409);
+                case 'verify-failed':
+                    return json({ error: VERIFY_FAILED_MESSAGE, reason: result.reason }, 409);
+                case 'plan-required':
+                    return planRequiredResponse(result.denial);
+                case 'not-found':
+                    return errorResponse(result.reason, 404);
+                case 'not-allowed':
+                    return errorResponse(result.reason, result.httpStatus);
+                case 'not-fixable':
+                    return errorResponse(result.reason, result.httpStatus);
+                default: {
+                    const _exhaustive = result;
+                    return _exhaustive;
+                }
+            }
+        }
+        catch (err) {
+            return internalError(err, 'seo/issues/:id/apply-fix');
+        }
+    });
+    router.post('/seo/issues/:id/dismiss-fix', async (request, params) => {
+        try {
+            const auth = await requireAuth(request);
+            if (auth.error)
+                return auth.error;
+            const roleErr = requireRole(auth.session.role, WRITE_ROLES);
+            if (roleErr)
+                return roleErr;
+            if (!hasModel(db(), 'seoIssue'))
+                return modelNotAvailable('SeoIssue');
             const issue = await db().seoIssue.findUnique({ where: { id: params.id } });
             if (!issue)
                 return errorResponse('Issue not found', 404);
-            if (issue.status === 'ignored') {
-                return errorResponse('Cannot apply a fix to an ignored issue. Reopen it first.', 409);
-            }
-            const loaded = await loadIssueFixContext(issue);
-            if ('error' in loaded)
-                return loaded.error;
-            const issueInput = {
-                type: issue.type,
-                title: issue.title,
-                recommendation: issue.recommendation,
-                entityType: issue.entityType,
-                entityId: issue.entityId,
-            };
-            const fixCtx = {
-                entity: loaded.entity,
-                siteSeo: loaded.siteSeo,
-                updatedAt: loaded.updatedAt,
-                metadata: asRecord(issue.metadata),
-            };
-            const { REDIRECT_FIX_TYPES, applyBrokenLinkRedirectFix, applyBrokenLinkContentFix } = await import('../../seo/issue-fix-redirect.js');
             const { pendingFixFromMetadata } = await import('../../seo/issue-fix-ai.js');
-            const { verifySeoIssueFix } = await import('../../seo/issue-fix-verify.js');
-            const { INSERT_LINK_FIX_TYPES, applyAndVerifyInternalLinkInsert, buildInsertLinkFingerprint, } = await import('../../seo/issue-fix-link-insert.js');
-            const cachedPending = pendingFixFromMetadata(issue.metadata);
-            const isInsertLinkFix = INSERT_LINK_FIX_TYPES.has(issue.type) || cachedPending?.patch?.fixStrategy === 'insert-link';
-            if (isInsertLinkFix) {
-                const inlinePlanErr = assertPlanFeature('seo.inlineApply');
-                if (inlinePlanErr)
-                    return planRequiredResponse(inlinePlanErr);
-                if (!cachedPending?.autoFixable ||
-                    (cachedPending.patch.fixStrategy !== 'insert-link' &&
-                        !INSERT_LINK_FIX_TYPES.has(issue.type))) {
-                    return errorResponse('This issue does not support an automatic fix.', 422);
-                }
-                if (INSERT_LINK_FIX_TYPES.has(issue.type) &&
-                    cachedPending.patch.fixStrategy &&
-                    cachedPending.patch.fixStrategy !== 'insert-link') {
-                    return errorResponse('This issue does not support an automatic fix.', 422);
-                }
-                const sourceEntityId = typeof cachedPending.patch.sourceEntityId === 'string'
-                    ? cachedPending.patch.sourceEntityId
-                    : '';
-                const targetEntityId = typeof cachedPending.patch.targetEntityId === 'string'
-                    ? cachedPending.patch.targetEntityId
-                    : (issue.entityId ?? '');
-                const targetPath = typeof cachedPending.patch.targetPath === 'string'
-                    ? cachedPending.patch.targetPath
-                    : loaded.entity.url;
-                const anchorText = typeof cachedPending.patch.anchorText === 'string' ? cachedPending.patch.anchorText : '';
-                if (!sourceEntityId || !targetEntityId || !anchorText) {
-                    return errorResponse('This issue does not support an automatic fix.', 422);
-                }
-                if (body?.fingerprint && body.fingerprint !== cachedPending.fingerprint) {
-                    return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
-                }
-                const source = await db().document.findFirst({
-                    where: { id: sourceEntityId, deletedAt: null },
-                    select: { id: true, updatedAt: true },
-                });
-                if (!source)
-                    return errorResponse('Source document not found', 404);
-                const liveFingerprint = buildInsertLinkFingerprint(sourceEntityId, targetEntityId, anchorText, source.updatedAt instanceof Date ? source.updatedAt : new Date(source.updatedAt));
-                if (cachedPending.fingerprint !== liveFingerprint) {
-                    return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
-                }
-                const ctx = buildActionContext(auth.session, db());
-                let verified;
-                try {
-                    const result = await applyAndVerifyInternalLinkInsert({
-                        db: db(),
-                        ctx,
-                        sourceEntityId,
-                        targetEntityId,
-                        anchorText,
-                        targetPath,
-                        siteUrl: getPrentaConfig()?.seo?.siteUrl ?? loaded.siteSeo?.siteUrl ?? '',
-                        navLinks: await gatherNavigationLinkTargets(db()),
-                    });
-                    verified = result.verify;
-                }
-                catch (err) {
-                    const mapped = mapInternalLinkInsertError(err);
-                    if (mapped)
-                        return mapped;
-                    throw err;
-                }
-                if (!verified.ok) {
-                    return json({ error: 'Fix applied but verification failed.', reason: verified.reason }, 409);
-                }
-                const existingMeta = asRecord(issue.metadata);
-                const resolved = await db().seoIssue.update({
-                    where: { id: issue.id },
-                    data: {
-                        status: 'resolved',
-                        resolvedAt: new Date(),
-                        resolvedById: auth.session.userId,
-                        relatedEntityIds: [sourceEntityId],
-                        metadata: { ...existingMeta, pendingFix: null },
-                    },
-                });
-                try {
-                    await logEvent({
-                        event: 'document_updated',
-                        userId: auth.session.userId,
-                        details: {
-                            action: 'seo_issue_fix_applied',
-                            seoFix: 'insert-link',
-                            issueId: issue.id,
-                            issueType: issue.type,
-                            sourceEntityId,
-                            targetEntityId,
-                            targetPath,
-                        },
-                    });
-                }
-                catch {
-                    /* noop */
-                }
-                return json({
-                    data: {
-                        issue: seoIssueToApi(resolved),
-                        applied: cachedPending.changes,
-                    },
-                });
-            }
-            if (REDIRECT_FIX_TYPES.has(issue.type)) {
-                const { buildFixFingerprint } = await import('../../seo/issue-fix.js');
-                const cached = cachedPending;
-                const liveFingerprint = buildFixFingerprint(loaded.entity.entityId, issue.type, loaded.updatedAt);
-                if (!cached?.autoFixable) {
-                    return errorResponse('This issue does not support an automatic fix.', 422);
-                }
-                if (body?.fingerprint && body.fingerprint !== cached.fingerprint) {
-                    return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
-                }
-                if (cached.fingerprint !== liveFingerprint) {
-                    return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
-                }
-                const fixStrategy = cached.patch.fixStrategy === 'fix-link' ? 'fix-link' : 'redirect';
-                try {
-                    if (fixStrategy === 'fix-link') {
-                        const ctx = buildActionContext(auth.session, db());
-                        await applyBrokenLinkContentFix(loaded.collection, loaded.entity.entityId, cached.patch, ctx);
-                    }
-                    else {
-                        await applyBrokenLinkRedirectFix(db(), cached.patch, auth.session.userId);
-                    }
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : 'Fix application failed';
-                    return errorResponse(msg, 400);
-                }
-                const afterDoc = await db().document.findFirst({
-                    where: { id: loaded.entity.entityId, deletedAt: null },
-                    select: { data: true },
-                });
-                const redirectSuggestion = {
-                    autoFixable: true,
-                    fingerprint: cached.fingerprint,
-                    fixStrategy: fixStrategy,
-                    patch: cached.patch,
-                    changes: cached.changes,
-                    justification: cached.justification,
-                    source: cached.source,
-                };
-                const verified = await verifySeoIssueFix({
-                    issueType: issue.type,
-                    suggestion: redirectSuggestion,
-                    entityId: loaded.entity.entityId,
-                    live: { data: asRecord(afterDoc?.data) },
-                    db: db(),
-                    siteUrl: getPrentaConfig()?.seo?.siteUrl ?? loaded.siteSeo?.siteUrl ?? '',
-                    navLinks: await gatherNavigationLinkTargets(db()),
-                });
-                if (!verified.ok) {
-                    return json({ error: 'Fix applied but verification failed.', reason: verified.reason }, 409);
-                }
-                const existingMeta = asRecord(issue.metadata);
-                const resolved = await db().seoIssue.update({
-                    where: { id: issue.id },
-                    data: {
-                        status: 'resolved',
-                        resolvedAt: new Date(),
-                        resolvedById: auth.session.userId,
-                        metadata: { ...existingMeta, pendingFix: null },
-                    },
-                });
-                try {
-                    await logEvent({
-                        event: 'document_updated',
-                        userId: auth.session.userId,
-                        details: {
-                            action: fixStrategy === 'fix-link'
-                                ? 'seo_issue_link_fix_applied'
-                                : 'seo_issue_redirect_applied',
-                            issueId: issue.id,
-                            issueType: issue.type,
-                            ...(fixStrategy === 'fix-link'
-                                ? {
-                                    fixLinkFrom: cached.patch.fixLinkFrom,
-                                    fixLinkTo: cached.patch.fixLinkTo,
-                                }
-                                : {
-                                    redirectFrom: cached.patch.redirectFrom,
-                                    redirectTo: cached.patch.redirectTo,
-                                }),
-                        },
-                    });
-                }
-                catch {
-                    /* noop */
-                }
-                return json({
-                    data: {
-                        issue: seoIssueToApi(resolved),
-                        applied: cached.changes,
-                    },
-                });
-            }
-            const { suggestDeterministicFix, buildFixFingerprint } = await import('../../seo/issue-fix.js');
-            const deterministic = suggestDeterministicFix(issueInput, fixCtx);
-            let suggestion = deterministic;
-            if (!deterministic.autoFixable || Object.keys(deterministic.patch).length === 0) {
-                const inlinePlanErr = assertPlanFeature('seo.inlineApply');
-                if (inlinePlanErr)
-                    return planRequiredResponse(inlinePlanErr);
-                const cached = cachedPending;
-                const liveFingerprint = buildFixFingerprint(loaded.entity.entityId, issue.type, loaded.updatedAt);
-                if (!cached || !cached.autoFixable) {
-                    return errorResponse('This issue does not support an automatic fix.', 422);
-                }
-                if (body?.fingerprint && body.fingerprint !== cached.fingerprint) {
-                    return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
-                }
-                if (cached.fingerprint !== liveFingerprint) {
-                    return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
-                }
-                suggestion = {
-                    autoFixable: true,
-                    source: 'ai',
-                    fingerprint: cached.fingerprint,
-                    patch: cached.patch,
-                    changes: cached.changes,
-                    justification: cached.justification,
-                };
-            }
-            else if (body?.fingerprint && body.fingerprint !== suggestion.fingerprint) {
-                return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
-            }
-            if (!suggestion.autoFixable || Object.keys(suggestion.patch).length === 0) {
-                return errorResponse('This issue does not support an automatic fix.', 422);
-            }
-            const ctx = buildActionContext(auth.session, db());
-            try {
-                await updateDocumentSeoFields(loaded.collection, loaded.entity.entityId, suggestion.patch, ctx);
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : '';
-                if (msg.includes('Access denied'))
-                    return errorResponse('Insufficient permissions', 403);
-                if (msg.includes('not found'))
-                    return errorResponse('Document not found', 404);
-                throw err;
-            }
-            const afterDoc = await db().document.findFirst({
-                where: { id: loaded.entity.entityId, deletedAt: null },
-                select: {
-                    id: true,
-                    collection: true,
-                    title: true,
-                    slug: true,
-                    data: true,
-                    structuredData: true,
-                    plainText: true,
-                    publishedAt: true,
-                    status: true,
-                },
-            });
-            const { documentToAuditEntity, frontEndContentCollectionTypes } = await import('../../seo/audit-runner.js');
-            const liveEntity = afterDoc
-                ? documentToAuditEntity(afterDoc, frontEndContentCollectionTypes(getPrentaConfig()), loaded.siteSeo ?? getPrentaConfig()?.seo)
-                : loaded.entity;
-            // Prefer the rendered/effective meta title so verify matches changes.after
-            // (page-title portion in the patch ≠ rendered title when a template applies).
-            const metaTitleLive = suggestion.changes.some((c) => c.field === 'metaTitle')
-                ? (liveEntity.metaTitle ??
-                    (typeof suggestion.patch.metaTitle === 'string' ? suggestion.patch.metaTitle : null))
-                : (liveEntity.metaTitle ?? null);
-            const verified = await verifySeoIssueFix({
-                issueType: issue.type,
-                suggestion,
-                entityId: loaded.entity.entityId,
-                live: {
-                    data: asRecord(afterDoc?.data),
-                    metaTitle: metaTitleLive,
-                    metaDescription: liveEntity.metaDescription ?? null,
-                    canonical: liveEntity.canonicalUrl ?? null,
-                    noindex: liveEntity.noindex ?? null,
-                    structuredDataType: liveEntity.structuredDataType ?? null,
-                    status: afterDoc ? String(afterDoc.status) : undefined,
-                },
-                db: db(),
-                siteUrl: getPrentaConfig()?.seo?.siteUrl ?? loaded.siteSeo?.siteUrl ?? '',
-                navLinks: await gatherNavigationLinkTargets(db()),
-            });
-            if (!verified.ok) {
-                return json({ error: 'Fix applied but verification failed.', reason: verified.reason }, 409);
-            }
-            const existingMeta = asRecord(issue.metadata);
-            const resolved = await db().seoIssue.update({
+            const cached = pendingFixFromMetadata(issue.metadata);
+            if (!cached)
+                return json({ data: { dismissed: false } });
+            // Sticky: remember which document state was rejected so batch
+            // generation does not recreate it until the document changes. The
+            // marker must match the entity-based live fingerprint the no-cache
+            // path computes, which differs from the cached one for insert-link.
+            const { dismissalFingerprintFor } = await import('../../seo/proposals.js');
+            const entityDoc = typeof issue.entityId === 'string'
+                ? await db()
+                    .document.findUnique({ where: { id: issue.entityId }, select: { updatedAt: true } })
+                    .catch(() => null)
+                : null;
+            const dismissedFingerprint = dismissalFingerprintFor(issue, cached, entityDoc?.updatedAt ?? null);
+            await db().seoIssue.update({
                 where: { id: issue.id },
                 data: {
-                    status: 'resolved',
-                    resolvedAt: new Date(),
-                    resolvedById: auth.session.userId,
-                    metadata: { ...existingMeta, pendingFix: null },
+                    metadata: {
+                        ...asRecord(issue.metadata),
+                        pendingFix: null,
+                        dismissedFingerprint,
+                    },
                 },
             });
             try {
                 await logEvent({
-                    event: 'document_updated',
+                    event: 'seo_fix_dismissed',
                     userId: auth.session.userId,
                     details: {
-                        action: 'seo_issue_fix_applied',
                         issueId: issue.id,
                         issueType: issue.type,
-                        entityId: loaded.entity.entityId,
-                        fields: Object.keys(suggestion.patch),
-                        source: suggestion.source ?? 'deterministic',
+                        entityId: issue.entityId ?? null,
+                        fingerprint: dismissedFingerprint,
+                        source: cached.source,
                     },
                 });
             }
             catch {
-                /* noop */
+                /* audit-log failures never block */
+            }
+            return json({ data: { dismissed: true } });
+        }
+        catch (err) {
+            return internalError(err, 'seo/issues/:id/dismiss-fix');
+        }
+    });
+    // Any authenticated user, like GET /seo/issues and GET /seo/overview: editors
+    // read the inbox and act through the WRITE_ROLES mutation routes.
+    router.get('/seo/proposals', async (request) => {
+        try {
+            const auth = await requireAuth(request);
+            if (auth.error)
+                return auth.error;
+            const { listSeoProposals } = await import('../../seo/proposals.js');
+            return json({ data: await listSeoProposals(db()) });
+        }
+        catch (err) {
+            return internalError(err, 'seo/proposals');
+        }
+    });
+    router.post('/seo/proposals/generate', async (request) => {
+        try {
+            const auth = await requireAuth(request);
+            if (auth.error)
+                return auth.error;
+            const roleErr = requireRole(auth.session.role, ADMIN_ROLES);
+            if (roleErr)
+                return roleErr;
+            const planErr = assertPlanFeature('seo.inlineApply');
+            if (planErr)
+                return planRequiredResponse(planErr);
+            if (!hasModel(db(), 'seoIssue'))
+                return modelNotAvailable('SeoIssue');
+            const body = (await request.json().catch(() => ({})));
+            if (body?.confirm !== true) {
+                return errorResponse('Pass { "confirm": true } to generate proposals.', 400);
+            }
+            if (!(await checkRateLimitAsync(aiGenerateLimiter, `ai-seo-proposals-generate:${auth.session.userId}`))) {
+                return errorResponse('AI rate limit reached. Try again in an hour.', 429);
+            }
+            const { generateSeoProposals } = await import('../../seo/proposals-generate.js');
+            const result = await generateSeoProposals(db(), { userId: auth.session.userId });
+            return json({ data: result });
+        }
+        catch (err) {
+            return internalError(err, 'seo/proposals/generate');
+        }
+    });
+    // WRITE_ROLES like the per-item apply-fix route; redirect items are
+    // additionally admin-gated per item inside the service (spec §4).
+    router.post('/seo/proposals/bulk-apply', async (request) => {
+        try {
+            const auth = await requireAuth(request);
+            if (auth.error)
+                return auth.error;
+            const roleErr = requireRole(auth.session.role, WRITE_ROLES);
+            if (roleErr)
+                return roleErr;
+            if (!hasModel(db(), 'seoIssue'))
+                return modelNotAvailable('SeoIssue');
+            const body = (await request.json().catch(() => ({})));
+            const rawItems = Array.isArray(body?.items) ? body.items : null;
+            if (!rawItems || rawItems.length === 0) {
+                return errorResponse('items must be a non-empty array.', 400);
+            }
+            const { PROPOSAL_BULK_APPLY_MAX, bulkApplySeoProposals } = await import('../../seo/proposals-bulk-apply.js');
+            if (rawItems.length > PROPOSAL_BULK_APPLY_MAX) {
+                return errorResponse(`At most ${PROPOSAL_BULK_APPLY_MAX} items per bulk apply.`, 400);
+            }
+            const items = [];
+            for (const raw of rawItems) {
+                const r = asRecord(raw);
+                if ((r.kind !== 'issue-fix' && r.kind !== 'redirect') ||
+                    typeof r.id !== 'string' ||
+                    !r.id) {
+                    return errorResponse('Each item needs kind ("issue-fix" | "redirect") and id.', 400);
+                }
+                items.push({
+                    kind: r.kind,
+                    id: r.id,
+                    fingerprint: typeof r.fingerprint === 'string' ? r.fingerprint : undefined,
+                });
+            }
+            const result = await bulkApplySeoProposals(db(), {
+                items,
+                actor: { userId: auth.session.userId, role: auth.session.role },
+            });
+            if (result.blocked) {
+                return json({ error: result.reason, code: 'governance_blocked' }, 403);
             }
             return json({
                 data: {
-                    issue: seoIssueToApi(resolved),
-                    applied: suggestion.changes,
+                    results: result.results,
+                    applied: result.applied,
+                    failed: result.failed,
+                    pending: result.pending,
                 },
             });
         }
         catch (err) {
-            return internalError(err, 'seo/issues/:id/apply-fix');
+            return internalError(err, 'seo/proposals/bulk-apply');
         }
     });
     router.get('/seo/overview', async (request) => {
@@ -1900,6 +1729,11 @@ export function registerSeoRoutes(router) {
                 warning: openIssues.filter((i) => i.severity === 'warning').length,
                 info: openIssues.filter((i) => i.severity === 'info').length,
             };
+            const { countPendingProposals } = await import('../../seo/proposals.js');
+            const pendingProposals = await countPendingProposals(db(), openIssues).catch(() => ({
+                issueFixes: 0,
+                redirects: 0,
+            }));
             const scoreAfter = lastRun?.siteScoreAfter ?? null;
             const scoreBefore = lastRun?.siteScoreBefore ?? null;
             const breakdown = lastRun?.metadata?.breakdown ?? [];
@@ -2019,6 +1853,7 @@ export function registerSeoRoutes(router) {
                     searchConsoleConnected: moduleSettings.searchConsoleConnected,
                     lastAuditRunId: lastRun?.id ?? null,
                     auditTruncated,
+                    pendingProposals,
                 },
             });
         }