dineway 0.1.49 → 0.2.1

package/dist/astro/routes/api/mcp.mjs

@@ -1,38 +1,359 @@
 import "../../../dialect-helpers-fk43GbDb.mjs";
 import "../../../base64-F8-DUraK.mjs";
-import "../../../types-CSgR9nQB.mjs";
-import "../../../loader--GOYux8M.mjs";
-import "../../../content-CBxYGWfL.mjs";
-import "../../../media-CbKyYukG.mjs";
-import "../../../options-LsPjZlqD.mjs";
-import "../../../site-activity-DONFrMBJ.mjs";
-import { t as ReviewRequestRepository } from "../../../review-requests-BW2NxY-l.mjs";
-import "../../../entity-aliases-4y93Yjuc.mjs";
-import "../../../request-cache-ho99schz.mjs";
-import { a as ContextRepository, i as parseSiteBriefingScope, r as formatSiteBriefingText, t as SiteBriefingAssembler } from "../../../briefing-CkTee1ex.mjs";
-import { t as SITE_CONTEXT_TYPES } from "../../../context-types-r8oFvyOq.mjs";
-import "../../../fts-manager-B5l_qwrA.mjs";
-import "../../../registry-D7HACema.mjs";
-import "../../../settings-CUXOxzsT.mjs";
-import { n as VERSION } from "../../../version-C4gfn0PJ.mjs";
-import "../../../query-CZ3TH_Uu.mjs";
-import "../../../zod-generator-K91-g665.mjs";
-import "../../../schema-Bsi-VpYv.mjs";
-import { t as apiError } from "../../../error-DCSuUAZW.mjs";
-import { P as settingsUpdateBody, Sn as contentBylineInputSchema, sn as contentSeoInput } from "../../../redirects-ocRJmQHP.mjs";
-import "../../../byline-fields-cNrLJVRs.mjs";
+import "../../../types-ChxYDRvx.mjs";
+import "../../../loader-aWkkc1_o.mjs";
+import "../../../object-cache-D51qOseS.mjs";
+import "../../../content-DJcAYFhz.mjs";
+import "../../../media-CVMOoywq.mjs";
+import "../../../options-DQPTH5n0.mjs";
+import "../../../site-activity-h8smOlYI.mjs";
+import { t as ReviewRequestRepository } from "../../../review-requests-CTWGnWUt.mjs";
+import { a as HITL_REQUEST_STATUSES, i as HITL_REQUEST_PRIORITIES, o as HitlRequestRepository, r as ReleasePayloadBuilder, t as PublicationAuthorizationError } from "../../../publication-authorization-RKiHXKtq.mjs";
+import { C as ASSIGNMENT_STATUSES, S as ASSIGNMENT_PRIORITIES, _ as toPublicContextDiff, a as EntityResolver, b as HitlRequestService, d as SettingsHitlPayloadBuilder, g as RiskPolicyEvaluator, h as SchemaHitlPayloadBuilder, i as ActorExpertiseService, n as AssignmentService, r as HandoffSnapshotStore, t as WorkflowHitlCoordinator, v as toPublicContextEntry, x as ASSIGNMENT_ACTOR_TYPES, y as toPublicContextEntryPage } from "../../../site-context-B8T1kpUP.mjs";
+import "../../../request-cache-CBFjCwSt.mjs";
+import { a as ContextRepository, i as parseSiteBriefingScope, r as formatSiteBriefingText, t as SiteBriefingAssembler } from "../../../briefing-0rf-su3-.mjs";
+import { t as SITE_CONTEXT_TYPES } from "../../../context-types-eBuMDAg-.mjs";
+import "../../../content-refresh-B4ZCmxgd.mjs";
+import "../../../fts-manager-ewTGohf4.mjs";
+import "../../../registry-BYYyb2tF.mjs";
+import { a as getSiteSettingsWithDb } from "../../../settings-BECcAIRH.mjs";
+import { t as ReviewPayloadBuilder } from "../../../review-payload-BysRWpxS.mjs";
+import { n as VERSION } from "../../../version-C3iVRuaF.mjs";
+import "../../../query-C2U5u5_p.mjs";
+import "../../../zod-generator-C7AsLpSB.mjs";
+import "../../../schema-DUtnZxjZ.mjs";
+import { t as apiError } from "../../../error-CSVaQNZy.mjs";
+import { Cn as contentBylineInputSchema, P as settingsUpdateBody, _n as bylineCreateBody, cn as contentSeoInput, xn as bylineUpdateBody } from "../../../redirects-Bhpm8bRe.mjs";
+import "../../../byline-fields-WN7RQT4q.mjs";
+import "../../../status-NqWOSFAD.mjs";
 import "../../../api/schemas/index.mjs";
-import "../../../utils-B8hBJ9Oz.mjs";
-import "../../../search-Gdrqj582.mjs";
-import { i as hasScope } from "../../../api-tokens-CYUoFGo7.mjs";
-import { C as HITL_REQUEST_STATUSES, E as ASSIGNMENT_STATUSES, S as HITL_REQUEST_PRIORITIES, T as ASSIGNMENT_PRIORITIES, _ as RiskPolicyEvaluator, a as ActorExpertiseService, b as toPublicContextEntry, f as SettingsHitlPayloadBuilder, g as SchemaHitlPayloadBuilder, i as HandoffSnapshotStore, n as HitlRequestService, o as EntityResolver, r as AssignmentService, t as WorkflowHitlCoordinator, v as ReviewPayloadBuilder, w as ASSIGNMENT_ACTOR_TYPES, x as toPublicContextEntryPage, y as toPublicContextDiff } from "../../../site-context-C8Az_P_I.mjs";
-import { T as resolveActorIdentity, b as schemaMcpToolSource, d as logSchemaActivity, o as logContentActivity, p as logSiteActivitySafely, r as contentMcpToolSource, t as activityChangedKeys } from "../../../activity-events-CwM7yxPW.mjs";
+import { i as hasScope } from "../../../api-tokens-Ypaly90d.mjs";
+import { r as registerPluginMcpRegistry, t as createReviewedPluginMcpCommandExecutor } from "../../../mcp-reviewed-executor-Dn52L_yY.mjs";
+import { n as resolveActorIdentity } from "../../../actor-0QJ1Gbtf.mjs";
+import "../../../activity-DUaz_w7p.mjs";
+import { d as logSchemaActivity, o as logContentActivity, p as logSiteActivitySafely, r as contentMcpToolSource, t as activityChangedKeys, x as schemaMcpToolSource } from "../../../activity-events-CJDvE2uc.mjs";
+import "../../../utils-D1SrKGtP.mjs";
+import "../../../search-DUKgZUlm.mjs";
+import { n as SeoProviderEvidenceService, t as ForgewaySeoGatewayClient } from "../../../forgeway-seo-client-G5ddhVHd.mjs";
+import { n as convertDataForWrite, t as convertDataForRead } from "../../../portable-text-BASHceim.mjs";
 import { z } from "zod";
 import { Role, canActOnOwn, hasPermission } from "@dineway-ai/auth";
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 
+//#region src/mcp/seo-provider-tools.ts
+const annotations = {
+	readOnlyHint: true,
+	destructiveHint: false,
+	idempotentHint: false,
+	openWorldHint: true
+};
+const forceRefreshInput = { force_refresh: z.boolean().optional().describe("Bypass the managed provider cache") };
+const dataForSeoCommonInput = {
+	location_code: z.number().int().min(1).max(1e7).optional(),
+	language_code: z.string().trim().min(1).max(20).optional(),
+	device: z.enum(["desktop", "mobile"]).optional(),
+	...forceRefreshInput
+};
+function serviceOrThrow(service) {
+	if (!service) throw new Error("Dineway hosted SEO provider evidence is unavailable in this runtime.");
+	return service;
+}
+function jsonResult$1(data) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(data, null, 2)
+	}] };
+}
+function errorResult$1(error) {
+	return {
+		content: [{
+			type: "text",
+			text: error instanceof Error ? error.message : "SEO provider evidence request failed."
+		}],
+		isError: true
+	};
+}
+function registerSeoProviderTools(server, options) {
+	server.registerTool("seo_firecrawl_scrape", {
+		title: "Scrape URL with Firecrawl",
+		description: "Fetch bounded managed-provider evidence for one HTTP(S) URL. Returns raw evidence without interpretation or persistence.",
+		inputSchema: z.object({
+			url: z.string().trim().min(1).max(2048),
+			formats: z.array(z.string().trim().min(1).max(50)).min(1).max(10).optional(),
+			only_main_content: z.boolean().optional(),
+			timeout_ms: z.number().int().min(1e3).max(12e4).optional(),
+			...forceRefreshInput
+		}),
+		annotations
+	}, async (args, extra) => {
+		options.authorize(extra);
+		try {
+			return jsonResult$1(await serviceOrThrow(options.service).firecrawlScrape({
+				url: args.url,
+				formats: args.formats,
+				onlyMainContent: args.only_main_content,
+				timeoutMs: args.timeout_ms,
+				forceRefresh: args.force_refresh
+			}));
+		} catch (error) {
+			return errorResult$1(error);
+		}
+	});
+	server.registerTool("seo_firecrawl_map", {
+		title: "Map URLs with Firecrawl",
+		description: "Discover a bounded URL map for one HTTP(S) origin through the managed provider bridge.",
+		inputSchema: z.object({
+			url: z.string().trim().min(1).max(2048),
+			search: z.string().trim().min(1).max(500).optional(),
+			sitemap: z.enum([
+				"skip",
+				"include",
+				"only"
+			]).optional(),
+			limit: z.number().int().min(1).max(1e3).optional(),
+			include_subdomains: z.boolean().optional(),
+			ignore_query_parameters: z.boolean().optional(),
+			...forceRefreshInput
+		}),
+		annotations
+	}, async (args, extra) => {
+		options.authorize(extra);
+		try {
+			return jsonResult$1(await serviceOrThrow(options.service).firecrawlMap({
+				url: args.url,
+				search: args.search,
+				sitemap: args.sitemap,
+				limit: args.limit,
+				includeSubdomains: args.include_subdomains,
+				ignoreQueryParameters: args.ignore_query_parameters,
+				forceRefresh: args.force_refresh
+			}));
+		} catch (error) {
+			return errorResult$1(error);
+		}
+	});
+	server.registerTool("seo_firecrawl_crawl_start", {
+		title: "Start Firecrawl Crawl",
+		description: "Start one bounded managed crawl and return the raw provider task payload. Does not create a Dineway workflow task.",
+		inputSchema: z.object({
+			url: z.string().trim().min(1).max(2048),
+			limit: z.number().int().min(1).max(1e3).optional(),
+			max_discovery_depth: z.number().int().min(0).max(20).optional(),
+			allow_external_links: z.boolean().optional(),
+			allow_subdomains: z.boolean().optional(),
+			scrape_formats: z.array(z.string().trim().min(1).max(50)).min(1).max(10).optional(),
+			...forceRefreshInput
+		}),
+		annotations
+	}, async (args, extra) => {
+		options.authorize(extra);
+		try {
+			return jsonResult$1(await serviceOrThrow(options.service).firecrawlCrawlStart({
+				url: args.url,
+				limit: args.limit,
+				maxDiscoveryDepth: args.max_discovery_depth,
+				allowExternalLinks: args.allow_external_links,
+				allowSubdomains: args.allow_subdomains,
+				scrapeFormats: args.scrape_formats,
+				forceRefresh: args.force_refresh
+			}));
+		} catch (error) {
+			return errorResult$1(error);
+		}
+	});
+	server.registerTool("seo_firecrawl_crawl_status", {
+		title: "Get Firecrawl Crawl Status",
+		description: "Read the raw status of one managed crawl by its provider crawl ID.",
+		inputSchema: z.object({ id: z.string().trim().min(1).max(500) }),
+		annotations
+	}, async (args, extra) => {
+		options.authorize(extra);
+		try {
+			return jsonResult$1(await serviceOrThrow(options.service).firecrawlCrawlStatus({ id: args.id }));
+		} catch (error) {
+			return errorResult$1(error);
+		}
+	});
+	server.registerTool("seo_firecrawl_search", {
+		title: "Search with Firecrawl",
+		description: "Return bounded raw web-search evidence through the managed provider bridge.",
+		inputSchema: z.object({
+			query: z.string().trim().min(1).max(1e3),
+			limit: z.number().int().min(1).max(1e3).optional(),
+			scrape: z.boolean().optional(),
+			...forceRefreshInput
+		}),
+		annotations
+	}, async (args, extra) => {
+		options.authorize(extra);
+		try {
+			return jsonResult$1(await serviceOrThrow(options.service).firecrawlSearch({
+				query: args.query,
+				limit: args.limit,
+				scrape: args.scrape,
+				forceRefresh: args.force_refresh
+			}));
+		} catch (error) {
+			return errorResult$1(error);
+		}
+	});
+	server.registerTool("seo_dataforseo_serp", {
+		title: "Get Organic SERP Evidence",
+		description: "Return bounded raw Google organic SERP evidence for one keyword.",
+		inputSchema: z.object({
+			keyword: z.string().trim().min(1).max(1e3),
+			depth: z.number().int().min(1).max(100).optional(),
+			...dataForSeoCommonInput
+		}),
+		annotations
+	}, async (args, extra) => {
+		options.authorize(extra);
+		try {
+			return jsonResult$1(await serviceOrThrow(options.service).dataForSeoSerp({
+				keyword: args.keyword,
+				depth: args.depth,
+				locationCode: args.location_code,
+				languageCode: args.language_code,
+				device: args.device,
+				forceRefresh: args.force_refresh
+			}));
+		} catch (error) {
+			return errorResult$1(error);
+		}
+	});
+	server.registerTool("seo_dataforseo_maps", {
+		title: "Get Maps SERP Evidence",
+		description: "Return bounded raw Google Maps SERP evidence for one keyword.",
+		inputSchema: z.object({
+			keyword: z.string().trim().min(1).max(1e3),
+			depth: z.number().int().min(1).max(100).optional(),
+			...dataForSeoCommonInput
+		}),
+		annotations
+	}, async (args, extra) => {
+		options.authorize(extra);
+		try {
+			return jsonResult$1(await serviceOrThrow(options.service).dataForSeoMaps({
+				keyword: args.keyword,
+				depth: args.depth,
+				locationCode: args.location_code,
+				languageCode: args.language_code,
+				device: args.device,
+				forceRefresh: args.force_refresh
+			}));
+		} catch (error) {
+			return errorResult$1(error);
+		}
+	});
+	server.registerTool("seo_dataforseo_keywords", {
+		title: "Get Keyword Evidence",
+		description: "Return bounded raw keyword suggestions for one seed keyword.",
+		inputSchema: z.object({
+			keyword: z.string().trim().min(1).max(1e3),
+			limit: z.number().int().min(1).max(1e3).optional(),
+			...dataForSeoCommonInput
+		}),
+		annotations
+	}, async (args, extra) => {
+		options.authorize(extra);
+		try {
+			return jsonResult$1(await serviceOrThrow(options.service).dataForSeoKeywords({
+				keyword: args.keyword,
+				limit: args.limit,
+				locationCode: args.location_code,
+				languageCode: args.language_code,
+				device: args.device,
+				forceRefresh: args.force_refresh
+			}));
+		} catch (error) {
+			return errorResult$1(error);
+		}
+	});
+	server.registerTool("seo_dataforseo_competitors", {
+		title: "Get Competitor Domain Evidence",
+		description: "Return bounded raw competitor-domain evidence for one target domain.",
+		inputSchema: z.object({
+			domain: z.string().trim().min(1).max(253),
+			limit: z.number().int().min(1).max(1e3).optional(),
+			...dataForSeoCommonInput
+		}),
+		annotations
+	}, async (args, extra) => {
+		options.authorize(extra);
+		try {
+			return jsonResult$1(await serviceOrThrow(options.service).dataForSeoCompetitors({
+				domain: args.domain,
+				limit: args.limit,
+				locationCode: args.location_code,
+				languageCode: args.language_code,
+				device: args.device,
+				forceRefresh: args.force_refresh
+			}));
+		} catch (error) {
+			return errorResult$1(error);
+		}
+	});
+	server.registerTool("seo_dataforseo_ai_scrape", {
+		title: "Get Managed AI Result Evidence",
+		description: "Return raw managed AI-result evidence for one keyword. This does not replace direct user-account observations.",
+		inputSchema: z.object({
+			keyword: z.string().trim().min(1).max(1e3),
+			platform: z.enum([
+				"chat_gpt",
+				"gemini",
+				"perplexity"
+			]).optional(),
+			...dataForSeoCommonInput
+		}),
+		annotations
+	}, async (args, extra) => {
+		options.authorize(extra);
+		try {
+			return jsonResult$1(await serviceOrThrow(options.service).dataForSeoAiScrape({
+				keyword: args.keyword,
+				platform: args.platform,
+				locationCode: args.location_code,
+				languageCode: args.language_code,
+				device: args.device,
+				forceRefresh: args.force_refresh
+			}));
+		} catch (error) {
+			return errorResult$1(error);
+		}
+	});
+	server.registerTool("seo_dataforseo_ai_mentions", {
+		title: "Get Managed AI Mention Evidence",
+		description: "Return bounded raw managed mention evidence for a domain, keyword, or both. This does not generate visibility conclusions.",
+		inputSchema: z.object({
+			domain: z.string().trim().min(1).max(253).optional(),
+			keyword: z.string().trim().min(1).max(1e3).optional(),
+			platform: z.enum(["google", "chat_gpt"]).optional(),
+			limit: z.number().int().min(1).max(1e3).optional(),
+			...dataForSeoCommonInput
+		}),
+		annotations
+	}, async (args, extra) => {
+		options.authorize(extra);
+		try {
+			return jsonResult$1(await serviceOrThrow(options.service).dataForSeoAiMentions({
+				domain: args.domain,
+				keyword: args.keyword,
+				platform: args.platform,
+				limit: args.limit,
+				locationCode: args.location_code,
+				languageCode: args.language_code,
+				device: args.device,
+				forceRefresh: args.force_refresh
+			}));
+		} catch (error) {
+			return errorResult$1(error);
+		}
+	});
+}
+
+//#endregion
 //#region src/mcp/server.ts
 const COLLECTION_SLUG_PATTERN = /^[a-z][a-z0-9_]*$/;
 const ENTITY_RESOLVE_TYPES = [
@@ -101,6 +422,28 @@ function getExtra(extra) {
 function getDineway(extra) {
 	return getExtra(extra).dineway;
 }
+async function getCollectionFields(dineway, collection) {
+	try {
+		const { SchemaRegistry } = await import("../../../schema-DUtnZxjZ.mjs").then((n) => n.t);
+		return (await new SchemaRegistry(dineway.db).getCollectionWithFields(collection))?.fields ?? null;
+	} catch {
+		return null;
+	}
+}
+async function convertWriteData(dineway, collection, data) {
+	const fields = await getCollectionFields(dineway, collection);
+	if (!fields) return data;
+	return convertDataForWrite(data, fields);
+}
+async function applyReadMarkdown(dineway, collection, items) {
+	const fields = await getCollectionFields(dineway, collection);
+	if (!fields) return;
+	for (const item of items) if (item.data && typeof item.data === "object") item.data = convertDataForRead(item.data, fields, false);
+}
+async function invalidateBylines() {
+	const { invalidateBylineCache } = await import("../../../bylines-CmZFCMr0.mjs").then((n) => n.t);
+	invalidateBylineCache();
+}
 function canReadDrafts(extra) {
 	return hasPermission({ role: getExtra(extra).userRole }, "content:read_drafts");
 }
@@ -240,7 +583,8 @@ function scopeReadableForExpertise(payload, scope) {
 			case "menu": return contentDiffReadableForHandoff(payload);
 			case "collection":
 			case "site": return contentDiffReadableForHandoff(payload) || schemaReadableForHandoff(payload) || pluginsReadableForHandoff(payload);
-			case "plugin": return pluginsReadableForHandoff(payload);
+			case "plugin":
+			case "plugin_extension": return pluginsReadableForHandoff(payload);
 		}
 	} catch {
 		return false;
@@ -275,27 +619,83 @@ function allowedEntityResolveTypes(payload, requestedTypes) {
 	if (disallowed.length > 0) throw new McpError(ErrorCode.InvalidRequest, `Insufficient scope or role for entity types: ${disallowed.join(", ")}`);
 	return requestedTypes;
 }
-function contentPublishReviewRequired(extra) {
-	const payload = getExtra(extra);
-	const actor = resolveActorIdentity(actorLocals(payload));
-	return new RiskPolicyEvaluator({
-		db: payload.dineway.db,
-		handlers: payload.dineway
-	}).requiresContentPublishReview(actor);
+function contentPublicationService(payload) {
+	return payload.dineway.createPublicationAuthorizationService();
 }
-async function requireApprovedContentPublishReview(extra, collection, id, reviewRequestId) {
-	const payload = getExtra(extra);
+function contentPublicationError(error) {
+	return error instanceof PublicationAuthorizationError ? errorResult(`[${error.code}] ${error.message}`) : errorResult(error);
+}
+async function ensureContentReleaseRequest(payload, input) {
 	const actor = resolveActorIdentity(actorLocals(payload));
-	const decision = await new RiskPolicyEvaluator({
-		db: payload.dineway.db,
-		handlers: payload.dineway
-	}).evaluateContentPublishReview({
-		actor,
-		collection,
-		id,
-		reviewRequestId
+	const settings = await getSiteSettingsWithDb(payload.dineway.db);
+	const release = await new ReleasePayloadBuilder({
+		handlers: payload.dineway,
+		reviewRequests: new ReviewRequestRepository(payload.dineway.db)
+	}).buildContentReleasePayload({
+		collection: input.collection,
+		id: input.id,
+		operation: input.operation,
+		editorialReviewRequestId: input.editorialReviewRequestId,
+		publishedAt: input.publishedAt,
+		scheduledAt: input.scheduledAt,
+		siteTimezone: settings.timezone?.trim() || "UTC"
+	});
+	const repository = new HitlRequestRepository(payload.dineway.db);
+	const existing = (await repository.list({
+		scope: release.scope,
+		statuses: ["pending", "approved"],
+		actionType: release.actionType,
+		targetRefType: "content",
+		targetRefId: release.entryId,
+		requestedByActorType: actor.actorType,
+		requestedByActorId: actor.actorId,
+		limit: 100
+	})).items.find((request) => request.metadata.actionHash === release.actionHash);
+	if (existing) return {
+		created: false,
+		request: existing
+	};
+	const request = await repository.create({
+		scope: release.scope,
+		actionType: release.actionType,
+		title: `${input.operation === "publish" ? "Publish" : "Schedule"} ${release.collection}/${release.entryId}`,
+		summary: `Authorize exact ${input.operation} release for reviewed Draft`,
+		riskReason: "Agent-authenticated content release requires explicit approval.",
+		reviewPayload: release.releasePayload,
+		targetRefType: "content",
+		targetRefId: release.entryId,
+		requestedByActorType: actor.actorType,
+		requestedByActorId: actor.actorId,
+		requestedAuthMetadata: actor.authMetadata,
+		metadata: {
+			actionHash: release.actionHash,
+			editorialReviewRequestId: release.editorialReviewRequestId,
+			operation: release.operation,
+			scheduledAt: release.scheduledAt,
+			publishedAt: release.publishedAt
+		}
 	});
-	if (!decision.allowed) throw new McpError(ErrorCode.InvalidRequest, decision.message);
+	await logSiteActivitySafely(payload.dineway.db, actorLocals(payload), {
+		actionType: "hitl.submitted",
+		subjectType: "hitl_request",
+		subjectId: request.id,
+		scope: request.scope,
+		sourceType: "mcp_tool",
+		sourceName: "content_release_request",
+		resultStatus: "pending",
+		summary: `Submitted release request for ${release.actionType}`,
+		detail: {
+			collection: release.collection,
+			entryId: release.entryId,
+			operation: release.operation,
+			editorialReviewRequestId: release.editorialReviewRequestId,
+			actionHash: release.actionHash
+		}
+	});
+	return {
+		created: true,
+		request
+	};
 }
 async function ensureWorkflowHitlRequest(extra, action) {
 	const payload = getExtra(extra);
@@ -426,11 +826,18 @@ async function logMcpContentActivity(dineway, locals, collection, entryId, actio
 function experimentalWorkflowDescription(description) {
 	return "Experimental: this deferred Site Context workflow surface exists on the current branch but is not part of the approved baseline contract. " + description;
 }
-function createMcpServer() {
+function createMcpServer(options = {}) {
 	const server = new McpServer({
 		name: "dineway",
 		version: VERSION
 	}, { capabilities: { logging: {} } });
+	registerSeoProviderTools(server, {
+		service: options.seoProviderService,
+		authorize: (extra) => {
+			requireScope(extra, "seo:read");
+			requireRole(extra, Role.AUTHOR);
+		}
+	});
 	server.registerTool("site_briefing_get", {
 		title: "Get Site Briefing",
 		description: "Build a read-only Site Context Engine briefing for a site, collection, content item, plugin, taxonomy, or menu scope. The briefing includes inherited scopes, authorized schema, recent activity, active plugin capabilities, curated settings/SEO, and forward-compatible context/review/staleness sections.",
@@ -457,6 +864,7 @@ function createMcpServer() {
 				db: ec.db,
 				storage: ec.storage,
 				configuredPlugins: ec.configuredPlugins,
+				sandboxedPluginEntries: ec.sandboxedPluginEntries,
 				marketplaceUrl: ec.config.marketplace,
 				permissions: briefingPermissions(payload)
 			}).assemble({
@@ -859,7 +1267,7 @@ function createMcpServer() {
 	});
 	server.registerTool("assignment_create", {
 		title: "Create Assignment",
-		description: experimentalWorkflowDescription("Create a workflow assignment attached to a Dineway scope. Assignments are durable human-agent handoffs and must use explicit lifecycle transitions instead of ad hoc status patches."),
+		description: "Create a workflow assignment attached to a Dineway scope. Assignments are durable human-agent handoffs and must use explicit lifecycle transitions instead of ad hoc status patches.",
 		inputSchema: z.object({
 			scope: z.string().describe("Assignment scope string."),
 			assignment_type: z.string().describe("Workflow-specific assignment type label."),
@@ -911,7 +1319,7 @@ function createMcpServer() {
 	});
 	server.registerTool("assignment_get", {
 		title: "Get Assignment",
-		description: experimentalWorkflowDescription("Fetch one workflow assignment by id."),
+		description: "Fetch one workflow assignment by id.",
 		inputSchema: z.object({ id: z.string().describe("Assignment id.") }),
 		annotations: { readOnlyHint: true }
 	}, async (args, extra) => {
@@ -926,7 +1334,7 @@ function createMcpServer() {
 	});
 	server.registerTool("assignment_list", {
 		title: "List Assignments",
-		description: experimentalWorkflowDescription("List workflow assignments visible to the current actor. Non-editor actors are automatically limited to assignments they assigned or were assigned."),
+		description: "List workflow assignments visible to the current actor. Non-editor actors are automatically limited to assignments they assigned or were assigned.",
 		inputSchema: z.object({
 			scope: z.string().optional().describe("Optional exact scope filter."),
 			statuses: z.array(z.enum(ASSIGNMENT_STATUSES)).optional().describe("Optional assignment status filters."),
@@ -960,7 +1368,7 @@ function createMcpServer() {
 	});
 	server.registerTool("assignment_accept", {
 		title: "Accept Assignment",
-		description: experimentalWorkflowDescription("Accept a pending workflow assignment."),
+		description: "Accept a pending workflow assignment.",
 		inputSchema: z.object({ id: z.string().describe("Assignment id.") })
 	}, async (args, extra) => {
 		requireWorkflowWrite(extra);
@@ -992,7 +1400,7 @@ function createMcpServer() {
 	});
 	server.registerTool("assignment_start", {
 		title: "Start Assignment",
-		description: experimentalWorkflowDescription("Move an assignment into in_progress. When the assignment is currently blocked, this acts as the validated resume transition."),
+		description: "Move an assignment into in_progress. When the assignment is currently blocked, this acts as the validated resume transition.",
 		inputSchema: z.object({ id: z.string().describe("Assignment id.") })
 	}, async (args, extra) => {
 		requireWorkflowWrite(extra);
@@ -1024,7 +1432,7 @@ function createMcpServer() {
 	});
 	server.registerTool("assignment_complete", {
 		title: "Complete Assignment",
-		description: experimentalWorkflowDescription("Mark a workflow assignment complete."),
+		description: "Mark a workflow assignment complete.",
 		inputSchema: z.object({
 			id: z.string().describe("Assignment id."),
 			completion_note: z.string().optional().describe("Optional completion note.")
@@ -1061,7 +1469,7 @@ function createMcpServer() {
 	});
 	server.registerTool("assignment_decline", {
 		title: "Decline Assignment",
-		description: experimentalWorkflowDescription("Decline a workflow assignment."),
+		description: "Decline a workflow assignment.",
 		inputSchema: z.object({
 			id: z.string().describe("Assignment id."),
 			reason: z.string().optional().describe("Optional decline reason.")
@@ -1098,7 +1506,7 @@ function createMcpServer() {
 	});
 	server.registerTool("assignment_block", {
 		title: "Block Assignment",
-		description: experimentalWorkflowDescription("Mark a workflow assignment blocked and record why."),
+		description: "Mark a workflow assignment blocked and record why.",
 		inputSchema: z.object({
 			id: z.string().describe("Assignment id."),
 			reason: z.string().optional().describe("Optional blocking reason.")
@@ -1135,7 +1543,7 @@ function createMcpServer() {
 	});
 	server.registerTool("assignment_cancel", {
 		title: "Cancel Assignment",
-		description: experimentalWorkflowDescription("Cancel a workflow assignment that should no longer continue."),
+		description: "Cancel a workflow assignment that should no longer continue.",
 		inputSchema: z.object({
 			id: z.string().describe("Assignment id."),
 			reason: z.string().optional().describe("Optional cancellation reason.")
@@ -1378,7 +1786,7 @@ function createMcpServer() {
 	});
 	server.registerTool("agent_handoff_capture", {
 		title: "Capture Agent Handoff",
-		description: experimentalWorkflowDescription("Capture the current agent objective, reasoning, findings, touched objects, and pending actions before pausing or handing work off."),
+		description: "Capture the current agent objective, reasoning, findings, touched objects, and pending actions before pausing or handing work off.",
 		inputSchema: z.object({
 			scope: z.string().describe("Scope string: site, collection:{slug}, content:{collection}:{id}, or plugin:{id}."),
 			objective: z.string().min(1).describe("Current objective or outcome the agent was pursuing."),
@@ -1483,7 +1891,7 @@ function createMcpServer() {
 	});
 	server.registerTool("agent_handoff_resume", {
 		title: "Resume Agent Handoff",
-		description: experimentalWorkflowDescription("Resume from a stored handoff snapshot and return a deterministic diff of activity, context, and review changes since capture time."),
+		description: "Resume from a stored handoff snapshot and return a deterministic diff of activity, context, and review changes since capture time.",
 		inputSchema: z.object({
 			snapshot_id: z.string().describe("Handoff snapshot id returned by agent_handoff_capture."),
 			activity_limit: z.number().int().min(1).max(100).optional().describe("Maximum activity rows to include in the diff. Defaults to 25."),
@@ -1536,21 +1944,30 @@ function createMcpServer() {
 			cursor: z.string().optional().describe("Pagination cursor from a previous response"),
 			orderBy: z.string().optional().describe("Field to sort by (e.g. 'created_at', 'updated_at')"),
 			order: z.enum(["asc", "desc"]).optional().describe("Sort direction (default 'desc')"),
-			locale: z.string().optional().describe("Filter by locale (e.g. 'en', 'fr'). Only relevant when i18n is enabled.")
+			locale: z.string().optional().describe("Filter by locale (e.g. 'en', 'fr'). Only relevant when i18n is enabled."),
+			markdown: z.boolean().optional().describe("Return rich text (portableText) fields as Markdown strings instead of Portable Text arrays (default false).")
 		}),
 		annotations: { readOnlyHint: true }
 	}, async (args, extra) => {
 		requireScope(extra, "content:read");
 		const ec = getDineway(extra);
 		const status = canReadDrafts(extra) ? args.status : "published";
-		return unwrap(await ec.handleContentList(args.collection, {
+		const result = await ec.handleContentList(args.collection, {
 			status,
 			limit: args.limit,
 			cursor: args.cursor,
 			orderBy: args.orderBy,
 			order: args.order,
 			locale: args.locale
-		}));
+		});
+		if (result.success && args.markdown) {
+			const data = result.data;
+			if (data && typeof data === "object" && "items" in data && Array.isArray(data.items)) {
+				const items = data.items.filter((item) => typeof item === "object" && item !== null);
+				await applyReadMarkdown(ec, args.collection, items);
+			}
+		}
+		return unwrap(result);
 	});
 	server.registerTool("content_get", {
 		title: "Get Content",
@@ -1558,28 +1975,32 @@ function createMcpServer() {
 		inputSchema: z.object({
 			collection: z.string().describe("Collection slug (e.g. 'posts', 'pages')"),
 			id: z.string().describe("Content item ID (ULID) or slug"),
-			locale: z.string().optional().describe("Locale to scope slug lookup (e.g. 'fr'). Only affects slug resolution; IDs are globally unique.")
+			locale: z.string().optional().describe("Locale to scope slug lookup (e.g. 'fr'). Only affects slug resolution; IDs are globally unique."),
+			markdown: z.boolean().optional().describe("Return rich text (portableText) fields as Markdown strings instead of Portable Text arrays (default false).")
 		}),
 		annotations: { readOnlyHint: true }
 	}, async (args, extra) => {
 		requireScope(extra, "content:read");
-		const result = await getDineway(extra).handleContentGet(args.collection, args.id, args.locale);
+		const ec = getDineway(extra);
+		const result = await ec.handleContentGet(args.collection, args.id, args.locale);
 		if (result.success && !canReadDrafts(extra)) {
 			const data = result.data && typeof result.data === "object" ? result.data : {};
 			if (!isPublishedRecord("item" in data ? data.item : data)) return errorResult("Content not found");
 		}
+		if (result.success && args.markdown && result.data?.item) await applyReadMarkdown(ec, args.collection, [result.data.item]);
 		return unwrap(result);
 	});
 	server.registerTool("content_create", {
 		title: "Create Content",
-		description: "Create a new content item in a collection. The 'data' object should contain field values matching the collection's schema (use schema_get_collection to check). Rich text fields accept Portable Text JSON arrays. A slug is auto-generated if not provided. Items are created as 'draft' by default — use content_publish to make them live.",
+		description: "Create a new content item in a collection. The 'data' object should contain field values matching the collection's schema (use schema_get_collection to check). For rich text (portableText) fields, pass a Markdown string — converted to Portable Text automatically; prefer this. Pass a Portable Text JSON array only for complex content Markdown can't express. A slug is auto-generated if not provided. Items are created as 'draft' by default — use content_publish to make them live.",
 		inputSchema: z.object({
 			collection: z.string().describe("Collection slug (e.g. 'posts', 'pages')"),
 			data: z.record(z.string(), z.unknown()).describe("Field values as key-value pairs matching the collection schema"),
 			slug: z.string().optional().describe("URL slug (auto-generated from title if omitted)"),
-			status: z.enum(["draft", "published"]).optional().describe("Initial status (default 'draft'). Requires publish permission."),
+			status: z.literal("draft").optional().describe("Initial status. Content creation is draft-only."),
 			locale: z.string().optional().describe("Locale for this content (e.g. 'fr'). Defaults to default locale."),
-			translationOf: z.string().optional().describe("ID of the content item this is a translation of. Links items in the same translation group.")
+			translationOf: z.string().optional().describe("ID of the content item this is a translation of. Links items in the same translation group."),
+			bylines: z.array(contentBylineInputSchema).optional().describe("Bylines to credit. Each entry references an existing byline by id, with an optional roleLabel. The first entry becomes the primary byline.")
 		}),
 		annotations: { destructiveHint: false }
 	}, async (args, extra) => {
@@ -1593,40 +2014,14 @@ function createMcpServer() {
 			if (!source.success) return unwrap(source);
 			requireOwnership(extra, extractContentAuthorId(source.data), "content:edit_own", "content:edit_any");
 		}
-		if (args.status === "published") {
-			if (!hasPermission({
-				id: userId,
-				role: getExtra(extra).userRole
-			}, "content:publish_own")) throw new McpError(ErrorCode.InvalidRequest, "Insufficient permissions: publishing requires content:publish_own");
-			if (contentPublishReviewRequired(extra)) throw new McpError(ErrorCode.InvalidRequest, "Token-authenticated content creation with immediate publish is review-gated. Create a draft first, submit review_request_submit, resolve it as approved, then call content_publish with review_request_id.");
-			const result = await dineway.handleContentCreate(args.collection, {
-				data: args.data,
-				slug: args.slug,
-				authorId: userId,
-				locale: args.locale,
-				translationOf: args.translationOf
-			});
-			if (!result.success) return unwrap(result);
-			const itemId = extractContentId(result.data);
-			if (itemId) {
-				await logMcpContentActivity(dineway, locals, args.collection, itemId, "created", "content_create", {
-					changedFields: activityChangedKeys(args.data),
-					slugProvided: args.slug !== void 0,
-					locale: args.locale ?? null,
-					translationOf: args.translationOf ?? null
-				});
-				const publishResult = await dineway.handleContentPublish(args.collection, itemId);
-				if (publishResult.success) await logMcpContentActivity(dineway, locals, args.collection, itemId, "published", "content_create");
-				return unwrap(publishResult);
-			}
-			return unwrap(result);
-		}
+		const data = await convertWriteData(dineway, args.collection, args.data);
 		const result = await dineway.handleContentCreate(args.collection, {
-			data: args.data,
+			data,
 			slug: args.slug,
 			authorId: userId,
 			locale: args.locale,
-			translationOf: args.translationOf
+			translationOf: args.translationOf,
+			bylines: args.bylines
 		});
 		if (result.success) {
 			const itemId = extractContentId(result.data);
@@ -1641,22 +2036,21 @@ function createMcpServer() {
 	});
 	server.registerTool("content_update", {
 		title: "Update Content",
-		description: "Update an existing content item. Only include fields you want to change in the 'data' object — unspecified fields are left unchanged. Pass the _rev token from content_get to enable optimistic concurrency checking (the update fails if the item was modified since you read it). `seo` and `bylines` are persisted alongside field updates. `publishedAt` requires content:publish_any permission and is useful for content imports.",
+		description: "Update an existing content item. Only include fields you want to change in the 'data' object — unspecified fields are left unchanged. Rich text (portableText) fields accept a Markdown string (recommended, converted automatically); use a Portable Text JSON array only for complex content Markdown can't express. Pass the _rev token from content_get to enable optimistic concurrency checking (the update fails if the item was modified since you read it). `seo` and `bylines` are persisted alongside field updates. `publishedAt` requires content:publish_any permission and is useful for content imports.",
 		inputSchema: z.object({
 			collection: z.string().describe("Collection slug"),
 			id: z.string().describe("Content item ID or slug"),
 			locale: z.string().optional().describe("Locale to scope slug lookup. Only affects slug resolution; IDs are globally unique."),
 			data: z.record(z.string(), z.unknown()).optional().describe("Field values to update (only include changed fields)"),
 			slug: z.string().optional().describe("New URL slug"),
-			status: z.enum(["draft", "published"]).optional().describe("New status. Setting to 'published' requires publish permission. Setting to 'draft' unpublishes the item and also requires publish permission."),
+			status: z.literal("draft").optional().describe("Set to 'draft' to unpublish the item. Publishing uses content_publish."),
 			seo: contentSeoInput.optional().describe("Per-content SEO metadata. Only valid for collections with SEO enabled."),
 			bylines: z.array(contentBylineInputSchema).optional().describe("Replace the byline list for this item. The first entry becomes the primary byline."),
 			publishedAt: z.iso.datetime({
 				offset: true,
 				message: "must be an ISO 8601 datetime"
 			}).nullish().describe("Override the publication timestamp. Requires content:publish_any permission. Pass null to clear."),
-			_rev: z.string().optional().describe("Revision token from content_get for conflict detection"),
-			review_request_id: z.string().optional().describe("Approved review request id required for token-authenticated content.publish actions.")
+			_rev: z.string().optional().describe("Revision token from content_get for conflict detection")
 		})
 	}, async (args, extra) => {
 		requireScope(extra, "content:write");
@@ -1676,39 +2070,12 @@ function createMcpServer() {
 			}, "content:publish_any")) return errorResult("[INSUFFICIENT_PERMISSIONS] Setting publishedAt requires content:publish_any permission");
 		}
 		const hasInlineUpdates = args.data || args.slug || args.seo !== void 0 || args.bylines !== void 0 || args.publishedAt !== void 0;
-		if (args.status === "published") {
-			requireOwnership(extra, ownerId, "content:publish_own", "content:publish_any");
-			if (contentPublishReviewRequired(extra) && hasInlineUpdates) throw new McpError(ErrorCode.InvalidRequest, "Token-authenticated publish with inline content changes is review-gated. Save the draft first, submit review_request_submit, resolve it as approved, then publish with review_request_id.");
-			if (hasInlineUpdates) {
-				const updateResult = await dineway.handleContentUpdate(args.collection, resolvedId, {
-					data: args.data,
-					slug: args.slug,
-					authorId: userId,
-					locale: args.locale,
-					seo: args.seo,
-					bylines: args.bylines,
-					publishedAt: args.publishedAt,
-					_rev: args._rev
-				});
-				if (!updateResult.success) return unwrap(updateResult);
-				await logMcpContentActivity(dineway, locals, args.collection, resolvedId, "updated", "content_update", {
-					changedFields: activityChangedKeys(args.data),
-					slugChanged: args.slug !== void 0,
-					seoChanged: args.seo !== void 0,
-					bylinesChanged: args.bylines !== void 0,
-					publishedAtChanged: args.publishedAt !== void 0
-				});
-			}
-			await requireApprovedContentPublishReview(extra, args.collection, resolvedId, args.review_request_id);
-			const publishResult = await dineway.handleContentPublish(args.collection, resolvedId);
-			if (publishResult.success) await logMcpContentActivity(dineway, locals, args.collection, resolvedId, "published", "content_update", { reviewRequestId: args.review_request_id ?? null });
-			return unwrap(publishResult);
-		}
+		const data = args.data ? await convertWriteData(dineway, args.collection, args.data) : args.data;
 		if (args.status === "draft") {
 			requireOwnership(extra, ownerId, "content:publish_own", "content:publish_any");
 			if (hasInlineUpdates) {
 				const updateResult = await dineway.handleContentUpdate(args.collection, resolvedId, {
-					data: args.data,
+					data,
 					slug: args.slug,
 					authorId: userId,
 					locale: args.locale,
@@ -1731,7 +2098,7 @@ function createMcpServer() {
 			return unwrap(unpublishResult);
 		}
 		const result = await dineway.handleContentUpdate(args.collection, resolvedId, {
-			data: args.data,
+			data,
 			slug: args.slug,
 			authorId: userId,
 			locale: args.locale,
@@ -1812,6 +2179,43 @@ function createMcpServer() {
 		if (result.success) await logMcpContentActivity(ec, locals, args.collection, resolvedId, "permanently_deleted", "content_permanent_delete");
 		return unwrap(result);
 	});
+	server.registerTool("content_release_request", {
+		title: "Request Content Release Authorization",
+		description: "Create or reuse an exact HITL request for publishing or scheduling an approved Draft. The server derives the action hash from current content, review, time, Site Settings, and policies.",
+		inputSchema: z.object({
+			collection: z.string().describe("Collection slug"),
+			id: z.string().describe("Content item ID or slug"),
+			operation: z.enum(["publish", "schedule"]).describe("Release operation"),
+			review_request_id: z.string().describe("Approved editorial Review Request bound to the exact Draft"),
+			publishedAt: z.iso.datetime({
+				offset: true,
+				message: "must be an ISO 8601 datetime"
+			}).optional().describe("Optional publication timestamp for a publish release"),
+			scheduledAt: z.iso.datetime({
+				offset: true,
+				message: "must be an ISO 8601 datetime"
+			}).optional().describe("Required exact publication time for a schedule release")
+		}).strict()
+	}, async (args, extra) => {
+		requireScope(extra, "content:write");
+		requireRole(extra, Role.AUTHOR);
+		const payload = getExtra(extra);
+		const existing = await payload.dineway.handleContentGet(args.collection, args.id);
+		if (!existing.success) return unwrap(existing);
+		requireOwnership(extra, extractContentAuthorId(existing.data), "content:publish_own", "content:publish_any");
+		try {
+			return jsonResult(await ensureContentReleaseRequest(payload, {
+				collection: args.collection,
+				id: extractContentId(existing.data) ?? args.id,
+				operation: args.operation,
+				editorialReviewRequestId: args.review_request_id,
+				publishedAt: args.publishedAt,
+				scheduledAt: args.scheduledAt
+			}));
+		} catch (error) {
+			return contentPublicationError(error);
+		}
+	});
 	server.registerTool("content_publish", {
 		title: "Publish Content",
 		description: "Publish a content item, making it live on the site. Creates a published revision from the current draft. Further edits create a new draft without affecting the live version until re-published. Pass `publishedAt` to backdate imported or historical content; this requires content:publish_any.",
@@ -1822,7 +2226,8 @@ function createMcpServer() {
 				offset: true,
 				message: "must be an ISO 8601 datetime"
 			}).optional().describe("Override publication timestamp. Requires content:publish_any permission."),
-			review_request_id: z.string().optional().describe("Approved review request id required for token-authenticated publish actions.")
+			review_request_id: z.string().describe("Approved editorial Review Request bound to the exact Draft."),
+			release_authorization_id: z.string().optional().describe("Approved exact release HITL request required for token actors.")
 		})
 	}, async (args, extra) => {
 		requireScope(extra, "content:write");
@@ -1840,13 +2245,20 @@ function createMcpServer() {
 				role: userRole
 			}, "content:publish_any")) return errorResult("[INSUFFICIENT_PERMISSIONS] Setting publishedAt requires content:publish_any permission");
 		}
-		await requireApprovedContentPublishReview(extra, args.collection, resolvedId, args.review_request_id);
-		const result = await ec.handleContentPublish(args.collection, resolvedId, { publishedAt: args.publishedAt });
-		if (result.success) await logMcpContentActivity(ec, locals, args.collection, resolvedId, "published", "content_publish", {
-			reviewRequestId: args.review_request_id ?? null,
-			publishedAt: args.publishedAt ?? null
-		});
-		return unwrap(result);
+		try {
+			return unwrap((await contentPublicationService(payload).publishAuthorizedContent({
+				actor: resolveActorIdentity(locals),
+				collection: args.collection,
+				id: resolvedId,
+				editorialReviewRequestId: args.review_request_id,
+				releaseHitlRequestId: args.release_authorization_id,
+				publishedAt: args.publishedAt,
+				sourceType: "mcp_tool",
+				sourceName: "content_publish"
+			})).result);
+		} catch (error) {
+			return contentPublicationError(error);
+		}
 	});
 	server.registerTool("content_unpublish", {
 		title: "Unpublish Content",
@@ -1875,7 +2287,9 @@ function createMcpServer() {
 		inputSchema: z.object({
 			collection: z.string().describe("Collection slug"),
 			id: z.string().describe("Content item ID or slug"),
-			scheduledAt: z.string().describe("ISO 8601 datetime for publication (e.g. '2025-06-01T09:00:00Z')")
+			scheduledAt: z.string().describe("ISO 8601 datetime for publication (e.g. '2025-06-01T09:00:00Z')"),
+			review_request_id: z.string().describe("Approved editorial Review Request bound to the exact Draft."),
+			release_authorization_id: z.string().optional().describe("Approved exact release HITL request required for token actors.")
 		})
 	}, async (args, extra) => {
 		requireScope(extra, "content:write");
@@ -1887,9 +2301,20 @@ function createMcpServer() {
 		if (!existing.success) return unwrap(existing);
 		requireOwnership(extra, extractContentAuthorId(existing.data), "content:publish_own", "content:publish_any");
 		const resolvedId = extractContentId(existing.data) ?? args.id;
-		const result = await ec.handleContentSchedule(args.collection, resolvedId, args.scheduledAt);
-		if (result.success) await logMcpContentActivity(ec, locals, args.collection, resolvedId, "scheduled", "content_schedule", { scheduledAt: args.scheduledAt });
-		return unwrap(result);
+		try {
+			return unwrap((await contentPublicationService(payload).scheduleAuthorizedContent({
+				actor: resolveActorIdentity(locals),
+				collection: args.collection,
+				id: resolvedId,
+				editorialReviewRequestId: args.review_request_id,
+				releaseHitlRequestId: args.release_authorization_id,
+				scheduledAt: args.scheduledAt,
+				sourceType: "mcp_tool",
+				sourceName: "content_schedule"
+			})).result);
+		} catch (error) {
+			return contentPublicationError(error);
+		}
 	});
 	server.registerTool("content_unschedule", {
 		title: "Cancel Scheduled Publication",
@@ -1908,9 +2333,17 @@ function createMcpServer() {
 		if (!existing.success) return unwrap(existing);
 		requireOwnership(extra, extractContentAuthorId(existing.data), "content:publish_own", "content:publish_any");
 		const resolvedId = extractContentId(existing.data) ?? args.id;
-		const result = await ec.handleContentUnschedule(args.collection, resolvedId);
-		if (result.success) await logMcpContentActivity(ec, locals, args.collection, resolvedId, "unscheduled", "content_unschedule");
-		return unwrap(result);
+		try {
+			return unwrap((await contentPublicationService(payload).unscheduleAuthorizedContent({
+				actor: resolveActorIdentity(locals),
+				collection: args.collection,
+				id: resolvedId,
+				sourceType: "mcp_tool",
+				sourceName: "content_unschedule"
+			})).result);
+		} catch (error) {
+			return contentPublicationError(error);
+		}
 	});
 	server.registerTool("content_compare", {
 		title: "Compare Live vs Draft",
@@ -2018,7 +2451,7 @@ function createMcpServer() {
 		requireRole(extra, Role.EDITOR);
 		const ec = getDineway(extra);
 		try {
-			const { SchemaRegistry } = await import("../../../schema-Bsi-VpYv.mjs").then((n) => n.t);
+			const { SchemaRegistry } = await import("../../../schema-DUtnZxjZ.mjs").then((n) => n.t);
 			return jsonResult({ items: await new SchemaRegistry(ec.db).listCollections() });
 		} catch (error) {
 			return errorResult(error);
@@ -2034,7 +2467,7 @@ function createMcpServer() {
 		requireRole(extra, Role.EDITOR);
 		const ec = getDineway(extra);
 		try {
-			const { SchemaRegistry } = await import("../../../schema-Bsi-VpYv.mjs").then((n) => n.t);
+			const { SchemaRegistry } = await import("../../../schema-DUtnZxjZ.mjs").then((n) => n.t);
 			const collection = await new SchemaRegistry(ec.db).getCollectionWithFields(args.slug);
 			if (!collection) return errorResult(`Collection '${args.slug}' not found`);
 			return jsonResult(collection);
@@ -2064,7 +2497,7 @@ function createMcpServer() {
 		requireRole(extra, Role.ADMIN);
 		const ec = getDineway(extra);
 		try {
-			const { SchemaRegistry } = await import("../../../schema-Bsi-VpYv.mjs").then((n) => n.t);
+			const { SchemaRegistry } = await import("../../../schema-DUtnZxjZ.mjs").then((n) => n.t);
 			const collection = await new SchemaRegistry(ec.db).createCollection({
 				slug: args.slug,
 				label: args.label,
@@ -2128,7 +2561,7 @@ function createMcpServer() {
 					request
 				});
 			}
-			const { SchemaRegistry } = await import("../../../schema-Bsi-VpYv.mjs").then((n) => n.t);
+			const { SchemaRegistry } = await import("../../../schema-DUtnZxjZ.mjs").then((n) => n.t);
 			await new SchemaRegistry(ec.db).deleteCollection(args.slug, { force: args.force });
 			ec.invalidateManifest();
 			await logSchemaActivity(ec.db, locals, {
@@ -2192,7 +2625,7 @@ function createMcpServer() {
 		requireRole(extra, Role.ADMIN);
 		const ec = getDineway(extra);
 		try {
-			const { SchemaRegistry } = await import("../../../schema-Bsi-VpYv.mjs").then((n) => n.t);
+			const { SchemaRegistry } = await import("../../../schema-DUtnZxjZ.mjs").then((n) => n.t);
 			const field = await new SchemaRegistry(ec.db).createField(args.collection, {
 				slug: args.slug,
 				label: args.label,
@@ -2261,7 +2694,7 @@ function createMcpServer() {
 					request
 				});
 			}
-			const { SchemaRegistry } = await import("../../../schema-Bsi-VpYv.mjs").then((n) => n.t);
+			const { SchemaRegistry } = await import("../../../schema-DUtnZxjZ.mjs").then((n) => n.t);
 			await new SchemaRegistry(ec.db).deleteField(args.collection, args.fieldSlug);
 			ec.invalidateManifest();
 			await logSchemaActivity(ec.db, locals, {
@@ -2394,7 +2827,7 @@ function createMcpServer() {
 		requireScope(extra, "content:read");
 		const ec = getDineway(extra);
 		try {
-			const { searchWithDb } = await import("../../../search-Gdrqj582.mjs").then((n) => n.t);
+			const { searchWithDb } = await import("../../../search-DUKgZUlm.mjs").then((n) => n.t);
 			return jsonResult(await searchWithDb(ec.db, args.query, {
 				collections: args.collections,
 				locale: args.locale,
@@ -2404,6 +2837,124 @@ function createMcpServer() {
 			return errorResult(error);
 		}
 	});
+	server.registerTool("byline_list", {
+		title: "List Bylines",
+		description: "List bylines (author/contributor credits) with optional filtering and pagination. Bylines are standalone records referenced by content items; use the returned id with content_create/content_update or byline_get. Use the nextCursor value from the response to fetch the next page.",
+		inputSchema: z.object({
+			search: z.string().optional().describe("Filter by display name or slug substring"),
+			isGuest: z.boolean().optional().describe("Filter by guest byline state"),
+			userId: z.string().optional().describe("Filter to the byline linked to a Dineway user ID"),
+			locale: z.string().optional().describe("Filter by locale (omit for all)"),
+			limit: z.number().int().min(1).max(100).optional().describe("Max items (default 50)"),
+			cursor: z.string().min(1).max(2048).optional().describe("Pagination cursor")
+		}),
+		annotations: { readOnlyHint: true }
+	}, async (args, extra) => {
+		requireScope(extra, "content:read");
+		const ec = getDineway(extra);
+		try {
+			const { BylineRepository } = await import("../../../byline-7xR185Ly.mjs").then((n) => n.n);
+			return jsonResult(await new BylineRepository(ec.db).findMany({
+				search: args.search,
+				isGuest: args.isGuest,
+				userId: args.userId,
+				locale: args.locale,
+				limit: args.limit,
+				cursor: args.cursor
+			}));
+		} catch (error) {
+			return errorResult(error);
+		}
+	});
+	server.registerTool("byline_get", {
+		title: "Get Byline",
+		description: "Get a single byline by its ID, including bio, avatar, website, linked user, and any custom fields.",
+		inputSchema: z.object({ id: z.string().describe("Byline ID") }),
+		annotations: { readOnlyHint: true }
+	}, async (args, extra) => {
+		requireScope(extra, "content:read");
+		const ec = getDineway(extra);
+		try {
+			const { BylineRepository } = await import("../../../byline-7xR185Ly.mjs").then((n) => n.n);
+			const byline = await new BylineRepository(ec.db).findById(args.id);
+			if (!byline) return errorResult(`Byline '${args.id}' not found`);
+			return jsonResult(byline);
+		} catch (error) {
+			return errorResult(error);
+		}
+	});
+	server.registerTool("byline_create", {
+		title: "Create Byline",
+		description: "Create a new byline (author/contributor credit). The slug must be unique and contain only lowercase letters, digits, and hyphens. Link the byline to a Dineway user via userId, or leave it as a standalone guest credit. The returned id can then be passed to content_create/content_update bylines.",
+		inputSchema: z.object({ ...bylineCreateBody.shape }),
+		annotations: { destructiveHint: false }
+	}, async (args, extra) => {
+		requireScope(extra, "content:write");
+		requireRole(extra, Role.EDITOR);
+		const ec = getDineway(extra);
+		try {
+			const { handleBylineCreate } = await import("../../../bylines-C-EL6dh3.mjs").then((n) => n.t);
+			const result = await handleBylineCreate(ec.db, args);
+			if (result.success) await invalidateBylines();
+			return unwrap(result);
+		} catch (error) {
+			return errorResult(error);
+		}
+	});
+	server.registerTool("byline_update", {
+		title: "Update Byline",
+		description: "Update an existing byline. Any field can be omitted to leave it unchanged. Renaming the slug must not collide with another byline.",
+		inputSchema: z.object({
+			id: z.string().describe("Byline ID to update"),
+			...bylineUpdateBody.shape
+		})
+	}, async (args, extra) => {
+		requireScope(extra, "content:write");
+		requireRole(extra, Role.EDITOR);
+		const ec = getDineway(extra);
+		try {
+			const { handleBylineUpdate } = await import("../../../bylines-C-EL6dh3.mjs").then((n) => n.t);
+			const { id, ...input } = args;
+			const result = await handleBylineUpdate(ec.db, id, input);
+			if (result.success) await invalidateBylines();
+			return unwrap(result);
+		} catch (error) {
+			return errorResult(error);
+		}
+	});
+	server.registerTool("byline_delete", {
+		title: "Delete Byline",
+		description: "Permanently delete a byline. Any content crediting this byline loses the association, and it is cleared as a primary byline where set.",
+		inputSchema: z.object({ id: z.string().describe("Byline ID to delete") }),
+		annotations: { destructiveHint: true }
+	}, async (args, extra) => {
+		requireScope(extra, "content:write");
+		requireRole(extra, Role.EDITOR);
+		const ec = getDineway(extra);
+		try {
+			const { BylineRepository } = await import("../../../byline-7xR185Ly.mjs").then((n) => n.n);
+			if (!await new BylineRepository(ec.db).delete(args.id)) return errorResult(`Byline '${args.id}' not found`);
+			await invalidateBylines();
+			return jsonResult({ deleted: args.id });
+		} catch (error) {
+			return errorResult(error);
+		}
+	});
+	server.registerTool("byline_translations", {
+		title: "List Byline Translations",
+		description: "Return every locale variant of a byline, identified via its shared translation group.",
+		inputSchema: z.object({ id: z.string().describe("Byline ID") }),
+		annotations: { readOnlyHint: true }
+	}, async (args, extra) => {
+		requireScope(extra, "content:read");
+		const ec = getDineway(extra);
+		try {
+			const { handleBylineTranslations } = await import("../../../bylines-C-EL6dh3.mjs").then((n) => n.t);
+			return unwrap(await handleBylineTranslations(ec.db, args.id));
+		} catch (error) {
+			return errorResult(error);
+		}
+	});
 	server.registerTool("taxonomy_list", {
 		title: "List Taxonomies",
 		description: "List all taxonomy definitions (e.g. categories, tags). Taxonomies are classification systems applied to content. Each has a name, label, and can be hierarchical (categories) or flat (tags). Optionally filter by locale.",
@@ -2413,7 +2964,7 @@ function createMcpServer() {
 		requireScope(extra, "content:read");
 		const ec = getDineway(extra);
 		try {
-			const { handleTaxonomyList } = await import("../../../taxonomies-D9Sw4wWM.mjs").then((n) => n.l);
+			const { handleTaxonomyList } = await import("../../../taxonomies-BiM9NtgW.mjs").then((n) => n.l);
 			return unwrap(await handleTaxonomyList(ec.db, { locale: args.locale }));
 		} catch (error) {
 			return errorResult(error);
@@ -2433,12 +2984,12 @@ function createMcpServer() {
 		requireScope(extra, "content:read");
 		const ec = getDineway(extra);
 		try {
-			const { handleTaxonomyList } = await import("../../../taxonomies-D9Sw4wWM.mjs").then((n) => n.l);
+			const { handleTaxonomyList } = await import("../../../taxonomies-BiM9NtgW.mjs").then((n) => n.l);
 			const listResult = await handleTaxonomyList(ec.db, { locale: args.locale });
 			if (!listResult.success) return unwrap(listResult);
 			if (!listResult.data.taxonomies.find((t) => t.name === args.taxonomy)) return errorResult(`Taxonomy '${args.taxonomy}' not found`);
-			const { TaxonomyRepository } = await import("../../../taxonomy-B169Nm6B.mjs").then((n) => n.n);
-			const { decodeCursor, encodeCursor } = await import("../../../types-CSgR9nQB.mjs").then((n) => n.a);
+			const { TaxonomyRepository } = await import("../../../taxonomy-0k_vRVsD.mjs").then((n) => n.n);
+			const { decodeCursor, encodeCursor } = await import("../../../types-ChxYDRvx.mjs").then((n) => n.a);
 			const repo = new TaxonomyRepository(ec.db);
 			const limit = Math.min(args.limit ?? 50, 100);
 			const terms = await repo.findByName(args.taxonomy, { locale: args.locale });
@@ -2487,7 +3038,7 @@ function createMcpServer() {
 		requireRole(extra, Role.EDITOR);
 		const ec = getDineway(extra);
 		try {
-			const { handleTermCreate } = await import("../../../taxonomies-D9Sw4wWM.mjs").then((n) => n.l);
+			const { handleTermCreate } = await import("../../../taxonomies-BiM9NtgW.mjs").then((n) => n.l);
 			return unwrap(await handleTermCreate(ec.db, args.taxonomy, {
 				slug: args.slug,
 				label: args.label,
@@ -2517,7 +3068,7 @@ function createMcpServer() {
 		requireRole(extra, Role.EDITOR);
 		const ec = getDineway(extra);
 		try {
-			const { handleTermUpdate } = await import("../../../taxonomies-D9Sw4wWM.mjs").then((n) => n.l);
+			const { handleTermUpdate } = await import("../../../taxonomies-BiM9NtgW.mjs").then((n) => n.l);
 			return unwrap(await handleTermUpdate(ec.db, args.taxonomy, args.termSlug, {
 				slug: args.slug,
 				label: args.label,
@@ -2542,7 +3093,7 @@ function createMcpServer() {
 		requireRole(extra, Role.EDITOR);
 		const ec = getDineway(extra);
 		try {
-			const { handleTermDelete } = await import("../../../taxonomies-D9Sw4wWM.mjs").then((n) => n.l);
+			const { handleTermDelete } = await import("../../../taxonomies-BiM9NtgW.mjs").then((n) => n.l);
 			return unwrap(await handleTermDelete(ec.db, args.taxonomy, args.termSlug, { locale: args.locale }));
 		} catch (error) {
 			return errorResult(error);
@@ -2557,7 +3108,7 @@ function createMcpServer() {
 		requireScope(extra, "content:read");
 		const ec = getDineway(extra);
 		try {
-			const { handleTermTranslations } = await import("../../../taxonomies-D9Sw4wWM.mjs").then((n) => n.l);
+			const { handleTermTranslations } = await import("../../../taxonomies-BiM9NtgW.mjs").then((n) => n.l);
 			return unwrap(await handleTermTranslations(ec.db, args.id));
 		} catch (error) {
 			return errorResult(error);
@@ -2572,7 +3123,7 @@ function createMcpServer() {
 		requireScope(extra, "content:read");
 		const ec = getDineway(extra);
 		try {
-			const { handleMenuList } = await import("../../../menus-BZbXf-ej.mjs").then((n) => n.d);
+			const { handleMenuList } = await import("../../../menus-CmyIkRG5.mjs").then((n) => n.d);
 			return unwrap(await handleMenuList(ec.db, { locale: args.locale }));
 		} catch (error) {
 			return errorResult(error);
@@ -2590,7 +3141,7 @@ function createMcpServer() {
 		requireScope(extra, "content:read");
 		const ec = getDineway(extra);
 		try {
-			const { handleMenuGet } = await import("../../../menus-BZbXf-ej.mjs").then((n) => n.d);
+			const { handleMenuGet } = await import("../../../menus-CmyIkRG5.mjs").then((n) => n.d);
 			return unwrap(await handleMenuGet(ec.db, args.name, { locale: args.locale }));
 		} catch (error) {
 			return errorResult(error);
@@ -2605,7 +3156,7 @@ function createMcpServer() {
 		requireScope(extra, "content:read");
 		const ec = getDineway(extra);
 		try {
-			const { handleMenuTranslations } = await import("../../../menus-BZbXf-ej.mjs").then((n) => n.d);
+			const { handleMenuTranslations } = await import("../../../menus-CmyIkRG5.mjs").then((n) => n.d);
 			return unwrap(await handleMenuTranslations(ec.db, args.id));
 		} catch (error) {
 			return errorResult(error);
@@ -2625,7 +3176,7 @@ function createMcpServer() {
 		requireRole(extra, Role.EDITOR);
 		const ec = getDineway(extra);
 		try {
-			const { handleMenuCreate } = await import("../../../menus-BZbXf-ej.mjs").then((n) => n.d);
+			const { handleMenuCreate } = await import("../../../menus-CmyIkRG5.mjs").then((n) => n.d);
 			return unwrap(await handleMenuCreate(ec.db, {
 				name: args.name,
 				label: args.label,
@@ -2649,7 +3200,7 @@ function createMcpServer() {
 		requireRole(extra, Role.EDITOR);
 		const ec = getDineway(extra);
 		try {
-			const { handleMenuUpdate } = await import("../../../menus-BZbXf-ej.mjs").then((n) => n.d);
+			const { handleMenuUpdate } = await import("../../../menus-CmyIkRG5.mjs").then((n) => n.d);
 			return unwrap(await handleMenuUpdate(ec.db, args.name, {
 				label: args.label,
 				locale: args.locale
@@ -2671,7 +3222,7 @@ function createMcpServer() {
 		requireRole(extra, Role.EDITOR);
 		const ec = getDineway(extra);
 		try {
-			const { handleMenuDelete } = await import("../../../menus-BZbXf-ej.mjs").then((n) => n.d);
+			const { handleMenuDelete } = await import("../../../menus-CmyIkRG5.mjs").then((n) => n.d);
 			return unwrap(await handleMenuDelete(ec.db, args.name, { locale: args.locale }));
 		} catch (error) {
 			return errorResult(error);
@@ -2706,7 +3257,7 @@ function createMcpServer() {
 		requireRole(extra, Role.EDITOR);
 		const ec = getDineway(extra);
 		try {
-			const { handleMenuSetItems } = await import("../../../menus-BZbXf-ej.mjs").then((n) => n.d);
+			const { handleMenuSetItems } = await import("../../../menus-CmyIkRG5.mjs").then((n) => n.d);
 			return unwrap(await handleMenuSetItems(ec.db, args.name, args.items, { locale: args.locale }));
 		} catch (error) {
 			return errorResult(error);
@@ -2753,7 +3304,7 @@ function createMcpServer() {
 		requireRole(extra, Role.ADMIN);
 		const ec = getDineway(extra);
 		try {
-			const { handleSettingsGet } = await import("../../../settings-DlBsT2VS.mjs").then((n) => n.r);
+			const { handleSettingsGet } = await import("../../../settings-EzADu-dd.mjs").then((n) => n.r);
 			return unwrap(await handleSettingsGet(ec.db, ec.storage));
 		} catch (error) {
 			return errorResult(error);
@@ -2790,7 +3341,7 @@ function createMcpServer() {
 					request
 				});
 			}
-			const { handleSettingsUpdate } = await import("../../../settings-DlBsT2VS.mjs").then((n) => n.r);
+			const { handleSettingsUpdate } = await import("../../../settings-EzADu-dd.mjs").then((n) => n.r);
 			const result = await handleSettingsUpdate(ec.db, ec.storage, settingsInput);
 			if (!result.success) return unwrap(result);
 			await logSiteActivitySafely(ec.db, locals, {
@@ -2812,8 +3363,36 @@ function createMcpServer() {
 			return errorResult(error);
 		}
 	});
+	if (options.pluginMcpRegistry) registerPluginMcpRegistry(server, options.pluginMcpRegistry, {
+		resolveContext: resolvePluginMcpExecutionContext,
+		authorizeTarget: options.authorizePluginMcpTarget,
+		authorizeSensitiveOutput: options.authorizePluginMcpSensitiveOutput,
+		executeCommand: options.executePluginMcpCommand
+	});
 	return server;
 }
+function resolvePluginMcpExecutionContext(plugin, requestExtra) {
+	if (!isMcpRequestExtra(requestExtra)) throw new Error("Dineway MCP request context is unavailable");
+	const payload = getExtra(requestExtra);
+	const resolvedActor = resolveActorIdentity(actorLocals(payload));
+	return {
+		plugin,
+		actor: {
+			type: resolvedActor.actorType,
+			id: resolvedActor.actorId,
+			userId: payload.userId || null,
+			role: payload.userRole,
+			authMethod: payload.authToken?.type ?? "session",
+			tokenScopes: payload.tokenScopes
+		},
+		db: payload.dineway.db,
+		storage: payload.dineway.storage,
+		http: typeof payload.dineway.getPluginHttpAccess === "function" ? payload.dineway.getPluginHttpAccess(plugin.id) : void 0
+	};
+}
+function isMcpRequestExtra(value) {
+	return typeof value === "object" && value !== null;
+}
 
 //#endregion
 //#region src/astro/routes/api/mcp.ts
@@ -2834,7 +3413,11 @@ const POST = async ({ request, locals }) => {
 	const { dineway, user } = locals;
 	if (!dineway) return apiError("NOT_CONFIGURED", "Dineway is not initialized", 500);
 	if (!user) return apiError("UNAUTHORIZED", "Authentication required", 401);
-	const server = createMcpServer();
+	const server = createMcpServer({
+		seoProviderService: new SeoProviderEvidenceService(new ForgewaySeoGatewayClient()),
+		pluginMcpRegistry: dineway.getPluginMcpRegistry(),
+		executePluginMcpCommand: createReviewedPluginMcpCommandExecutor()
+	});
 	try {
 		const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
 		await server.connect(transport);