dineway 0.1.4 → 0.1.6

package/src/astro/routes/api/admin/briefing.ts

@@ -0,0 +1,76 @@
+/**
+ * Admin site briefing endpoint
+ *
+ * GET /_dineway/api/admin/briefing - Build a role-scoped Site Context Engine briefing
+ */
+
+import { hasPermission } from "@dineway-ai/auth";
+import type { APIRoute } from "astro";
+
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleSiteBriefingGet } from "#api/handlers/briefing.js";
+import { isParseError, parseQuery } from "#api/parse.js";
+import { siteBriefingQuery } from "#api/schemas.js";
+import type { SiteBriefingPermissions } from "#site-context/index.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ url, locals }) => {
+	const { dineway, user } = locals;
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	if (!user) {
+		return apiError("UNAUTHORIZED", "Authentication required", 401);
+	}
+
+	const permissions = briefingPermissionsForUser(user);
+	if (!canReadAnyBriefingSection(permissions)) {
+		return apiError("FORBIDDEN", "Insufficient permissions", 403);
+	}
+
+	try {
+		const query = parseQuery(url, siteBriefingQuery);
+		if (isParseError(query)) return query;
+
+		const result = await handleSiteBriefingGet(
+			{
+				db: dineway.db,
+				storage: dineway.storage ?? null,
+				configuredPlugins: dineway.configuredPlugins ?? [],
+				marketplaceUrl: dineway.config.marketplace,
+				permissions,
+			},
+			{
+				scope: query.scope,
+				since: query.since,
+				contextTypes: query.contextTypes,
+				includeStale: query.includeStale,
+				tokenBudget: query.tokenBudget,
+				activityLimit: query.activityLimit,
+			},
+		);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to build site briefing", "SITE_BRIEFING_ERROR");
+	}
+};
+
+function briefingPermissionsForUser(user: { role: number }): SiteBriefingPermissions {
+	return {
+		canReadContent: hasPermission(user, "content:read"),
+		canReadSchema: hasPermission(user, "schema:read"),
+		canReadSettings: hasPermission(user, "settings:read"),
+		canReadPlugins: hasPermission(user, "plugins:read"),
+	};
+}
+
+function canReadAnyBriefingSection(permissions: SiteBriefingPermissions): boolean {
+	return (
+		permissions.canReadContent ||
+		permissions.canReadSchema ||
+		permissions.canReadSettings ||
+		permissions.canReadPlugins
+	);
+}

package/src/astro/routes/api/admin/bylines/[id]/index.ts

@@ -5,6 +5,7 @@ import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
 import { isParseError, parseBody } from "#api/parse.js";
 import { bylineUpdateBody } from "#api/schemas.js";
+import { invalidateBylineCache } from "#bylines/index.js";
 import { BylineRepository } from "#db/repositories/byline.js";
 
 export const prerender = false;
@@ -61,6 +62,7 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 		});
 
 		if (!byline) return apiError("NOT_FOUND", "Byline not found", 404);
+		invalidateBylineCache();
 		return apiSuccess(byline);
 	} catch (error) {
 		return handleError(error, "Failed to update byline", "BYLINE_UPDATE_ERROR");
@@ -80,6 +82,7 @@ export const DELETE: APIRoute = async ({ params, locals }) => {
 		const repo = new BylineRepository(dineway.db);
 		const deleted = await repo.delete(params.id!);
 		if (!deleted) return apiError("NOT_FOUND", "Byline not found", 404);
+		invalidateBylineCache();
 		return apiSuccess({ deleted: true });
 	} catch (error) {
 		return handleError(error, "Failed to delete byline", "BYLINE_DELETE_ERROR");

package/src/astro/routes/api/admin/bylines/index.ts

@@ -5,6 +5,7 @@ import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
 import { isParseError, parseBody, parseQuery } from "#api/parse.js";
 import { bylineCreateBody, bylinesListQuery } from "#api/schemas.js";
+import { invalidateBylineCache } from "#bylines/index.js";
 import { BylineRepository } from "#db/repositories/byline.js";
 
 export const prerender = false;
@@ -65,6 +66,7 @@ export const POST: APIRoute = async ({ request, locals }) => {
 			isGuest: body.isGuest,
 		});
 
+		invalidateBylineCache();
 		return apiSuccess(byline, 201);
 	} catch (error) {
 		return handleError(error, "Failed to create byline", "BYLINE_CREATE_ERROR");

package/src/astro/routes/api/admin/context/[id]/history.ts

@@ -0,0 +1,35 @@
+/**
+ * Admin context supersede history
+ *
+ * GET /_dineway/api/admin/context/:id/history - Get a context entry supersede chain
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleContextEntryHistory } from "#api/handlers/context.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ params, locals }) => {
+	const { dineway, user } = locals;
+	const { id } = params;
+
+	if (!id) {
+		return apiError("VALIDATION_ERROR", "Context entry ID required", 400);
+	}
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "settings:read");
+	if (denied) return denied;
+
+	try {
+		const result = await handleContextEntryHistory(dineway.db, id);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to load context history", "CONTEXT_HISTORY_ERROR");
+	}
+};

package/src/astro/routes/api/admin/context/[id]/index.ts

@@ -0,0 +1,35 @@
+/**
+ * Admin context entry detail
+ *
+ * GET /_dineway/api/admin/context/:id - Get a context entry
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleContextEntryGet } from "#api/handlers/context.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ params, locals }) => {
+	const { dineway, user } = locals;
+	const { id } = params;
+
+	if (!id) {
+		return apiError("VALIDATION_ERROR", "Context entry ID required", 400);
+	}
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "settings:read");
+	if (denied) return denied;
+
+	try {
+		const result = await handleContextEntryGet(dineway.db, id);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to get context entry", "CONTEXT_GET_ERROR");
+	}
+};

package/src/astro/routes/api/admin/context/[id]/review.ts

@@ -0,0 +1,57 @@
+/**
+ * Admin context review
+ *
+ * POST /_dineway/api/admin/context/:id/review - Mark a context entry reviewed
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { logContextRouteActivity, resolveContextRouteActor } from "#api/context-route-helpers.js";
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleContextEntryReview } from "#api/handlers/context.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { contextEntryReviewBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { dineway, user } = locals;
+	const { id } = params;
+
+	if (!id) {
+		return apiError("VALIDATION_ERROR", "Context entry ID required", 400);
+	}
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "content:edit_any");
+	if (denied) return denied;
+
+	try {
+		const body = await parseBody(request, contextEntryReviewBody);
+		if (isParseError(body)) return body;
+
+		const result = await handleContextEntryReview(
+			dineway.db,
+			id,
+			body,
+			resolveContextRouteActor(locals),
+		);
+		if (!result.success) return unwrapResult(result);
+
+		await logContextRouteActivity(dineway.db, locals, {
+			actionType: "context.reviewed",
+			entry: result.data.item,
+			summary: `Reviewed context entry ${result.data.item.title}`,
+			detail: {
+				validUntil: result.data.item.validUntil,
+			},
+		});
+
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to review context entry", "CONTEXT_REVIEW_ERROR");
+	}
+};

package/src/astro/routes/api/admin/context/[id]/supersede.ts

@@ -0,0 +1,58 @@
+/**
+ * Admin context supersede
+ *
+ * POST /_dineway/api/admin/context/:id/supersede - Replace a context entry
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { logContextRouteActivity, resolveContextRouteActor } from "#api/context-route-helpers.js";
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleContextEntrySupersede } from "#api/handlers/context.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { contextEntrySupersedeBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { dineway, user } = locals;
+	const { id } = params;
+
+	if (!id) {
+		return apiError("VALIDATION_ERROR", "Context entry ID required", 400);
+	}
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "content:edit_any");
+	if (denied) return denied;
+
+	try {
+		const body = await parseBody(request, contextEntrySupersedeBody);
+		if (isParseError(body)) return body;
+
+		const result = await handleContextEntrySupersede(
+			dineway.db,
+			id,
+			body,
+			resolveContextRouteActor(locals),
+		);
+		if (!result.success) return unwrapResult(result);
+
+		await logContextRouteActivity(dineway.db, locals, {
+			actionType: "context.superseded",
+			entry: result.data.item,
+			summary: `Superseded context entry ${id}`,
+			detail: {
+				supersedesId: id,
+				replacementId: result.data.item.id,
+			},
+		});
+
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to supersede context entry", "CONTEXT_SUPERSEDE_ERROR");
+	}
+};

package/src/astro/routes/api/admin/context/diff.ts

@@ -0,0 +1,35 @@
+/**
+ * Admin context diff
+ *
+ * GET /_dineway/api/admin/context/diff - Diff context entries since a timestamp
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleContextEntryDiff } from "#api/handlers/context.js";
+import { isParseError, parseQuery } from "#api/parse.js";
+import { contextEntryDiffQuery } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ url, locals }) => {
+	const { dineway, user } = locals;
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "settings:read");
+	if (denied) return denied;
+
+	try {
+		const query = parseQuery(url, contextEntryDiffQuery);
+		if (isParseError(query)) return query;
+
+		const result = await handleContextEntryDiff(dineway.db, query);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to diff context entries", "CONTEXT_DIFF_ERROR");
+	}
+};

package/src/astro/routes/api/admin/context/index.ts

@@ -0,0 +1,69 @@
+/**
+ * Admin context entry browser
+ *
+ * GET /_dineway/api/admin/context - List/search context entries
+ * POST /_dineway/api/admin/context - Add a context entry
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { logContextRouteActivity, resolveContextRouteActor } from "#api/context-route-helpers.js";
+import { handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleContextEntryCreate, handleContextEntryList } from "#api/handlers/context.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { contextEntryCreateBody, contextEntryListQuery } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ url, locals }) => {
+	const { dineway, user } = locals;
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "settings:read");
+	if (denied) return denied;
+
+	try {
+		const query = parseQuery(url, contextEntryListQuery);
+		if (isParseError(query)) return query;
+
+		const result = await handleContextEntryList(dineway.db, query);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to list context entries", "CONTEXT_LIST_ERROR");
+	}
+};
+
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { dineway, user } = locals;
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "content:edit_any");
+	if (denied) return denied;
+
+	try {
+		const body = await parseBody(request, contextEntryCreateBody);
+		if (isParseError(body)) return body;
+
+		const result = await handleContextEntryCreate(
+			dineway.db,
+			body,
+			resolveContextRouteActor(locals),
+		);
+		if (!result.success) return unwrapResult(result);
+
+		await logContextRouteActivity(dineway.db, locals, {
+			actionType: "context.added",
+			entry: result.data.item,
+			summary: `Added ${result.data.item.contextType} context: ${result.data.item.title}`,
+		});
+
+		return unwrapResult(result, 201);
+	} catch (error) {
+		return handleError(error, "Failed to create context entry", "CONTEXT_CREATE_ERROR");
+	}
+};

package/src/astro/routes/api/admin/context/stale.ts

@@ -0,0 +1,35 @@
+/**
+ * Admin stale context entries
+ *
+ * GET /_dineway/api/admin/context/stale - List current entries past valid_until
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleContextEntryStale } from "#api/handlers/context.js";
+import { isParseError, parseQuery } from "#api/parse.js";
+import { contextEntryStaleQuery } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ url, locals }) => {
+	const { dineway, user } = locals;
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "settings:read");
+	if (denied) return denied;
+
+	try {
+		const query = parseQuery(url, contextEntryStaleQuery);
+		if (isParseError(query)) return query;
+
+		const result = await handleContextEntryStale(dineway.db, query);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to list stale context entries", "CONTEXT_STALE_ERROR");
+	}
+};

package/src/astro/routes/api/admin/hitl-requests/[id]/index.ts

@@ -0,0 +1,38 @@
+/**
+ * Admin HITL request detail
+ *
+ * GET /_dineway/api/admin/hitl-requests/:id - Get a generic HITL request
+ */
+
+import { Role } from "@dineway-ai/auth";
+import type { APIRoute } from "astro";
+
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleHitlRequestGet } from "#api/handlers/hitl-requests.js";
+import { resolveHitlRouteActor } from "#api/hitl-route-helpers.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ params, locals }) => {
+	const { dineway, user } = locals;
+	const { id } = params;
+
+	if (!id) {
+		return apiError("VALIDATION_ERROR", "HITL request ID required", 400);
+	}
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	if (!user || user.role < Role.ADMIN) {
+		return apiError("FORBIDDEN", "Admin privileges required", 403);
+	}
+
+	try {
+		const actor = resolveHitlRouteActor(locals);
+		const result = await handleHitlRequestGet(dineway.db, id, actor.access);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to fetch HITL request", "WORKFLOW_HITL_GET_ERROR");
+	}
+};

package/src/astro/routes/api/admin/hitl-requests/[id]/resolve.ts

@@ -0,0 +1,54 @@
+/**
+ * Admin HITL request resolution
+ *
+ * POST /_dineway/api/admin/hitl-requests/:id/resolve - Approve or reject a generic HITL request
+ */
+
+import { Role } from "@dineway-ai/auth";
+import type { APIRoute } from "astro";
+
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleHitlRequestResolve } from "#api/handlers/hitl-requests.js";
+import { logHitlRouteActivity, resolveHitlRouteActor } from "#api/hitl-route-helpers.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { hitlRequestResolveBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { dineway, user } = locals;
+	const { id } = params;
+
+	if (!id) {
+		return apiError("VALIDATION_ERROR", "HITL request ID required", 400);
+	}
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	if (!user || user.role < Role.ADMIN) {
+		return apiError("FORBIDDEN", "Admin privileges required", 403);
+	}
+
+	try {
+		const body = await parseBody(request, hitlRequestResolveBody);
+		if (isParseError(body)) return body;
+
+		const actor = resolveHitlRouteActor(locals);
+		const result = await handleHitlRequestResolve(dineway.db, id, {
+			decision: body.decision,
+			reviewNote: body.reviewNote,
+			actor: actor.access,
+		});
+		if (!result.success) return unwrapResult(result);
+
+		await logHitlRouteActivity(dineway.db, locals, {
+			actionType: body.decision === "approved" ? "hitl.approved" : "hitl.rejected",
+			item: result.data.item,
+		});
+
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to resolve HITL request", "WORKFLOW_HITL_RESOLVE_ERROR");
+	}
+};

package/src/astro/routes/api/admin/hitl-requests/index.ts

@@ -0,0 +1,38 @@
+/**
+ * Admin HITL requests
+ *
+ * GET /_dineway/api/admin/hitl-requests - List generic HITL requests
+ */
+
+import { Role } from "@dineway-ai/auth";
+import type { APIRoute } from "astro";
+
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleHitlRequestList } from "#api/handlers/hitl-requests.js";
+import { resolveHitlRouteActor } from "#api/hitl-route-helpers.js";
+import { isParseError, parseQuery } from "#api/parse.js";
+import { hitlRequestListQuery } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ url, locals }) => {
+	const { dineway, user } = locals;
+
+	const dbErr = requireDb(dineway?.db);
+	if (dbErr) return dbErr;
+
+	if (!user || user.role < Role.ADMIN) {
+		return apiError("FORBIDDEN", "Admin privileges required", 403);
+	}
+
+	try {
+		const query = parseQuery(url, hitlRequestListQuery);
+		if (isParseError(query)) return query;
+
+		const actor = resolveHitlRouteActor(locals);
+		const result = await handleHitlRequestList(dineway.db, actor.access, query);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to list HITL requests", "WORKFLOW_HITL_LIST_ERROR");
+	}
+};

package/src/astro/routes/api/admin/hooks/exclusive/[hookName].ts

@@ -13,8 +13,18 @@ import { z } from "zod";
 
 import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
+import {
+	ensureWorkflowHitlRouteRequest,
+	hitlRequiredRouteError,
+	resolveHitlRouteActor,
+} from "#api/hitl-route-helpers.js";
 import { isParseError, parseBody } from "#api/parse.js";
-import { OptionsRepository } from "#db/repositories/options.js";
+import {
+	ExclusiveHookHitlPayloadBuilder,
+	exclusiveHookApiRouteSource,
+	logExclusiveHookActivity,
+	RiskPolicyEvaluator,
+} from "#site-context/index.js";
 
 export const prerender = false;
 
@@ -23,6 +33,7 @@ const HOOK_NAME_RE = /^[a-z]+:[a-zA-Z]+$/;
 
 const setSelectionSchema = z.object({
 	pluginId: z.string().min(1).nullable(),
+	hitlRequestId: z.string().min(1).optional(),
 });
 
 export const PUT: APIRoute = async ({ params, request, locals }) => {
@@ -55,20 +66,14 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 
 		const body = await parseBody(request, setSelectionSchema);
 		if (isParseError(body)) return body;
-
-		const optionsRepo = new OptionsRepository(dineway.db);
-		const optionKey = `dineway:exclusive_hook:${hookName}`;
-
-		if (body.pluginId === null) {
-			// Clear the selection
-			await optionsRepo.delete(optionKey);
-			pipeline.clearExclusiveSelection(hookName);
-		} else {
-			// Validate that the pluginId is an actual provider for this hook
-			const providers = pipeline.getExclusiveHookProviders(hookName);
-			const isValidProvider = providers.some(
-				(p: { pluginId: string }) => p.pluginId === body.pluginId,
-			);
+		const providers = pipeline
+			.getExclusiveHookProviders(hookName)
+			.map((provider: { pluginId: string; pluginName?: string }) => ({
+				pluginId: provider.pluginId,
+				pluginName: provider.pluginName ?? provider.pluginId,
+			}));
+		if (body.pluginId !== null) {
+			const isValidProvider = providers.some((provider) => provider.pluginId === body.pluginId);
 			if (!isValidProvider) {
 				return apiError(
 					"VALIDATION_ERROR",
@@ -76,11 +81,47 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 					400,
 				);
 			}
+		}
 
-			await optionsRepo.set(optionKey, body.pluginId);
-			pipeline.setExclusiveSelection(hookName, body.pluginId);
+		const previousPluginId = await pipeline.getExclusiveHookSelection(hookName);
+		const actor = resolveHitlRouteActor(locals);
+		const evaluator = new RiskPolicyEvaluator({
+			db: dineway.db,
+			handlers: dineway,
+		});
+		let approvedHitlRequestId: string | null = null;
+
+		if (evaluator.requiresWorkflowHitl(actor.identity)) {
+			const action = await new ExclusiveHookHitlPayloadBuilder().buildSetSelectionRequest({
+				hookName,
+				currentPluginId: previousPluginId,
+				requestedPluginId: body.pluginId,
+				providers,
+			});
+			const decision = await evaluator.evaluateWorkflowHitl({
+				actor: actor.identity,
+				hitlRequestId: body.hitlRequestId,
+				action,
+			});
+			if (!decision.allowed) {
+				const ensured = await ensureWorkflowHitlRouteRequest(dineway.db, locals, decision.action);
+				return hitlRequiredRouteError(decision, ensured);
+			}
+			approvedHitlRequestId = decision.hitlRequest.id;
 		}
 
+		await pipeline.setExclusiveHookSelection(hookName, body.pluginId);
+		await logExclusiveHookActivity(dineway.db, locals, {
+			action: "updated",
+			hookName,
+			previousPluginId,
+			selectedPluginId: body.pluginId,
+			...exclusiveHookApiRouteSource("updated"),
+			detail: {
+				hitlRequestId: approvedHitlRequestId,
+			},
+		});
+
 		return apiSuccess({
 			hookName,
 			selectedPluginId: body.pluginId,