@xopcai/xopc 0.0.173 → 0.0.175

package/dist/src/focuses/service.js

@@ -0,0 +1,241 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { createFocus, createFocusActivity, deleteFocus, getFocus, getFocusMonitor, listAllFocusMonitors, listFocusMonitors, listFocuses, updateFocus, updateFocusMonitorRuntime, upsertFocusMonitor } from "./repository.js";
+import { buildFocusMonitorInstruction } from "./prompts.js";
+//#region src/focuses/service.ts
+init_logger();
+const log = createLogger("FocusService");
+const DEFAULT_CADENCE = {
+	kind: "interval",
+	everyMs: 864e5
+};
+var FocusService = class {
+	constructor(automations) {
+		this.automations = automations;
+	}
+	list(statuses) {
+		return listFocuses({ statuses }).map((focus) => this.detail(focus));
+	}
+	get(id) {
+		const focus = getFocus(id);
+		return focus ? this.detail(focus) : null;
+	}
+	create(input) {
+		if (!input.title.trim()) throw new Error("Focus title is required");
+		const focus = createFocus(input);
+		return this.detail(focus);
+	}
+	update(id, input) {
+		if (input.title !== void 0 && !input.title.trim()) throw new Error("Focus title is required");
+		if (!updateFocus({
+			id,
+			...input
+		})) return null;
+		createFocusActivity({
+			focusId: id,
+			type: "updated",
+			summary: "Focus updated"
+		});
+		return this.get(id);
+	}
+	async setStatus(id, status) {
+		const focus = getFocus(id);
+		if (!focus) return null;
+		if (focus.status === status) return this.detail(focus);
+		const monitors = listFocusMonitors(id);
+		if (status === "active") for (const monitor of monitors.filter((item) => item.enabled && item.automationId)) await this.automations.resume(monitor.automationId);
+		else if (status === "paused") for (const monitor of monitors.filter((item) => item.enabled && item.automationId)) await this.automations.pause(monitor.automationId);
+		else for (const monitor of monitors.filter((item) => item.automationId)) {
+			await this.automations.remove(monitor.automationId);
+			upsertFocusMonitor({
+				focusId: id,
+				kind: monitor.kind,
+				enabled: false,
+				cadence: monitor.cadence,
+				automationId: null
+			});
+		}
+		if (!updateFocus({
+			id,
+			status
+		})) return null;
+		const type = status === "active" ? "resumed" : status === "paused" ? "paused" : "completed";
+		createFocusActivity({
+			focusId: id,
+			type,
+			summary: `Focus ${type}`
+		});
+		return this.get(id);
+	}
+	async remove(id) {
+		if (!getFocus(id)) return false;
+		for (const monitor of listFocusMonitors(id).filter((item) => item.automationId)) await this.automations.remove(monitor.automationId);
+		return deleteFocus(id);
+	}
+	async configureMonitor(input) {
+		const focus = getFocus(input.focusId);
+		if (!focus) throw new Error("Focus not found");
+		if (focus.status !== "active") throw new Error("Only active focuses can enable monitoring");
+		const existing = getFocusMonitor(input.focusId, input.kind);
+		const cadence = input.cadence ?? existing?.cadence ?? DEFAULT_CADENCE;
+		if (cadence.kind !== "interval" || cadence.everyMs < 6e4) throw new Error("Invalid monitor cadence");
+		if (input.enabled && existing?.enabled && existing.cadence.everyMs === cadence.everyMs) return { monitor: existing };
+		if (!input.enabled) {
+			if (existing?.automationId) await this.automations.pause(existing.automationId);
+			const monitor = upsertFocusMonitor({
+				focusId: input.focusId,
+				kind: input.kind,
+				enabled: false,
+				cadence,
+				automationId: existing?.automationId
+			});
+			createFocusActivity({
+				focusId: input.focusId,
+				monitorId: monitor.id,
+				type: "monitor_disabled",
+				summary: `${input.kind} monitoring disabled`
+			});
+			return { monitor };
+		}
+		let monitor = upsertFocusMonitor({
+			focusId: input.focusId,
+			kind: input.kind,
+			enabled: true,
+			runState: "queued",
+			cadence,
+			automationId: existing?.automationId
+		});
+		try {
+			let automation;
+			if (existing?.automationId) if (existing.cadence.everyMs !== cadence.everyMs) automation = await this.automations.update(existing.automationId, { trigger: {
+				kind: "schedule",
+				schedule: {
+					kind: "interval",
+					everyMs: cadence.everyMs
+				}
+			} });
+			else automation = await this.automations.resume(existing.automationId);
+			else automation = await this.automations.create({
+				name: `Monitor: ${focus.title}`.slice(0, 200),
+				description: `${input.kind} monitor for a user-confirmed focus.`,
+				...focus.projectIds[0] ? { projectId: focus.projectIds[0] } : {},
+				trigger: {
+					kind: "schedule",
+					schedule: {
+						kind: "interval",
+						everyMs: cadence.everyMs
+					}
+				},
+				action: {
+					kind: "agent",
+					instruction: buildFocusMonitorInstruction(focus, input.kind),
+					timeoutSeconds: 300
+				},
+				safety: { mode: "suggest_only" },
+				afterRun: { kind: "none" },
+				reliability: {
+					timeoutSeconds: 300,
+					disableAfterConsecutiveFailures: 3
+				}
+			});
+			monitor = upsertFocusMonitor({
+				focusId: input.focusId,
+				kind: input.kind,
+				enabled: true,
+				runState: "queued",
+				cadence,
+				automationId: automation.id
+			});
+			createFocusActivity({
+				focusId: input.focusId,
+				monitorId: monitor.id,
+				type: "monitor_enabled",
+				summary: `${input.kind} monitoring enabled`
+			});
+			const run = await this.automations.runNow(automation.id);
+			monitor = updateFocusMonitorRuntime({
+				id: monitor.id,
+				runState: "running",
+				lastRunId: run.id,
+				nextRunAt: automation.state.nextRunAtMs ?? null
+			}) ?? monitor;
+			createFocusActivity({
+				focusId: input.focusId,
+				monitorId: monitor.id,
+				type: "run_started",
+				summary: "Initial monitor check started",
+				details: { runId: run.id }
+			});
+			return {
+				monitor,
+				initialRunId: run.id
+			};
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			updateFocusMonitorRuntime({
+				id: monitor.id,
+				runState: "failed",
+				error: errorMessage
+			});
+			log.error({
+				err,
+				focusId: input.focusId,
+				monitorKind: input.kind
+			}, `Focus monitor enable failed: ${errorMessage}`);
+			throw err;
+		}
+	}
+	async runMonitorNow(focusId, kind) {
+		const monitor = getFocusMonitor(focusId, kind);
+		if (!monitor?.enabled || !monitor.automationId) throw new Error("Monitor is not enabled");
+		updateFocusMonitorRuntime({
+			id: monitor.id,
+			runState: "queued",
+			error: null
+		});
+		const run = await this.automations.runNow(monitor.automationId);
+		updateFocusMonitorRuntime({
+			id: monitor.id,
+			runState: "running",
+			lastRunId: run.id
+		});
+		createFocusActivity({
+			focusId,
+			monitorId: monitor.id,
+			type: "run_started",
+			summary: "Monitor check started",
+			details: { runId: run.id }
+		});
+		return run;
+	}
+	async reconcile() {
+		for (const monitor of listAllFocusMonitors()) {
+			const focus = getFocus(monitor.focusId);
+			if (!focus) continue;
+			const automation = monitor.automationId ? await this.automations.get(monitor.automationId) : null;
+			if (monitor.enabled && focus.status === "active" && !automation) try {
+				await this.configureMonitor({
+					focusId: focus.id,
+					kind: monitor.kind,
+					enabled: true,
+					cadence: monitor.cadence
+				});
+			} catch (err) {
+				log.warn({
+					err,
+					focusId: focus.id,
+					monitorId: monitor.id
+				}, "Focus monitor reconciliation failed");
+			}
+			else if ((!monitor.enabled || focus.status !== "active") && automation?.enabled) await this.automations.pause(automation.id);
+		}
+	}
+	detail(focus) {
+		return {
+			...focus,
+			monitors: listFocusMonitors(focus.id)
+		};
+	}
+};
+//#endregion
+export { FocusService };

package/dist/src/focuses/types.d.ts

@@ -0,0 +1,89 @@
+export type FocusStatus = 'active' | 'paused' | 'completed';
+export type FocusSource = 'user' | 'discovery';
+export type FocusCandidateStatus = 'pending' | 'accepted' | 'dismissed';
+export type FocusMonitorKind = 'progress' | 'external_changes';
+export type FocusMonitorRunState = 'idle' | 'queued' | 'running' | 'failed';
+export type FocusInsightStatus = 'unread' | 'dismissed' | 'approved';
+export type FocusActivityType = 'created' | 'updated' | 'paused' | 'resumed' | 'completed' | 'monitor_enabled' | 'monitor_disabled' | 'run_started' | 'run_no_change' | 'run_failed' | 'insight_created' | 'insight_dismissed' | 'insight_approved';
+export interface FocusEvidence {
+    label: string;
+    source?: string;
+    publishedAt?: string;
+}
+export interface FocusCandidate {
+    id: string;
+    canonicalKey: string;
+    title: string;
+    summary: string;
+    confidence: number;
+    evidence: FocusEvidence[];
+    projectIds: string[];
+    status: FocusCandidateStatus;
+    discoveredAt: number;
+    updatedAt: number;
+}
+export interface Focus {
+    id: string;
+    title: string;
+    summary: string;
+    status: FocusStatus;
+    source: FocusSource;
+    sourceCandidateId?: string;
+    projectIds: string[];
+    goalId?: string;
+    createdAt: number;
+    updatedAt: number;
+    completedAt?: number;
+    lastActivityAt?: number;
+}
+export interface FocusCadence {
+    kind: 'interval';
+    everyMs: number;
+}
+export interface FocusMonitor {
+    id: string;
+    focusId: string;
+    kind: FocusMonitorKind;
+    enabled: boolean;
+    runState: FocusMonitorRunState;
+    cadence: FocusCadence;
+    automationId?: string;
+    lastRunId?: string;
+    lastRunAt?: number;
+    nextRunAt?: number;
+    lastMeaningfulResultAt?: number;
+    lastError?: string;
+    consecutiveFailures: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface FocusActivity {
+    id: string;
+    focusId: string;
+    monitorId?: string;
+    type: FocusActivityType;
+    summary: string;
+    details: Record<string, unknown>;
+    createdAt: number;
+}
+export interface FocusInsight {
+    id: string;
+    focusId: string;
+    monitorId: string;
+    runId: string;
+    kind: FocusMonitorKind;
+    title: string;
+    summary: string;
+    whyItMatters: string;
+    nextAction: string;
+    evidence: FocusEvidence[];
+    status: FocusInsightStatus;
+    valueScore: number;
+    valueReasons: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface FocusDetail extends Focus {
+    monitors: FocusMonitor[];
+    latestInsight?: FocusInsight;
+}

package/dist/src/gateway/agents-admin.js

@@ -1,5 +1,5 @@
-import { resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentDir, resolveAgentProfileDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, resolveUserPath, validateAgentIdForNewAgent } from "../agent/agent-scope.js";
+import { resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import { resolveEffectiveAgentProfile } from "../config/agent-profile.js";
 import { WORKSPACE_FILES, init_paths, resolveUserProfilePath } from "../config/paths.js";
 import { AGENT_PROFILE_MARKDOWN_SYSTEM_FILES, REQUIRED_AGENT_PROFILE_MARKDOWN_FILE_SET } from "../agent/context/workspace.js";

package/dist/src/gateway/heartbeat/service.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { shouldSilence, stripHeartbeatToken } from "../../heartbeat/tokens.js";
+import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { isWithinActiveHours } from "../../heartbeat/active-hours.js";
 import { isHeartbeatContentEmpty } from "../../heartbeat/content-check.js";
-import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { createHeartbeatWake } from "../../heartbeat/wake.js";
 import { resolveHeartbeatMdPath } from "../workspace-heartbeat-path.js";
 import { readFile } from "fs/promises";

package/dist/src/gateway/hono/routes/focuses.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerFocusRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/focuses.js

@@ -0,0 +1,319 @@
+import { createFocusActivity, listFocusActivities } from "../../../focuses/repository.js";
+import { acceptFocusCandidate, listFocusCandidates, setFocusCandidateStatus } from "../../../focuses/candidate-repository.js";
+import { getFocusInsight, listFocusInsights, setFocusInsightStatus } from "../../../focuses/insight-repository.js";
+import { FocusService } from "../../../focuses/service.js";
+import "../../../focuses/index.js";
+//#region src/gateway/hono/routes/focuses.ts
+const FOCUS_STATUSES = [
+	"active",
+	"paused",
+	"completed"
+];
+const MONITOR_KINDS = ["progress", "external_changes"];
+function stringField(body, field) {
+	if (!body || typeof body !== "object") return "";
+	const value = body[field];
+	return typeof value === "string" ? value.trim() : "";
+}
+function stringArrayField(body, field) {
+	if (!body || typeof body !== "object") return void 0;
+	const value = body[field];
+	if (!Array.isArray(value)) return void 0;
+	return [...new Set(value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean))];
+}
+function registerFocusRoutes(authenticated, deps) {
+	const focuses = new FocusService(deps.service.automationServiceInstance);
+	const limited = deps.strictRateLimitMiddleware;
+	authenticated.get("/api/focuses", (c) => {
+		const requested = c.req.query("status")?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
+		const statuses = requested.length > 0 ? requested.filter((item) => FOCUS_STATUSES.includes(item)) : void 0;
+		if (requested.length > 0 && statuses?.length !== requested.length) return c.json({
+			ok: false,
+			error: "Invalid focus status"
+		}, 400);
+		return c.json({
+			ok: true,
+			focuses: focuses.list(statuses)
+		});
+	});
+	authenticated.post("/api/focuses", limited, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		const title = stringField(body, "title");
+		if (!title) return c.json({
+			ok: false,
+			error: "Focus title is required"
+		}, 400);
+		const focus = focuses.create({
+			title,
+			summary: stringField(body, "summary"),
+			...stringArrayField(body, "projectIds") ? { projectIds: stringArrayField(body, "projectIds") } : {},
+			...stringField(body, "goalId") ? { goalId: stringField(body, "goalId") } : {}
+		});
+		deps.service.emit("focus.created", { focus });
+		return c.json({
+			ok: true,
+			focus
+		}, 201);
+	});
+	authenticated.get("/api/focuses/:focusId", (c) => {
+		const focus = focuses.get(c.req.param("focusId"));
+		return focus ? c.json({
+			ok: true,
+			focus
+		}) : c.json({
+			ok: false,
+			error: "Focus not found"
+		}, 404);
+	});
+	authenticated.patch("/api/focuses/:focusId", limited, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		const requestedStatus = stringField(body, "status");
+		if (requestedStatus && !FOCUS_STATUSES.includes(requestedStatus)) return c.json({
+			ok: false,
+			error: "Invalid focus status"
+		}, 400);
+		try {
+			const title = stringField(body, "title");
+			const hasSummary = typeof body?.summary === "string";
+			const projectIds = stringArrayField(body, "projectIds");
+			let focus = Boolean(title || hasSummary || projectIds) ? focuses.update(c.req.param("focusId"), {
+				...title ? { title } : {},
+				...hasSummary ? { summary: stringField(body, "summary") } : {},
+				...projectIds ? { projectIds } : {}
+			}) : focuses.get(c.req.param("focusId"));
+			if (focus && requestedStatus) focus = await focuses.setStatus(c.req.param("focusId"), requestedStatus);
+			if (!focus) return c.json({
+				ok: false,
+				error: "Focus not found"
+			}, 404);
+			deps.service.emit("focus.updated", { focus });
+			return c.json({
+				ok: true,
+				focus
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.delete("/api/focuses/:focusId", limited, async (c) => {
+		try {
+			if (!await focuses.remove(c.req.param("focusId"))) return c.json({
+				ok: false,
+				error: "Focus not found"
+			}, 404);
+			deps.service.emit("focus.deleted", { focusId: c.req.param("focusId") });
+			return c.json({ ok: true });
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 500);
+		}
+	});
+	authenticated.put("/api/focuses/:focusId/monitors/:kind", limited, async (c) => {
+		const kind = c.req.param("kind");
+		if (!MONITOR_KINDS.includes(kind)) return c.json({
+			ok: false,
+			error: "Invalid monitor kind"
+		}, 400);
+		const body = await c.req.json().catch(() => null);
+		const enabled = body && typeof body === "object" ? body.enabled : void 0;
+		if (typeof enabled !== "boolean") return c.json({
+			ok: false,
+			error: "enabled must be a boolean"
+		}, 400);
+		const everyMs = body && typeof body === "object" && body.cadence && typeof body.cadence === "object" ? Number(body.cadence.everyMs) : void 0;
+		try {
+			const result = await focuses.configureMonitor({
+				focusId: c.req.param("focusId"),
+				kind,
+				enabled,
+				...Number.isFinite(everyMs) ? { cadence: {
+					kind: "interval",
+					everyMs
+				} } : {}
+			});
+			deps.service.emit("focus.monitor.updated", {
+				focusId: c.req.param("focusId"),
+				monitor: result.monitor
+			});
+			return c.json({
+				ok: true,
+				...result
+			}, result.initialRunId ? 202 : 200);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.post("/api/focuses/:focusId/monitors/:kind/run", limited, async (c) => {
+		const kind = c.req.param("kind");
+		if (!MONITOR_KINDS.includes(kind)) return c.json({
+			ok: false,
+			error: "Invalid monitor kind"
+		}, 400);
+		try {
+			const run = await focuses.runMonitorNow(c.req.param("focusId"), kind);
+			deps.service.emit("focus.run.updated", {
+				focusId: c.req.param("focusId"),
+				kind,
+				run
+			});
+			return c.json({
+				ok: true,
+				run
+			}, 202);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.get("/api/focuses/:focusId/activities", (c) => c.json({
+		ok: true,
+		activities: listFocusActivities({
+			focusId: c.req.param("focusId"),
+			...Number.isFinite(Number(c.req.query("before"))) ? { before: Number(c.req.query("before")) } : {},
+			...Number.isFinite(Number(c.req.query("limit"))) ? { limit: Number(c.req.query("limit")) } : {}
+		})
+	}));
+	authenticated.get("/api/focuses/:focusId/insights", (c) => c.json({
+		ok: true,
+		insights: listFocusInsights({
+			focusId: c.req.param("focusId"),
+			limit: Number(c.req.query("limit")) || 20
+		})
+	}));
+	authenticated.post("/api/focuses/:focusId/insights/:insightId/dismiss", limited, (c) => {
+		const insight = getFocusInsight(c.req.param("insightId"));
+		if (!insight || insight.focusId !== c.req.param("focusId")) return c.json({
+			ok: false,
+			error: "Insight not found"
+		}, 404);
+		const updated = setFocusInsightStatus(insight.id, "dismissed", "unread");
+		if (!updated) return c.json({
+			ok: false,
+			error: "Insight was already handled"
+		}, 409);
+		createFocusActivity({
+			focusId: insight.focusId,
+			monitorId: insight.monitorId,
+			type: "insight_dismissed",
+			summary: insight.title,
+			details: { insightId: insight.id }
+		});
+		deps.service.emit("focus.insight.updated", { insight: updated });
+		return c.json({
+			ok: true,
+			insight: updated
+		});
+	});
+	authenticated.post("/api/focuses/:focusId/insights/:insightId/investigate", limited, async (c) => {
+		const insight = getFocusInsight(c.req.param("insightId"));
+		const focus = focuses.get(c.req.param("focusId"));
+		if (!insight || !focus || insight.focusId !== focus.id) return c.json({
+			ok: false,
+			error: "Insight not found"
+		}, 404);
+		const claimed = setFocusInsightStatus(insight.id, "approved", "unread");
+		if (!claimed) return c.json({
+			ok: false,
+			error: "Insight was already handled"
+		}, 409);
+		let automationId;
+		try {
+			const automation = await deps.service.automationServiceInstance.create({
+				name: `Investigate: ${insight.title}`.slice(0, 200),
+				description: `User-approved investigation for focus insight ${insight.id}.`,
+				...focus.projectIds[0] ? { projectId: focus.projectIds[0] } : {},
+				trigger: { kind: "manual" },
+				action: {
+					kind: "agent",
+					instruction: [
+						"Investigate this user-approved focus insight in read-only mode.",
+						`Focus: ${focus.title}`,
+						`Observed change: ${insight.summary}`,
+						`Why it matters: ${insight.whyItMatters}`,
+						`Next step: ${insight.nextAction}`,
+						`Evidence: ${JSON.stringify(insight.evidence)}`,
+						"Return a concise result with evidence. Do not modify files or external systems."
+					].join("\n"),
+					timeoutSeconds: 300
+				},
+				safety: { mode: "suggest_only" },
+				afterRun: { kind: "none" },
+				reliability: {
+					timeoutSeconds: 300,
+					disableAfterConsecutiveFailures: 1
+				}
+			});
+			automationId = automation.id;
+			const run = await deps.service.automationServiceInstance.runNow(automation.id);
+			createFocusActivity({
+				focusId: focus.id,
+				monitorId: insight.monitorId,
+				type: "insight_approved",
+				summary: insight.title,
+				details: {
+					insightId: insight.id,
+					automationId,
+					runId: run.id
+				}
+			});
+			deps.service.emit("focus.insight.updated", {
+				insight: claimed,
+				investigationRunId: run.id
+			});
+			return c.json({
+				ok: true,
+				insight: claimed,
+				automationId,
+				runId: run.id
+			}, 202);
+		} catch (error) {
+			if (automationId) await deps.service.automationServiceInstance.remove(automationId);
+			setFocusInsightStatus(insight.id, "unread", "approved");
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 500);
+		}
+	});
+	authenticated.get("/api/focus-candidates", (c) => c.json({
+		ok: true,
+		candidates: listFocusCandidates()
+	}));
+	authenticated.post("/api/focus-candidates/:candidateId/accept", limited, (c) => {
+		const focus = acceptFocusCandidate(c.req.param("candidateId"));
+		if (!focus) return c.json({
+			ok: false,
+			error: "Focus candidate not found"
+		}, 404);
+		const detail = focuses.get(focus.id);
+		deps.service.emit("focus.created", { focus: detail });
+		return c.json({
+			ok: true,
+			focus: detail
+		}, 201);
+	});
+	authenticated.post("/api/focus-candidates/:candidateId/dismiss", limited, (c) => {
+		const candidate = setFocusCandidateStatus(c.req.param("candidateId"), "dismissed");
+		if (!candidate) return c.json({
+			ok: false,
+			error: "Focus candidate not found"
+		}, 404);
+		deps.service.emit("focus.candidate.updated", { candidate });
+		return c.json({
+			ok: true,
+			candidate
+		});
+	});
+}
+//#endregion
+export { registerFocusRoutes };