@xopcai/xopc 0.0.331 → 0.0.333

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/session-input-handler.js

@@ -4,9 +4,9 @@ import { parseUserTurnDocument, userTurnDocumentRefIds } from "../../../../packa
 import { browserPageContextsInputSchema } from "../../../../packages/gateway-contract/src/browser-page-context.js";
 import { init_src } from "../../../../packages/gateway-contract/src/index.js";
 import { endpointTurnClaimSchema, init_src as init_src$1 } from "../../../../packages/endpoint-tools-protocol/src/index.js";
+import { init_providers, resolveModel } from "../../../providers/index.js";
 import { CapabilityError } from "../../../capabilities/runtime/errors.js";
 import "../../../capabilities/runtime/dispatcher.js";
-import { init_providers, resolveModel } from "../../../providers/index.js";
 import { validateWebchatAttachments, validateWebchatContent } from "../../chat-limits.js";
 import { isTaskDestructiveCommand } from "../../../session/reset-triggers.js";
 import { parseSlashCommand } from "../../../chat-commands/command-parse.js";

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/tasks.js

@@ -5,9 +5,9 @@ import { init_src } from "../../../../packages/gateway-contract/src/index.js";
 import { enqueueTaskChangedEvent, init_task_change_events } from "../../../tasks/task-change-events.js";
 import { TaskRepository, init_task_repository } from "../../../tasks/task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "../../../tasks/task-run-repository.js";
+import { TaskConversationRepository } from "../../../tasks/task-conversation-repository.js";
 import { CapabilityError } from "../../../capabilities/runtime/errors.js";
 import "../../../capabilities/runtime/dispatcher.js";
-import { TaskConversationRepository } from "../../../tasks/task-conversation-repository.js";
 import { TaskContextMutationOutputSchema } from "../../../tasks/capabilities/relations.js";
 import { TaskDeleteOutputSchema } from "../../../tasks/capabilities/management.js";
 import { TaskMutationOutputSchema } from "../../../tasks/capabilities/write.js";

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

@@ -32,13 +32,18 @@ function registerUpdateRoutes(authenticated, deps) {
 		});
 	});
 	authenticated.post("/api/update/check", strictRateLimitMiddleware, async (c) => {
-		await runGatewayUpdateCheck({
+		const checkResult = await runGatewayUpdateCheck({
 			config: loadConfig(service.getHealth().configPath),
 			force: true,
 			onUpdateAvailableChange: (update) => {
 				service.emit("update.available", update);
 			}
 		});
+		if (checkResult.ok === false) return c.json({
+			ok: false,
+			error: "update-check-failed",
+			message: `Could not check npm for updates: ${checkResult.error}`
+		}, 502);
 		const result = getUpdateAvailable();
 		return c.json({
 			ok: true,

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/image-generation-setup.js

@@ -1,11 +1,11 @@
 import { normalizeAgentId } from "../agent-catalog/id.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
-import { init_agent_scope } from "../agent/agent-scope.js";
-import { AgentCatalogService } from "../agent-catalog/service.js";
 import { ConfigSchema, init_schema } from "../config/schema.js";
+import { init_agent_scope } from "../agent/agent-scope.js";
 import { resolveEffectiveAgentConfigForAgent } from "../config/agent-profile.js";
 import { fetchWithTimeoutGuarded } from "../media-shared/http/provider-http.js";
 import "../media-shared/http/index.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
 import { getImageGenerationProvider, listImageGenerationProvidersSummary } from "../agent/image/generation/provider-registry.js";
 //#region src/gateway/image-generation-setup.ts
 init_repository();

package/dist/src/gateway/lock.js

@@ -1,8 +1,8 @@
 import path from "node:path";
 import fs from "node:fs";
 import { createHash } from "node:crypto";
-import fs$1 from "node:fs/promises";
 import net from "node:net";
+import fs$1 from "node:fs/promises";
 import { homedir } from "os";
 //#region src/gateway/lock.ts
 /**

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

@@ -1,9 +1,6 @@
-import { normalizeAgentId } from "../agent-catalog/id.js";
-import { init_agent_scope, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
-import { maintenanceInstruction, resolveMemoryMaintenanceSchedules } from "../memory-maintenance/schedule.js";
+import { resolveMemoryMaintenanceSchedules } from "../memory-maintenance/schedule.js";
 import "../memory-maintenance/index.js";
 //#region src/gateway/memory-maintenance-automation-reconciler.ts
-init_agent_scope();
 const AUTOMATION_IDS = [
 	"system-memory-temporal-sweep",
 	"system-memory-daily-reconciliation",
@@ -17,8 +14,6 @@ async function reconcileMemoryMaintenanceAutomations(input) {
 	};
 	const schedules = resolveMemoryMaintenanceSchedules(input.config);
 	const enabledIds = new Set(schedules.map((item) => item.automationId));
-	const agentId = normalizeAgentId(resolveDefaultAgentId());
-	const workingDirectory = resolveAgentWorkspaceDir(agentId);
 	for (const id of AUTOMATION_IDS) {
 		if (enabledIds.has(id)) continue;
 		if ((await input.automationService.get(id))?.enabled) {
@@ -36,11 +31,8 @@ async function reconcileMemoryMaintenanceAutomations(input) {
 			}
 		};
 		const action = {
-			kind: "agent",
-			agentId,
-			instruction: maintenanceInstruction(schedule.jobType),
-			workingDirectory,
-			timeoutSeconds: 300
+			kind: "system",
+			capability: `memory.${schedule.jobType}`
 		};
 		const next = {
 			name: schedule.name,
@@ -50,8 +42,17 @@ async function reconcileMemoryMaintenanceAutomations(input) {
 			action,
 			safety: { mode: "auto_apply" },
 			conversationMode: "continuous",
-			notificationPolicy: "none",
-			reliability: { disableAfterConsecutiveFailures: 3 }
+			delivery: {
+				notificationPolicy: "none",
+				destinations: []
+			},
+			reliability: { disableAfterConsecutiveFailures: 3 },
+			management: {
+				owner: "memory-maintenance",
+				editable: ["enabled", "trigger"],
+				runnable: true,
+				deletable: false
+			}
 		};
 		const current = await input.automationService.get(schedule.automationId);
 		if (!current) {
@@ -62,8 +63,13 @@ async function reconcileMemoryMaintenanceAutomations(input) {
 			result.created += 1;
 			continue;
 		}
-		if (current.name !== next.name || current.description !== next.description || !current.enabled || JSON.stringify(current.trigger) !== JSON.stringify(trigger) || JSON.stringify(current.action) !== JSON.stringify(action) || current.safety?.mode !== "auto_apply" || current.notificationPolicy !== "none") {
-			await input.automationService.update(schedule.automationId, next);
+		const reconciled = current.management ? {
+			...next,
+			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.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;

package/dist/src/gateway/service/active-execution.js

@@ -0,0 +1,16 @@
+//#region src/gateway/service/active-execution.ts
+function describeActiveExecution(input) {
+	const { origin } = input;
+	const background = origin.type === "system" && (origin.source === "automation" || origin.source === "heartbeat" || origin.source === "internal");
+	const kind = input.kind ?? (origin.type === "system" && origin.source === "automation" ? "automation" : origin.type === "system" && origin.source === "workflow" ? "workflow" : input.taskRunId ? "task" : "chat");
+	return {
+		conversationId: input.conversationId,
+		runId: input.runId,
+		kind,
+		initiator: background ? "background" : "user",
+		phase: "running",
+		startedAt: input.startedAt ?? Date.now()
+	};
+}
+//#endregion
+export { describeActiveExecution };

package/dist/src/gateway/service/agent-runner.d.ts

@@ -7,6 +7,7 @@ import type { ChannelManager } from '../../channels/manager.js';
 import type { SessionIndex } from '../../session/index.js';
 import { type ClarificationStreamEvent } from '../ephemeral-clarification-waiter.js';
 import type { ClarifyRequestPayload, ClarifyRequestResult } from '../../agent/tools/clarify-tool.js';
+import { type ActiveExecution, type ActiveExecutionKind } from './active-execution.js';
 import type { UserTurnAttachment, UserTurnInput } from '../user-turn-input.js';
 import type { AgentSourceContext, TurnContextRef } from '../../agent/source-context/types.js';
 import { SessionInputCoordinator, type ReplaceLatestTurnInput, type SubmitSessionInput } from './session-input-coordinator.js';
@@ -33,6 +34,7 @@ export declare class GatewayAgentRunner {
     private readonly ephemeralClarifications;
     /** Maps webchat session key → active `runId` for `clarify` tool routing. */
     private readonly activeWebchatRunBySession;
+    private readonly activeExecutionBySession;
     private readonly externalStreamBySession;
     private readonly externalClarificationResponses;
     readonly inputs: SessionInputCoordinator;
@@ -45,9 +47,11 @@ export declare class GatewayAgentRunner {
         conversationId: string;
         runId: string;
     }>;
+    listActiveExecutions(): ActiveExecution[];
     disposeClarifications(): void;
     registerExternalWebchatRun(conversationId: string, runId: string, publish: (event: ClarificationStreamEvent) => void, options?: {
         beforeClarificationResponse?: () => boolean;
+        kind?: ActiveExecutionKind;
     }): void;
     unregisterExternalWebchatRun(conversationId: string, runId: string): void;
     cancelClarificationForRun(runId: string): void;