@xopcai/xopc 0.0.188 → 0.0.190

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

@@ -11,6 +11,7 @@ import { createConnectorSetupSecretRequest, submitConnectorSetupSecret } from ".
 import { configureComposioApiKey, executeComposioTool, getComposioInstallationPolicy, getComposioToolkitScope, inspectComposioConnectorHealth, listComposioConnections, listComposioTools, refreshComposioConnection, revokeComposioConnection, setComposioToolkitScope, updateComposioConnection, updateComposioInstallationPolicy } from "../../../connectors/composio.js";
 import { listConnectorProviders } from "../../../connectors/providers.js";
 import { getConnectorDefinition, listConnectorCatalog } from "../../../connectors/catalog.js";
+import { listUnderstandingSourceGrants, revokeUnderstandingSourceGrant } from "../../../user-context/sources/repository.js";
 import { recordConnectorHealthUsage } from "../../../connectors/usage.js";
 import { getConnectorInstance, listConnectorInstances } from "../../../connectors/instances.js";
 import { installConnector, installConnectorDefinition, uninstallConnector, updateConnectorConfig } from "../../../connectors/install.js";
@@ -159,8 +160,11 @@ function registerConnectorRoutes(authenticated, deps) {
 			...allowedScenarioKeys ? { allowedScenarioKeys } : {}
 		});
 		const connectionId = account.currentConnectionId;
-		if (connectionId && !policy.scanEnabled) service.setConnectorLearningPaused(connectionId, true);
-		else if (connectionId && previous?.scanEnabled === false) {
+		if (connectionId && !policy.scanEnabled) {
+			service.setConnectorLearningPaused(connectionId, true);
+			const grant = listUnderstandingSourceGrants().find((item) => item.sourceKey === `connector-account:${account.id}`);
+			if (grant) revokeUnderstandingSourceGrant(grant.id);
+		} else if (connectionId && previous?.scanEnabled === false) {
 			if (service.setConnectorLearningPaused(connectionId, false) === 0) service.requestConnectorLearning(connectionId, {
 				mode: "incremental",
 				reason: "schedule"
@@ -179,15 +183,6 @@ function registerConnectorRoutes(authenticated, deps) {
 				ok: false,
 				error: "Connector account has no usable authorization."
 			}, 409);
-			const config = service.currentConfig;
-			if (!config.userContext.memory.sources.includes("connectedSources")) {
-				config.userContext.memory.sources = [...config.userContext.memory.sources, "connectedSources"];
-				const saved = await service.saveConfig(config);
-				if (!saved.saved) return c.json({
-					ok: false,
-					error: saved.error
-				}, 500);
-			}
 			const job = service.requestConnectorLearning(account.currentConnectionId, { reason: "manual" });
 			if (!job) return c.json({
 				ok: false,
@@ -255,7 +250,13 @@ function registerConnectorRoutes(authenticated, deps) {
 	});
 	authenticated.delete("/api/connectors/composio/connections/:id", strictRateLimitMiddleware, async (c) => {
 		try {
-			await revokeComposioConnection(c.req.param("id"));
+			const connectionId = c.req.param("id");
+			const connection = listConnectorConnections().find((item) => item.id === connectionId);
+			await revokeComposioConnection(connectionId);
+			if (connection?.accountId) {
+				const grant = listUnderstandingSourceGrants().find((item) => item.sourceKey === `connector-account:${connection.accountId}`);
+				if (grant) revokeUnderstandingSourceGrant(grant.id);
+			}
 			return c.json({
 				ok: true,
 				payload: { revoked: true }

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

@@ -1,11 +1,9 @@
 import type { MiddlewareHandler } from 'hono';
 import type { GatewayService } from '../../service.js';
-import type { SSEHandlerConfig } from '../sse.js';
 export interface AuthenticatedRouteDeps {
     service: GatewayService;
     strictRateLimitMiddleware: MiddlewareHandler;
     chatRateLimitMiddleware: MiddlewareHandler;
     xopcCloudPollRateLimitMiddleware: MiddlewareHandler;
     channelRateLimitMiddleware?: MiddlewareHandler;
-    sseConfig: SSEHandlerConfig;
 }

package/dist/src/gateway/hono/routes/endpoint-tools.d.ts

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

package/dist/src/gateway/hono/routes/endpoint-tools.js

@@ -0,0 +1,196 @@
+import { endpointPrincipalRegistrationSchema } from "../../../../packages/endpoint-tools-protocol/src/index.js";
+import { createEndpointPrincipal, getEndpointPrincipal, listEndpointPrincipals, revokeEndpointPrincipal } from "../../../storage/sqlite/endpoint-principal-repository.js";
+import { listEndpointToolInvocationAudits } from "../../../storage/sqlite/endpoint-tool-invocation-repository.js";
+import "../../../storage/sqlite/index.js";
+import { parseEndpointPublicKey } from "../../../endpoint-tools/auth.js";
+import { ENDPOINT_UPLOAD_MAX_BYTES, EndpointUploadError } from "../../../endpoint-tools/upload-service.js";
+//#region src/gateway/hono/routes/endpoint-tools.ts
+async function readBoundedBody(body, maxBytes) {
+	if (!body) return new Uint8Array();
+	const reader = body.getReader();
+	const chunks = [];
+	let size = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			size += value.byteLength;
+			if (size > maxBytes) throw new EndpointUploadError("Uploaded file is too large");
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const bytes = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return bytes;
+}
+function registerEndpointToolRoutes(authenticated, deps) {
+	authenticated.get("/api/endpoint-tools/principals", (c) => {
+		const endpointsByPrincipal = /* @__PURE__ */ new Map();
+		for (const endpoint of deps.service.endpointTools.registry.list()) {
+			const endpoints = endpointsByPrincipal.get(endpoint.principalId) ?? [];
+			endpoints.push(endpoint);
+			endpointsByPrincipal.set(endpoint.principalId, endpoints);
+		}
+		return c.json({
+			ok: true,
+			payload: listEndpointPrincipals().map(({ publicKey: _publicKey, ...principal }) => ({
+				...principal,
+				endpoints: endpointsByPrincipal.get(principal.id) ?? []
+			}))
+		});
+	});
+	authenticated.post("/api/endpoint-tools/principals", async (c) => {
+		const parsed = endpointPrincipalRegistrationSchema.safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success) return c.json({
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: "Invalid endpoint principal"
+			}
+		}, 400);
+		try {
+			parseEndpointPublicKey(parsed.data.publicKey);
+		} catch {
+			return c.json({
+				ok: false,
+				error: {
+					code: "BAD_REQUEST",
+					message: "Invalid endpoint public key"
+				}
+			}, 400);
+		}
+		const existing = getEndpointPrincipal(parsed.data.principalId);
+		if (existing && !existing.revokedAt && existing.displayName === parsed.data.displayName && existing.kind === parsed.data.kind && existing.platform === parsed.data.platform && existing.publicKey === parsed.data.publicKey) return c.json({
+			ok: true,
+			payload: existing
+		}, 200);
+		if (existing) {
+			if (existing.revokedAt) return c.json({
+				ok: false,
+				error: {
+					code: "PRINCIPAL_REVOKED",
+					message: "Endpoint principal was revoked"
+				}
+			}, 403);
+			return c.json({
+				ok: false,
+				error: {
+					code: "CONFLICT",
+					message: "Endpoint principal already exists"
+				}
+			}, 409);
+		}
+		const principal = createEndpointPrincipal({
+			id: parsed.data.principalId,
+			displayName: parsed.data.displayName,
+			kind: parsed.data.kind,
+			platform: parsed.data.platform,
+			publicKey: parsed.data.publicKey
+		});
+		return c.json({
+			ok: true,
+			payload: principal
+		}, 201);
+	});
+	authenticated.delete("/api/endpoint-tools/principals/:principalId", (c) => {
+		const principalId = c.req.param("principalId").trim();
+		if (!principalId) return c.json({
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: "Missing principal id"
+			}
+		}, 400);
+		if (!revokeEndpointPrincipal(principalId)) return c.json({
+			ok: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Endpoint principal not found"
+			}
+		}, 404);
+		for (const endpoint of deps.service.endpointTools.registry.list()) if (endpoint.principalId === principalId) deps.service.endpointTools.disconnect(endpoint.endpointId, "Endpoint principal revoked");
+		return c.json({
+			ok: true,
+			payload: {
+				principalId,
+				revoked: true
+			}
+		});
+	});
+	authenticated.get("/api/endpoint-tools/invocations", (c) => {
+		const limit = Number(c.req.query("limit") ?? 100);
+		return c.json({
+			ok: true,
+			payload: listEndpointToolInvocationAudits(Number.isFinite(limit) ? limit : 100)
+		});
+	});
+	authenticated.post("/api/endpoint-tools/invocations/:invocationId/files", async (c) => {
+		const invocationId = c.req.param("invocationId");
+		const endpointId = c.req.header("x-endpoint-id") ?? "";
+		const token = c.req.header("x-endpoint-upload-token") ?? "";
+		const name = c.req.query("name") ?? "";
+		const mimeType = c.req.header("content-type")?.split(";", 1)[0]?.trim() ?? "";
+		if (Number(c.req.header("content-length") ?? 0) > ENDPOINT_UPLOAD_MAX_BYTES) return c.json({
+			ok: false,
+			error: {
+				code: "RESULT_TOO_LARGE",
+				message: "Uploaded file is too large"
+			}
+		}, 413);
+		try {
+			const bytes = await readBoundedBody(c.req.raw.body, ENDPOINT_UPLOAD_MAX_BYTES);
+			const file = deps.service.endpointTools.uploads.upload({
+				invocationId,
+				endpointId,
+				token,
+				name,
+				mimeType,
+				bytes
+			});
+			return c.json({
+				ok: true,
+				payload: {
+					type: "file",
+					fileId: file.fileId,
+					name: file.name,
+					mimeType: file.mimeType,
+					size: file.size,
+					sha256: file.sha256
+				}
+			}, 201);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return c.json({
+				ok: false,
+				error: {
+					code: error instanceof EndpointUploadError ? "INVALID_UPLOAD_GRANT" : "UPLOAD_FAILED",
+					message
+				}
+			}, 400);
+		}
+	});
+	authenticated.get("/api/endpoint-tools/files/:fileId", (c) => {
+		const file = deps.service.endpointTools.uploads.getFile(c.req.param("fileId"));
+		const bytes = file && deps.service.endpointTools.uploads.readFile(file.fileId);
+		if (!file || !bytes) return c.json({
+			ok: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Endpoint file not found"
+			}
+		}, 404);
+		c.header("Content-Type", file.mimeType);
+		c.header("Content-Length", String(file.size));
+		c.header("Content-Disposition", `attachment; filename*=UTF-8''${encodeURIComponent(file.name)}`);
+		const body = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+		return c.body(body);
+	});
+}
+//#endregion
+export { registerEndpointToolRoutes };

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

@@ -3,15 +3,17 @@ import { registerAgentStreamRoutes } from "./agent-stream.js";
 import { registerDiscussionRoutes } from "./discussions.js";
 import { registerSessionsRoutes } from "./sessions.js";
 import { registerStatusRoutes } from "./status.js";
-import { registerMemoryRoutes } from "./memory.js";
 import { registerProjectsRoutes } from "./projects.js";
 import { registerProjectSkillRoutes } from "./project-skills.js";
 import { registerSearchRoutes } from "./search.js";
 import { registerMobileRoutes } from "./mobile.js";
 import { registerInteractionStateRoutes } from "./interaction-state.js";
 import { registerComposerHistoryRoutes } from "./composer-history.js";
+import { registerEndpointToolRoutes } from "./endpoint-tools.js";
+import { registerRealtimeRoutes } from "./realtime.js";
 import { registerLocalAppsRoutes } from "./local-apps.js";
 import { registerWorkDiscoveryRoutes } from "./work-discovery.js";
+import { registerUnderstandingSourceRoutes } from "./understanding-sources.js";
 import { registerTaskRoutes } from "./tasks.js";
 import { registerProactiveRoutes } from "./proactive.js";
 import { mountAppLazyRoutePrefixes, registerAuthenticatedLazyRouteFallback } from "./lazy-fallback.js";
@@ -20,19 +22,21 @@ function registerCoreAuthenticatedRoutes(authenticated, deps) {
 	registerStatusRoutes(authenticated, deps);
 	registerAgentStreamRoutes(authenticated, deps);
 	registerSessionsRoutes(authenticated, deps);
-	registerMemoryRoutes(authenticated, deps);
 	registerActivityRoutes(authenticated, deps);
 	registerDiscussionRoutes(authenticated, deps);
 	registerProjectsRoutes(authenticated, deps);
 	registerProjectSkillRoutes(authenticated, deps);
 	registerLocalAppsRoutes(authenticated, deps);
 	registerWorkDiscoveryRoutes(authenticated, deps);
+	registerUnderstandingSourceRoutes(authenticated, deps);
 	registerTaskRoutes(authenticated, deps);
 	registerProactiveRoutes(authenticated, deps);
 	registerSearchRoutes(authenticated, deps);
 	registerMobileRoutes(authenticated, deps);
 	registerInteractionStateRoutes(authenticated, deps);
 	registerComposerHistoryRoutes(authenticated, deps);
+	registerEndpointToolRoutes(authenticated, deps);
+	registerRealtimeRoutes(authenticated, deps);
 }
 function registerAuthenticatedRoutes(app, authenticated, deps) {
 	registerCoreAuthenticatedRoutes(authenticated, deps);

package/dist/src/gateway/hono/routes/lazy-bundles.js

@@ -94,11 +94,7 @@ const AUTHENTICATED_LAZY_ROUTE_BUNDLES = [
 	},
 	{
 		id: "agents",
-		match: (path) => startsWithAny(path, [
-			"/api/agents",
-			"/api/user-profile",
-			"/api/voice/models"
-		]),
+		match: (path) => startsWithAny(path, ["/api/agents", "/api/voice/models"]),
 		load: async () => {
 			const { registerAgentsRoutes } = await import("./agents.js");
 			return { register: registerAgentsRoutes };

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

@@ -131,10 +131,6 @@ function registerLogsRoutes(authenticated, _deps) {
 		const { getLogLevel } = await import("../../../utils/logger.js");
 		return c.json({ level: getLogLevel() });
 	});
-	authenticated.get("/api/logs/stream", async (c) => {
-		const { createLogSSEHandler } = await import("../../../utils/logger/log-stream.js");
-		return createLogSSEHandler()(c);
-	});
 }
 //#endregion
 export { registerLogsRoutes };

package/dist/src/gateway/hono/routes/public-gateway.js

@@ -110,10 +110,10 @@ function registerPublicGatewayRoutes(app, service) {
 				"POST /api/sessions/:sessionKey/inputs",
 				"GET  /api/sessions/:sessionKey/input-state",
 				"PATCH/DELETE /api/sessions/:sessionKey/inputs/:inputId",
-				"POST /api/agent/resume          (SSE stream)",
 				"POST /api/agent/abort",
 				"POST /api/send",
-				"GET  /api/events          (SSE stream)",
+				"POST /api/realtime/tickets",
+				"WS   /api/realtime/v1/ws",
 				"GET  /api/channels/catalog",
 				"GET  /api/channels/status",
 				"POST /api/channels/:channelId/actions/:actionId",

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

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

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

@@ -0,0 +1,35 @@
+import { realtimeClientKindSchema } from "../../../../packages/realtime-protocol/src/index.js";
+import { z } from "zod";
+//#region src/gateway/hono/routes/realtime.ts
+const ticketRequestSchema = z.strictObject({
+	clientId: z.string().min(1).max(160),
+	clientKind: realtimeClientKindSchema
+});
+function registerRealtimeRoutes(authenticated, deps) {
+	authenticated.post("/api/realtime/tickets", async (c) => {
+		const parsed = ticketRequestSchema.safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success) return c.json({
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: "Invalid realtime ticket request"
+			}
+		}, 400);
+		try {
+			return c.json({
+				ok: true,
+				payload: deps.service.realtime.tickets.issue(parsed.data.clientId, parsed.data.clientKind)
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: {
+					code: "TICKET_LIMIT",
+					message: error instanceof Error ? error.message : "Ticket issue failed"
+				}
+			}, 503);
+		}
+	});
+}
+//#endregion
+export { registerRealtimeRoutes };

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

@@ -34,7 +34,6 @@ function buildEvalRuntimeIdentity(service, agentId) {
 	const models = asRecord(manifest.models);
 	const tools = asRecord(manifest.tools);
 	const skills = manifest.skills ?? [];
-	const codeIntelligence = config.codeIntelligence;
 	return {
 		ok: true,
 		payload: {
@@ -48,12 +47,6 @@ function buildEvalRuntimeIdentity(service, agentId) {
 			systemPromptConfigHash: contentHash(manifest.systemPrompt ?? null),
 			toolPolicyHash: contentHash(tools),
 			skillPolicyHash: contentHash(skills),
-			codeIntelligence: {
-				enabled: codeIntelligence?.enabled === true,
-				configuredForAgent: codeIntelligence?.agentIds?.includes(agentId) === true,
-				indexMode: codeIntelligence?.indexMode ?? null,
-				configHash: contentHash(codeIntelligence ?? null)
-			},
 			presetChain: effective.data.sources
 		}
 	};

package/dist/src/gateway/hono/routes/understanding-sources.d.ts

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

package/dist/src/gateway/hono/routes/understanding-sources.js

@@ -0,0 +1,203 @@
+import { deleteUnderstanding, listUnderstandingEvidence, listUnderstandings } from "../../../storage/sqlite/user-context-repository.js";
+import { getConnectorAccount } from "../../../storage/sqlite/connector-account-repository.js";
+import "../../../storage/sqlite/index.js";
+import { getUnderstandingSourceGrant, listUnderstandingSourceGrants, listUserFocuses, revokeUnderstandingSourceGrant, setUserFocusStatus } from "../../../user-context/sources/repository.js";
+import { getWorkDiscoveryService } from "./work-discovery.js";
+import { listUnderstandingSourceDefinitions } from "../../../user-context/sources/catalog.js";
+//#region src/gateway/hono/routes/understanding-sources.ts
+function stringField(body, field) {
+	if (!body || typeof body !== "object") return "";
+	const value = body[field];
+	return typeof value === "string" ? value.trim() : "";
+}
+function decisionsFrom(body) {
+	return (body && typeof body === "object" && Array.isArray(body.decisions) ? body.decisions : []).flatMap((value) => {
+		if (!value || typeof value !== "object") return [];
+		const item = value;
+		const understandingId = typeof item.understandingId === "string" ? item.understandingId.trim() : "";
+		const status = item.status === "accepted" || item.status === "edited" || item.status === "rejected" ? item.status : null;
+		if (!understandingId || !status) return [];
+		return [{
+			understandingId,
+			status,
+			...typeof item.statement === "string" ? { statement: item.statement } : {}
+		}];
+	}).slice(0, 20);
+}
+function registerUnderstandingSourceRoutes(authenticated, deps) {
+	const service = getWorkDiscoveryService(deps);
+	const limited = deps.strictRateLimitMiddleware;
+	authenticated.get("/api/understanding/sources/catalog", (c) => {
+		const requested = c.req.query("platform");
+		const platform = requested === "darwin" || requested === "win32" || requested === "linux" ? requested : process.platform;
+		return c.json({
+			ok: true,
+			sources: listUnderstandingSourceDefinitions(platform)
+		});
+	});
+	authenticated.get("/api/understanding/sources/grants", (c) => c.json({
+		ok: true,
+		grants: listUnderstandingSourceGrants({ includeRevoked: c.req.query("includeRevoked") === "true" })
+	}));
+	authenticated.delete("/api/understanding/sources/grants/:grantId", limited, (c) => {
+		const current = getUnderstandingSourceGrant(c.req.param("grantId"));
+		const accountId = typeof current?.config.accountId === "string" ? current.config.accountId : void 0;
+		const connectionId = accountId ? getConnectorAccount(accountId)?.currentConnectionId : void 0;
+		if (connectionId) deps.service.setConnectorLearningPaused(connectionId, true);
+		const grant = revokeUnderstandingSourceGrant(c.req.param("grantId"));
+		if (grant && c.req.query("deleteDerived") === "true") {
+			const activeGrantIds = new Set(listUnderstandingSourceGrants().map((item) => item.id));
+			for (const understanding of listUnderstandings()) {
+				const grantEvidence = listUnderstandingEvidence(understanding.id).map((evidence) => /^understanding-source-grant:([^:]+):/.exec(evidence.sourceRef)?.[1]).filter((id) => Boolean(id));
+				if (grantEvidence.includes(grant.id) && !grantEvidence.some((id) => id !== grant.id && activeGrantIds.has(id))) deleteUnderstanding(understanding.id);
+			}
+		}
+		return grant ? c.json({
+			ok: true,
+			grant
+		}) : c.json({
+			ok: false,
+			error: "Source grant not found"
+		}, 404);
+	});
+	authenticated.post("/api/understanding/sources/grants/:grantId/refresh", limited, async (c) => {
+		const grant = getUnderstandingSourceGrant(c.req.param("grantId"));
+		if (!grant || grant.status !== "active") return c.json({
+			ok: false,
+			error: "Active source grant not found"
+		}, 404);
+		try {
+			if (grant.adapterId === "local-work-folders") {
+				const result = await service.refreshDirectorySourceIfChanged({
+					id: grant.id,
+					idempotencyKey: crypto.randomUUID()
+				});
+				return c.json({
+					ok: true,
+					result
+				}, result.changed ? 202 : 200);
+			}
+			const accountId = typeof grant.config.accountId === "string" ? grant.config.accountId : "";
+			const connectionId = accountId ? getConnectorAccount(accountId)?.currentConnectionId : void 0;
+			if (connectionId) {
+				const job = deps.service.requestConnectorLearning(connectionId, {
+					mode: "incremental",
+					reason: "manual"
+				});
+				return job ? c.json({
+					ok: true,
+					job
+				}, 202) : c.json({
+					ok: false,
+					error: "Source does not support learning"
+				}, 409);
+			}
+			return c.json({
+				ok: false,
+				error: "This source is collected from the desktop app"
+			}, 409);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.get("/api/understanding/sources/work-folders", (c) => c.json({
+		ok: true,
+		sources: service.listDirectorySources()
+	}));
+	authenticated.post("/api/understanding/sources/work-folders", limited, async (c) => {
+		const rootPath = stringField(await c.req.json().catch(() => null), "rootPath");
+		if (!rootPath) return c.json({
+			ok: false,
+			error: "Missing rootPath"
+		}, 400);
+		try {
+			return c.json({
+				ok: true,
+				source: await service.grantDirectorySource(rootPath)
+			}, 201);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.post("/api/understanding/sources/work-folders/:grantId/runs", limited, async (c) => {
+		try {
+			const run = await service.rescanDirectorySource({
+				id: c.req.param("grantId"),
+				idempotencyKey: crypto.randomUUID()
+			});
+			return c.json({
+				ok: true,
+				run
+			}, 202);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.post("/api/understanding/bootstrap", limited, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		const items = body && typeof body === "object" && Array.isArray(body.items) ? body.items.slice(0, 150) : [];
+		if (!items.length) return c.json({
+			ok: false,
+			error: "No understanding source items were provided"
+		}, 400);
+		try {
+			const result = await service.importUnderstandingSources(items, c.req.raw.signal, stringField(body, "workDiscoveryRunId") || void 0);
+			return c.json({
+				ok: true,
+				...result
+			}, 201);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 400);
+		}
+	});
+	authenticated.post("/api/understanding/review", limited, async (c) => {
+		const decisions = decisionsFrom(await c.req.json().catch(() => null));
+		if (!decisions.length) return c.json({
+			ok: false,
+			error: "At least one valid decision is required"
+		}, 400);
+		return c.json({
+			ok: true,
+			decisions: service.updateUnderstandingSourceProfile({ decisions })
+		});
+	});
+	authenticated.get("/api/understanding/focuses", (c) => c.json({
+		ok: true,
+		focuses: listUserFocuses()
+	}));
+	authenticated.patch("/api/understanding/focuses/:focusId", limited, async (c) => {
+		const requested = stringField(await c.req.json().catch(() => null), "status");
+		if (!new Set([
+			"candidate",
+			"active",
+			"paused",
+			"completed",
+			"rejected"
+		]).has(requested)) return c.json({
+			ok: false,
+			error: "Invalid focus status"
+		}, 400);
+		const focus = setUserFocusStatus(c.req.param("focusId"), requested);
+		return focus ? c.json({
+			ok: true,
+			focus
+		}) : c.json({
+			ok: false,
+			error: "Focus not found"
+		}, 404);
+	});
+}
+//#endregion
+export { registerUnderstandingSourceRoutes };

package/dist/src/gateway/hono/routes/work-discovery.d.ts

@@ -1,3 +1,5 @@
 import type { Hono } from 'hono';
+import { WorkDiscoveryService } from '../../../work-discovery/service.js';
 import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function getWorkDiscoveryService(deps: AuthenticatedRouteDeps): WorkDiscoveryService;
 export declare function registerWorkDiscoveryRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;