@xopcai/xopc 0.0.332 → 0.0.333

package/dist/src/gateway/agent-builtin-tools.d.ts

@@ -277,4 +277,4 @@ export declare const GATEWAY_BUILTIN_TOOLS: readonly [{
         readonly zh: "使用已验证的参数执行选定的外部工具。";
     };
 }];
-export declare const GATEWAY_BUILTIN_TOOL_IDS: ("automation" | "workflow" | "find" | "image" | "knowledge_search" | "knowledge_get" | "knowledge_write" | "user_context_search" | "user_context_get" | "user_context_update" | "web_search" | "web_fetch" | "browser_use" | "grep" | "session_search" | "read_file" | "list_dir" | "write_file" | "apply_patch" | "exec_command" | "update_plan" | "todo" | "clarify" | "xopc_tool_execute" | "computer_use" | "tool_manual" | "web_extract" | "image_generate" | "skills_list" | "skill_view" | "skill_manage" | "skills_marketplace_search" | "session_status" | "send_message" | "send_media" | "delegate_task" | "skill_install" | "text_to_speech" | "create_share" | "xopc_tool_search" | "xopc_tool_describe" | "read_media" | "memory_maintenance" | "execute_code" | "create_desktop_pet")[];
+export declare const GATEWAY_BUILTIN_TOOL_IDS: ("automation" | "workflow" | "find" | "image" | "knowledge_search" | "knowledge_get" | "knowledge_write" | "user_context_search" | "user_context_get" | "user_context_update" | "web_search" | "web_fetch" | "browser_use" | "grep" | "session_search" | "read_file" | "list_dir" | "write_file" | "apply_patch" | "exec_command" | "update_plan" | "todo" | "clarify" | "xopc_tool_execute" | "web_extract" | "image_generate" | "skills_list" | "skill_view" | "skill_manage" | "skills_marketplace_search" | "xopc_tool_search" | "xopc_tool_describe" | "send_message" | "send_media" | "read_media" | "create_share" | "session_status" | "memory_maintenance" | "computer_use" | "tool_manual" | "delegate_task" | "skill_install" | "text_to_speech" | "execute_code" | "create_desktop_pet")[];

package/dist/src/gateway/home-intelligence-automation-reconciler.js

@@ -11,7 +11,10 @@ async function reconcileHomeIntelligenceAutomation(automationService) {
 		},
 		safety: { mode: "auto_apply" },
 		conversationMode: "new_session",
-		notificationPolicy: "none",
+		delivery: {
+			notificationPolicy: "none",
+			destinations: []
+		},
 		reliability: { disableAfterConsecutiveFailures: 3 },
 		management: {
 			owner: "home-intelligence",

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

@@ -55,7 +55,7 @@ function registerCapabilityRoutes(authenticated, deps) {
 		try {
 			const { instance, plan } = await persistConfigMutation({
 				config,
-				mutate: () => installStoreConnector(config, c.req.param("name"), input, optionalVersion(body)),
+				mutate: () => installStoreConnector(config, c.req.param("name"), input, optionalVersion(body), typeof body.reviewHash === "string" ? body.reviewHash : void 0),
 				save: () => service.saveConfig(config)
 			});
 			return c.json({

package/dist/src/gateway/hono/routes/connection-waits.js

@@ -6,9 +6,9 @@ const actionSchema = z.object({
 	expectedVersion: z.number().int().positive(),
 	idempotencyKey: z.string().min(1).max(200),
 	action: z.enum([
+		"install_complete",
 		"connect",
 		"check",
-		"continue",
 		"skip",
 		"cancel",
 		"select_account",
@@ -19,7 +19,8 @@ const actionSchema = z.object({
 	candidateRef: z.string().optional(),
 	needKey: z.string().optional(),
 	accountId: z.string().optional(),
-	callbackUrl: z.string().max(16384).optional()
+	callbackUrl: z.string().max(16384).optional(),
+	instanceId: z.string().optional()
 }).strict();
 function registerConnectionWaitRoutes(app, { service, strictRateLimitMiddleware }) {
 	app.get("/api/sessions/:conversationId/connection-wait", (c) => {

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

@@ -238,7 +238,12 @@ const AUTHENTICATED_LAZY_ROUTE_BUNDLES = [
 	},
 	{
 		id: "automations",
-		match: (path) => startsWithAny(path, ["/api/automations", "/api/automation-runs"]),
+		match: (path) => startsWithAny(path, [
+			"/api/automations",
+			"/api/automation-runs",
+			"/api/automation-events",
+			"/api/automation-deliveries"
+		]),
 		load: async () => {
 			const { registerAutomationRoutes } = await import("../../../automations/api/routes.js");
 			return { register: registerAutomationRoutes };
@@ -284,6 +289,14 @@ const AUTHENTICATED_LAZY_ROUTE_BUNDLES = [
 			return { register: registerLogsRoutes };
 		}
 	},
+	{
+		id: "usage",
+		match: (path) => startsWithAny(path, ["/api/usage"]),
+		load: async () => {
+			const { registerUsageRoutes } = await import("./usage.js");
+			return { register: registerUsageRoutes };
+		}
+	},
 	{
 		id: "shares",
 		match: (path) => startsWithAny(path, ["/api/shares", "/api/hosted-publications"]) || /^\/api\/notes\/[^/]+\/hosted-publications(?:\/.*)?$/.test(path) || /^\/api\/sessions\/[^/]+\/(?:share-preview|shares|hosted-shares)(?:\/.*)?$/.test(path),

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

@@ -1,10 +1,11 @@
 import { PACKAGE_VERSION, init_package_version } from "../../../package-version.js";
 import { claimConnectorWebhookDelivery, completeConnectorWebhookDelivery, releaseConnectorWebhookDelivery } from "../../../storage/sqlite/connector-repository.js";
 import { init_sqlite } from "../../../storage/sqlite/index.js";
+import { resolveAutomationWebhookSecret } from "../../../automations/webhook-secrets.js";
 import { composioLogoResponse } from "../../../connectors/composio-logo.js";
 import { appendComposioTriggerEvent, applyComposioConnectionLifecycleEvent, normalizeComposioTriggerPayload, verifyComposioWebhook } from "../../../connectors/composio-triggers.js";
 import { serveStaticFile } from "../lib/static-ui.js";
-import { createHash } from "node:crypto";
+import { createHash, timingSafeEqual } from "node:crypto";
 //#region src/gateway/hono/routes/public-gateway.ts
 init_package_version();
 init_sqlite();
@@ -19,6 +20,9 @@ const PUBLIC_UI_ROOT_ASSETS = [
 	"pwa-512x512.png",
 	"site.webmanifest"
 ];
+function secretsEqual(actual, expected) {
+	return timingSafeEqual(createHash("sha256").update(actual).digest(), createHash("sha256").update(expected).digest());
+}
 function registerPublicGatewayRoutes(app, service) {
 	app.get("/health", (c) => {
 		return c.json(service.getHealth());
@@ -84,9 +88,16 @@ function registerPublicGatewayRoutes(app, service) {
 			if (inactiveConnectionId) service.setConnectorLearningPaused(inactiveConnectionId, true);
 			const event = await appendComposioTriggerEvent(service.currentConfig, archivedPayload);
 			if (normalized.toolkit) service.requestConnectorLearningForToolkit(normalized.toolkit);
-			const runs = await service.automationServiceInstance.triggerEvent({
+			const ingested = service.ingestAutomationEvent({
+				id: `connector:composio:${webhookId}`,
 				type: `connector.${normalized.trigger ?? normalized.type}`,
 				source: normalized.toolkit ? `composio:${normalized.toolkit}` : "composio",
+				subject: {
+					kind: "connector_event",
+					id: webhookId
+				},
+				dedupeKey: webhookId,
+				trust: "connector",
 				payload: {
 					...normalized.data,
 					connectorId: normalized.toolkit ? `composio-${normalized.toolkit}` : "composio",
@@ -98,7 +109,7 @@ function registerPublicGatewayRoutes(app, service) {
 				ok: true,
 				payload: {
 					eventId: event.id,
-					automationRuns: runs.length
+					automationDeliveries: ingested.deliveryCount
 				}
 			});
 		} catch (error) {
@@ -109,6 +120,85 @@ function registerPublicGatewayRoutes(app, service) {
 			}, 500);
 		}
 	});
+	app.post("/api/automation-hooks/:automationId", async (c) => {
+		const automationId = c.req.param("automationId");
+		const automation = await service.automationServiceInstance.get(automationId);
+		if (!automation || !automation.enabled || automation.trigger.kind !== "webhook") return c.json({
+			ok: false,
+			error: "Automation webhook not found."
+		}, 404);
+		const secretId = automation.trigger.secretId?.trim();
+		let expectedSecret;
+		try {
+			expectedSecret = secretId ? resolveAutomationWebhookSecret(secretId) : void 0;
+		} catch {
+			return c.json({
+				ok: false,
+				error: "Automation webhook secrets are misconfigured."
+			}, 503);
+		}
+		if (!expectedSecret) return c.json({
+			ok: false,
+			error: "Automation webhook secret is not configured."
+		}, 503);
+		const authorization = c.req.header("authorization")?.trim() ?? "";
+		const suppliedSecret = authorization.startsWith("Bearer ") ? authorization.slice(7).trim() : c.req.header("x-xopc-webhook-secret")?.trim() ?? "";
+		if (!suppliedSecret || !secretsEqual(suppliedSecret, expectedSecret)) return c.json({
+			ok: false,
+			error: "Invalid automation webhook secret."
+		}, 401);
+		const idempotencyKey = c.req.header("idempotency-key")?.trim();
+		if (!idempotencyKey || idempotencyKey.length > 200) return c.json({
+			ok: false,
+			error: "A valid Idempotency-Key header is required."
+		}, 400);
+		const declaredSize = Number(c.req.header("content-length") ?? 0);
+		if (Number.isFinite(declaredSize) && declaredSize > 256 * 1024) return c.json({
+			ok: false,
+			error: "Webhook payload is too large."
+		}, 413);
+		const rawBody = await c.req.text();
+		if (Buffer.byteLength(rawBody) > 256 * 1024) return c.json({
+			ok: false,
+			error: "Webhook payload is too large."
+		}, 413);
+		let payload;
+		try {
+			const parsed = rawBody ? JSON.parse(rawBody) : {};
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("invalid payload");
+			payload = parsed;
+		} catch {
+			return c.json({
+				ok: false,
+				error: "Webhook payload must be a JSON object."
+			}, 400);
+		}
+		try {
+			const result = service.ingestAutomationEvent({
+				id: `webhook:${automationId}:${idempotencyKey}`,
+				type: "automation.webhook.received",
+				source: `webhook:${automationId}`,
+				subject: {
+					kind: "automation",
+					id: automationId
+				},
+				correlationId: c.req.header("x-correlation-id")?.trim() || void 0,
+				dedupeKey: idempotencyKey,
+				trust: "untrusted_webhook",
+				payload
+			}, { targetAutomationIds: [automationId] });
+			return c.json({
+				ok: true,
+				eventId: result.event.id,
+				duplicate: !result.created
+			}, result.created ? 202 : 200);
+		} catch {
+			return c.json({
+				ok: false,
+				error: "Automation webhook ingestion failed."
+			}, 500);
+		}
+	});
 	app.get("/api", (c) => {
 		return c.json({
 			service: "xopc-gateway",

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

@@ -66,14 +66,22 @@ function registerSceneRoutes(authenticated, deps) {
 			idempotencyKey: c.req.header("Idempotency-Key") ?? randomUUID()
 		});
 	};
-	app.get("/source-providers", (c) => c.json({ providers: deps.scenes.followUps?.sources.list() ?? [] }));
-	app.get("/source-providers/:provider/accounts", (c) => c.json({ accounts: deps.scenes.followUps?.sources.get(c.req.param("provider")).listAccounts?.(principal(c)) ?? [] }));
+	const template = (key, version) => deps.scenes.repository.getTemplate(key, version);
+	const adapterTarget = (key, version) => {
+		const manifest = template(key, version);
+		return manifest.execution.kind === "agent" ? void 0 : {
+			manifest,
+			adapter: deps.scenes.activationAdapters.get(manifest.execution.kind)
+		};
+	};
+	app.get("/source-providers", (c) => c.json({ providers: deps.scenes.sourceProviders.providers() }));
+	app.get("/source-providers/:provider/accounts", (c) => c.json({ accounts: deps.scenes.sourceProviders.get(c.req.param("provider")).listAccounts?.(principal(c)) ?? [] }));
 	app.post("/source-providers/:provider/resolve-link", deps.strictRateLimitMiddleware, async (c) => {
 		const input = z.strictObject({
 			accountId: z.string().min(1).max(200),
 			url: z.string().url().max(2e3)
 		}).parse(await c.req.json());
-		const source = deps.scenes.followUps?.sources.get(c.req.param("provider"));
+		const source = deps.scenes.sourceProviders.get(c.req.param("provider"));
 		if (!source?.resolveLink) return c.json({ error: "source_resolution_unavailable" }, 422);
 		const reference = await source.resolveLink(principal(c), input.accountId, input.url, AbortSignal.any([c.req.raw.signal, AbortSignal.timeout(3e4)]));
 		return c.json({ source: {
@@ -81,48 +89,21 @@ function registerSceneRoutes(authenticated, deps) {
 			reference
 		} });
 	});
-	app.get("/task-follow-ups", (c) => c.json({ items: deps.scenes.followUps?.list(principal(c)) ?? [] }));
-	app.get("/task-follow-ups/projects/:projectId/branches", async (c) => {
-		if (!deps.scenes.followUps) return c.json({ error: "task_follow_up_unavailable" }, 503);
-		return c.json(await deps.scenes.followUps.branches.list(principal(c), c.req.param("projectId")));
+	app.get("/resources/projects/:projectId/branches", async (c) => {
+		const owner = deps.scenes.activationAdapters.list().find((item) => item.listProjectBranches);
+		if (!owner?.listProjectBranches) return c.json({ error: "branch_inventory_unavailable" }, 503);
+		return c.json(await owner.listProjectBranches(principal(c), c.req.param("projectId")));
 	});
-	app.post("/task-follow-ups/branch-links", deps.strictRateLimitMiddleware, async (c) => {
+	app.post("/resources/branch-links", deps.strictRateLimitMiddleware, async (c) => {
 		const input = z.strictObject({
 			projectId: z.string().min(1).max(200),
 			taskId: z.string().uuid(),
 			branchRef: z.string().startsWith("refs/heads/").max(300),
 			expectedSha: z.string().regex(/^[a-f0-9]{40,64}$/)
 		}).parse(await c.req.json());
-		if (!deps.scenes.followUps) return c.json({ error: "task_follow_up_unavailable" }, 503);
-		return c.json(await deps.scenes.followUps.branches.associate(principal(c), input));
-	});
-	app.post("/task-follow-ups/preflight", deps.strictRateLimitMiddleware, async (c) => {
-		if (!deps.scenes.followUps) return c.json({ error: "task_follow_up_unavailable" }, 503);
-		return c.json(await deps.scenes.followUps.preflight(principal(c), await c.req.json()));
-	});
-	app.post("/task-follow-ups", deps.strictRateLimitMiddleware, async (c) => {
-		if (!deps.scenes.followUps) return c.json({ error: "task_follow_up_unavailable" }, 503);
-		return c.json(await deps.scenes.followUps.create(principal(c), await c.req.json()), 201);
-	});
-	app.get("/task-follow-ups/:id", (c) => {
-		if (!deps.scenes.followUps) return c.json({ error: "task_follow_up_unavailable" }, 503);
-		return c.json(deps.scenes.followUps.get(principal(c), c.req.param("id")));
-	});
-	app.patch("/task-follow-ups/:id", deps.strictRateLimitMiddleware, async (c) => {
-		const input = z.union([z.strictObject({
-			expectedRevision: z.number().int().positive(),
-			status: z.enum([
-				"active",
-				"paused",
-				"archived"
-			])
-		}), z.strictObject({
-			expectedRevision: z.number().int().positive(),
-			configuration: z.unknown()
-		})]).parse(await c.req.json());
-		if (!deps.scenes.followUps) return c.json({ error: "task_follow_up_unavailable" }, 503);
-		if ("configuration" in input) return c.json(await deps.scenes.followUps.configure(principal(c), c.req.param("id"), input.expectedRevision, input.configuration));
-		return c.json(await deps.scenes.followUps.transition(principal(c), c.req.param("id"), input.expectedRevision, input.status));
+		const owner = deps.scenes.activationAdapters.list().find((item) => item.associateBranch);
+		if (!owner?.associateBranch) return c.json({ error: "branch_inventory_unavailable" }, 503);
+		return c.json(await owner.associateBranch(principal(c), input));
 	});
 	app.post("/browser/prepare", deps.strictRateLimitMiddleware, (c) => c.json(deps.scenes.browser.prepare()));
 	app.post("/browser/subscriptions", deps.strictRateLimitMiddleware, async (c) => c.json(deps.scenes.browser.register(principal(c), await c.req.json()), 201));
@@ -160,7 +141,14 @@ function registerSceneRoutes(authenticated, deps) {
 		key: c.req.param("key"),
 		version: c.req.param("version")
 	})));
-	app.post("/preflight", deps.strictRateLimitMiddleware, async (c) => c.json(await read(c, "xopc.scenes.preflight", await c.req.json())));
+	app.post("/preflight", deps.strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json();
+		if (typeof body.templateKey === "string" && typeof body.templateVersion === "string") {
+			const target = adapterTarget(body.templateKey, body.templateVersion);
+			if (target) return c.json(await target.adapter.preflight(principal(c), target.manifest, body.configuration));
+		}
+		return c.json(await read(c, "xopc.scenes.preflight", body));
+	});
 	app.get("/activations", async (c) => {
 		return c.json(await read(c, "xopc.scenes.list", {
 			...c.req.query(),
@@ -169,14 +157,42 @@ function registerSceneRoutes(authenticated, deps) {
 	});
 	app.post("/activations", deps.strictRateLimitMiddleware, async (c) => {
 		requestIdentity.parse(c.req.header("Idempotency-Key"));
-		return c.json(await write(c, "xopc.scenes.start", await c.req.json()), 201);
+		const body = await c.req.json();
+		if (typeof body.templateKey === "string" && typeof body.templateVersion === "string") {
+			const target = adapterTarget(body.templateKey, body.templateVersion);
+			if (target) return c.json(await target.adapter.create(principal(c), target.manifest, body.configuration), 201);
+		}
+		return c.json(await write(c, "xopc.scenes.start", body), 201);
 	});
 	app.get("/activations/:id", async (c) => {
 		const { activation } = ProductReadContracts["xopc.scenes.get"].output.parse(await read(c, "xopc.scenes.get", { id: c.req.param("id") }));
-		return c.json({ activation });
+		const manifest = template(activation.templateKey, activation.templateVersion);
+		const activationAdapter = manifest.execution.kind === "agent" ? void 0 : deps.scenes.activationAdapters.get(manifest.execution.kind);
+		return c.json({
+			activation,
+			template: manifest,
+			...activationAdapter ? { details: activationAdapter.get(principal(c), activation.id) } : {}
+		});
 	});
 	app.patch("/activations/:id", deps.strictRateLimitMiddleware, async (c) => {
 		const body = await c.req.json();
+		const activation = deps.scenes.repository.getActivation(principal(c), c.req.param("id"));
+		const manifest = template(activation.templateKey, activation.templateVersion);
+		if (manifest.execution.kind !== "agent") {
+			const input = z.union([z.strictObject({
+				expectedRevision: z.number().int().positive(),
+				status: z.enum([
+					"active",
+					"paused",
+					"archived"
+				])
+			}), z.strictObject({
+				expectedRevision: z.number().int().positive(),
+				configuration: z.unknown()
+			})]).parse(body);
+			const execution = deps.scenes.activationAdapters.get(manifest.execution.kind);
+			return c.json("configuration" in input ? await execution.configure(principal(c), activation.id, input.expectedRevision, input.configuration) : await execution.transition(principal(c), activation.id, input.expectedRevision, input.status));
+		}
 		if (!(typeof body === "object" && body !== null && Object.hasOwn(body, "status"))) return c.json(await write(c, "xopc.scenes.configure", {
 			...body,
 			id: c.req.param("id")

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

@@ -109,6 +109,15 @@ function registerSessionsRoutes(authenticated, deps) {
 			payload: { runs: service.sessions.listActiveRuns() }
 		});
 	});
+	authenticated.get("/api/runtime/quit-impact", async (c) => {
+		const blocked = ensureGatewayReadyForSessions(c, service, "sessions.list");
+		if (blocked) return blocked;
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload: await service.sessions.getQuitImpact()
+		});
+	});
 	authenticated.get("/api/sidebar/chat-list", async (c) => {
 		const blocked = ensureGatewayReadyForSessions(c, service, "sessions.list");
 		if (blocked) return blocked;
@@ -564,6 +573,12 @@ function registerSessionsRoutes(authenticated, deps) {
 			includeContextRows: true
 		});
 		if (!result) return c.json({ error: "Session not found" }, 404);
+		const revision = result.pagination.revision;
+		if (typeof revision === "number") {
+			const etag = `"${result.session.transcriptId ?? key}:${revision}"`;
+			c.header("ETag", etag);
+			if (c.req.header("If-None-Match") === etag) return c.body(null, 304);
+		}
 		return c.json(result);
 	});
 	authenticated.get("/api/sessions/:key/timeline", async (c) => {

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

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

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

@@ -0,0 +1,61 @@
+import { getAiUsageEventView, listAiUsageEvents, listAiUsageTrace, summarizeAiUsage } from "../../../storage/sqlite/ai-usage-repository.js";
+import { z } from "zod";
+import { Hono } from "hono";
+//#region src/gateway/hono/routes/usage.ts
+const MAX_RANGE_MS = 366 * 24 * 60 * 60 * 1e3;
+const DEFAULT_RANGE_MS = 10080 * 60 * 1e3;
+const filtersSchema = z.object({
+	from: z.coerce.number().int().nonnegative().optional(),
+	to: z.coerce.number().int().positive().optional(),
+	category: z.string().trim().min(1).max(80).optional(),
+	provider: z.string().trim().min(1).max(120).optional(),
+	model: z.string().trim().min(1).max(240).optional(),
+	agentId: z.string().trim().min(1).max(200).optional(),
+	conversationId: z.string().trim().min(1).max(200).optional()
+});
+function parseFilters(value) {
+	const parsed = filtersSchema.parse(value);
+	const to = parsed.to ?? Date.now() + 1;
+	const from = parsed.from ?? to - DEFAULT_RANGE_MS;
+	if (from >= to || to - from > MAX_RANGE_MS) throw new Error("invalid_usage_range");
+	return {
+		...parsed,
+		from,
+		to
+	};
+}
+function parseCursor(value) {
+	if (!value) return void 0;
+	const separator = value.indexOf(":");
+	const startedAt = Number(value.slice(0, separator));
+	const id = value.slice(separator + 1);
+	if (separator < 1 || !Number.isSafeInteger(startedAt) || startedAt < 0 || !id) throw new Error("invalid_usage_cursor");
+	return {
+		startedAt,
+		id
+	};
+}
+function registerUsageRoutes(authenticated, _deps) {
+	const app = new Hono();
+	app.onError((error, c) => {
+		if (error instanceof z.ZodError || error.message.startsWith("invalid_usage_")) return c.json({ error: "invalid_usage_query" }, 400);
+		throw error;
+	});
+	app.get("/summary", (c) => c.json(summarizeAiUsage(parseFilters(c.req.query()))));
+	app.get("/events", (c) => {
+		const limit = z.coerce.number().int().min(1).max(200).optional().parse(c.req.query("limit"));
+		return c.json(listAiUsageEvents({
+			...parseFilters(c.req.query()),
+			limit,
+			before: parseCursor(c.req.query("cursor"))
+		}));
+	});
+	app.get("/events/:id", (c) => {
+		const event = getAiUsageEventView(c.req.param("id"));
+		return event ? c.json({ event }) : c.json({ error: "usage_event_not_found" }, 404);
+	});
+	app.get("/traces/:traceId", (c) => c.json({ events: listAiUsageTrace(c.req.param("traceId")) }));
+	authenticated.route("/api/usage", app);
+}
+//#endregion
+export { registerUsageRoutes };

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

@@ -101,7 +101,7 @@ async function refineTranscript(raw, config, signal) {
 			maxTokens: Math.min(raw.length * 3, 4096),
 			temperature: .2,
 			signal: mergedSignal
-		});
+		}, void 0, { operation: "voice.select" });
 		let out = "";
 		if (Array.isArray(result.content)) {
 			for (const c of result.content) if (c && typeof c === "object" && c.type === "text") out += String(c.text || "");

package/dist/src/gateway/memory-maintenance-automation-reconciler.js

@@ -42,7 +42,10 @@ async function reconcileMemoryMaintenanceAutomations(input) {
 			action,
 			safety: { mode: "auto_apply" },
 			conversationMode: "continuous",
-			notificationPolicy: "none",
+			delivery: {
+				notificationPolicy: "none",
+				destinations: []
+			},
 			reliability: { disableAfterConsecutiveFailures: 3 },
 			management: {
 				owner: "memory-maintenance",
@@ -65,7 +68,7 @@ async function reconcileMemoryMaintenanceAutomations(input) {
 			enabled: current.enabled,
 			trigger: current.trigger
 		} : next;
-		if (current.name !== reconciled.name || current.description !== next.description || current.enabled !== reconciled.enabled || JSON.stringify(current.trigger) !== JSON.stringify(reconciled.trigger) || JSON.stringify(current.action) !== JSON.stringify(action) || current.safety?.mode !== "auto_apply" || current.notificationPolicy !== "none" || JSON.stringify(current.management) !== JSON.stringify(next.management)) {
+		if (current.name !== reconciled.name || current.description !== next.description || current.enabled !== reconciled.enabled || JSON.stringify(current.trigger) !== JSON.stringify(reconciled.trigger) || JSON.stringify(current.action) !== JSON.stringify(action) || current.safety?.mode !== "auto_apply" || current.delivery.notificationPolicy !== "none" || JSON.stringify(current.management) !== JSON.stringify(next.management)) {
 			await input.automationService.update(schedule.automationId, reconciled);
 			result.updated += 1;
 		}

package/dist/src/gateway/scenes/host.js

@@ -13,6 +13,7 @@ import { SceneMailObservationService } from "../../scenes/mailObservations.js";
 import { maintainSceneStorage } from "../../scenes/maintenance.js";
 import { SceneMetrics } from "../../scenes/metrics.js";
 import { resolveSceneModelRef } from "../../scenes/model.js";
+import { SceneCapabilityRegistry } from "../../scenes/registry.js";
 import { SceneResultNotifications } from "../../scenes/resultNotifications.js";
 import { SceneRuntime } from "../../scenes/runtime.js";
 import { familyPlanTemplate, mailFollowUpTemplate } from "../../scenes/templates.js";
@@ -20,8 +21,8 @@ import { SceneUserNotesProvider } from "../../scenes/userNotes.js";
 import { createSceneBrowserDispatcher } from "./browserNotifications.js";
 import { GatewaySceneMailContext } from "./mailContext.js";
 import { SlackThreadSource } from "./slackThreadSource.js";
-import { TaskSourceRegistry } from "../../scenes/taskFollowUp/contracts.js";
-import { TaskFollowUpService } from "../../scenes/taskFollowUp/service.js";
+import { SceneSourceRegistry, decisionLogTemplate, taskFollowUpTemplate } from "../../scenes/taskFollowUp/contracts.js";
+import { SceneTaskExecutionService } from "../../scenes/taskFollowUp/service.js";
 //#region src/gateway/scenes/host.ts
 init_providers();
 init_scenes_schema();
@@ -47,30 +48,39 @@ var GatewaySceneHost = class {
 		const repository = new SceneRepository(db);
 		repository.installTemplate(mailFollowUpTemplate);
 		repository.installTemplate(familyPlanTemplate);
+		repository.installTemplate(taskFollowUpTemplate);
+		repository.installTemplate(decisionLogTemplate);
 		const mail = input.mail ?? new GatewaySceneMailContext(db, clock);
-		const providers = [mail, new SceneUserNotesProvider(db, clock)];
+		const providers = new SceneCapabilityRegistry([mail, new SceneUserNotesProvider(db, clock)]);
 		const authorize = (activation) => {
 			if (activation.ownerId !== input.principal.ownerId || activation.workspaceId !== input.principal.workspaceId) return {
 				accountIds: [],
 				contextProviders: [],
 				effectHandlers: []
 			};
-			const accountIds = mail.authorizedAccounts(activation);
+			const grants = providers.list().flatMap((provider) => {
+				const accountIds = provider.authorization?.(activation) ?? null;
+				return accountIds === null ? [] : [{
+					id: provider.id,
+					accountIds
+				}];
+			});
 			return {
-				accountIds,
-				contextProviders: [...activation.scope.kind === "personal" ? ["user_notes"] : [], ...accountIds.length ? ["mail"] : []],
+				accountIds: [...new Set(grants.flatMap((grant) => grant.accountIds))],
+				contextProviders: grants.map((grant) => grant.id),
 				effectHandlers: []
 			};
 		};
 		const grant = async (activation) => authorize(activation);
 		const executor = input.executor ?? new SceneAgentExecutor(() => resolveModel(resolveSceneModelRef(input.config())));
-		const slackThread = new SlackThreadSource(db);
-		const followUps = new TaskFollowUpService(db, {
+		const sourceProviders = new SceneSourceRegistry([new SlackThreadSource(db)]);
+		const activationAdapters = new SceneCapabilityRegistry([new SceneTaskExecutionService(db, {
 			config: input.config,
-			sources: new TaskSourceRegistry([slackThread])
-		});
+			sources: sourceProviders
+		})]);
 		this.http = {
-			followUps,
+			activationAdapters,
+			sourceProviders,
 			repository,
 			mail,
 			mailDiscovery: mail instanceof GatewaySceneMailContext ? mail : void 0,
@@ -99,7 +109,10 @@ var GatewaySceneHost = class {
 		assertSceneStorageReady(this.db);
 		this.runtime.start();
 		const poll = () => {
-			this.http.followUps?.tick().catch((err) => log.error({ err }, "Task follow-up check failed"));
+			for (const adapter of this.http.activationAdapters.list()) adapter.tick().catch((err) => log.error({
+				err,
+				adapter: adapter.id
+			}, "Scene adapter check failed"));
 			try {
 				if (this.clock() >= this.nextMaintenanceAt) {
 					maintainSceneStorage(this.db, this.clock());
@@ -118,7 +131,7 @@ var GatewaySceneHost = class {
 	tick() {
 		if (this.stopped) return Promise.reject(/* @__PURE__ */ new Error("Scene host stopped"));
 		if (this.active) return this.active;
-		const work = Promise.all([this.runtime.tick(), this.http.followUps?.tick()]).then(() => {
+		const work = Promise.all([this.runtime.tick(), ...this.http.activationAdapters.list().map((adapter) => adapter.tick())]).then(() => {
 			if (!this.stopped) this.notifications.drain();
 		});
 		this.active = work.finally(() => {
@@ -131,7 +144,7 @@ var GatewaySceneHost = class {
 		this.stopped = true;
 		if (this.timer) clearInterval(this.timer);
 		this.timer = void 0;
-		await this.http.followUps?.stop();
+		await Promise.all(this.http.activationAdapters.list().map((adapter) => adapter.stop()));
 		await this.runtime.stop();
 		await this.browserDispatcher.stop();
 		await this.active?.catch(() => void 0);

package/dist/src/gateway/scenes/slackThreadSource.d.ts

@@ -2,7 +2,7 @@ import type { DatabaseSync } from 'node:sqlite';
 import { z } from 'zod';
 import { ComposioSessionsAdapter } from '../../connectors/composio-sessions.js';
 import { type ScenePrincipal } from '../../scenes/contracts.js';
-import type { TaskSourceAdapter, SourceSnapshot } from '../../scenes/taskFollowUp/contracts.js';
+import type { SceneSourceAdapter, SourceSnapshot } from '../../scenes/taskFollowUp/contracts.js';
 export declare const slackThreadSchema: z.ZodObject<{
     accountId: z.ZodString;
     teamId: z.ZodString;
@@ -16,7 +16,7 @@ export declare function parseSlackThreadUrl(value: string): {
     threadTs: string;
 };
 /** Read-only connector adapter. Account policy is rechecked before and after every page. */
-export declare class SlackThreadSource implements TaskSourceAdapter {
+export declare class SlackThreadSource implements SceneSourceAdapter {
     private readonly db;
     private readonly adapter;
     readonly id = "slack_thread";

package/dist/src/gateway/security/gateway-scopes.js

@@ -22,6 +22,7 @@ function requiredGatewayScope(method, path) {
 	if (method === "GET" && path === "/api/connectors/approvals") return "sessions.read";
 	if (method === "POST" && path === "/api/connectors/approvals/respond") return "sessions.write";
 	if (path === "/api/agent" || path.startsWith("/api/agent/")) return "agents.run";
+	if (path.startsWith("/api/usage")) return "gateway.admin";
 	if (path.startsWith("/api/agents") || path.startsWith("/api/models")) return methodScope(method, "agents.read", "gateway.admin");
 	if (path.startsWith("/api/sessions") || path.startsWith("/api/side-chats")) return methodScope(method, "sessions.read", "sessions.write");
 	if (path.startsWith("/api/tasks")) return methodScope(method, "tasks.read", "tasks.write");

package/dist/src/gateway/service/active-execution.d.ts

@@ -0,0 +1,19 @@
+import type { TurnOrigin } from '@xopcai/endpoint-tools-protocol';
+export type ActiveExecutionKind = 'chat' | 'side-chat' | 'task' | 'workflow' | 'automation';
+export type ActiveExecutionInitiator = 'user' | 'background';
+export type ActiveExecution = {
+    conversationId: string;
+    runId: string;
+    kind: ActiveExecutionKind;
+    initiator: ActiveExecutionInitiator;
+    phase: 'running';
+    startedAt: number;
+};
+export declare function describeActiveExecution(input: {
+    conversationId: string;
+    runId: string;
+    origin: TurnOrigin;
+    taskRunId?: string;
+    kind?: ActiveExecutionKind;
+    startedAt?: number;
+}): ActiveExecution;