@xopcai/xopc 0.0.331 → 0.0.333

package/dist/src/scenes/agentExecutor.js

@@ -1,6 +1,7 @@
 import { init_sync_provider_auth, resolveProviderApiKeySync } from "../auth/sync-provider-auth.js";
 import { getApiKeySync, init_providers } from "../providers/index.js";
 import { createExtensionAwareStreamFn } from "../providers/extension-stream-bridge.js";
+import { trackAiUsageStream } from "../usage/recorder.js";
 import { readOnlyResultSchema } from "./execution.js";
 import { Agent } from "@earendil-works/pi-agent-core";
 //#region src/scenes/agentExecutor.ts
@@ -25,10 +26,10 @@ var SceneAgentExecutor = class {
 			},
 			streamFn: (model, context, options) => {
 				if (++calls > 1) throw new Error("Scene executor permits one model call");
-				return stream(model, context, {
+				return trackAiUsageStream(model, input.usage, () => stream(model, context, {
 					...options,
 					maxTokens: input.template.execution.limits.maxOutputTokens
-				});
+				}));
 			},
 			getApiKey: (provider) => resolveProviderApiKeySync(provider) ?? getApiKeySync(provider) ?? ""
 		});
@@ -42,14 +43,6 @@ var SceneAgentExecutor = class {
 			}));
 			input.signal.throwIfAborted();
 			const response = agent.state.messages.findLast((message) => message.role === "assistant");
-			if (response?.role === "assistant") input.onUsage?.({
-				provider: response.provider,
-				model: response.model,
-				inputTokens: response.usage.input,
-				outputTokens: response.usage.output,
-				totalTokens: response.usage.totalTokens,
-				estimatedCost: response.usage.cost.total
-			});
 			if (!response || response.role !== "assistant" || response.stopReason !== "stop") throw new Error("Scene model did not complete a read-only result");
 			if (response.content.some((block) => block.type === "toolCall")) throw new Error("Scene model attempted an unavailable tool");
 			const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");

package/dist/src/scenes/contracts.d.ts

@@ -2,14 +2,8 @@ export { sceneOutcomeKinds, activationStatuses, sceneScopeSchema, sceneTemplateS
 import { type SceneTemplate, type ScenePermission, type ActivationStatus } from '@xopcai/gateway-contract';
 /** Stable JSON hashing binds approvals and immutable versions to exact content. */
 export declare function sceneContentHash(value: unknown): string;
-export declare function validateTemplate(value: unknown, registered: Pick<ScenePermission, 'contextProviders' | 'effectHandlers'>): SceneTemplate;
+export declare function validateTemplate(value: unknown, registered: Pick<ScenePermission, 'contextProviders' | 'effectHandlers'> & {
+    executionAdapters?: string[];
+}): SceneTemplate;
 export declare function intersectPermissions(...permissions: ScenePermission[]): ScenePermission;
 export declare function canTransitionActivation(from: ActivationStatus, to: ActivationStatus): boolean;
-export type SceneModelUsage = {
-    provider: string;
-    model: string;
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    estimatedCost: number;
-};

package/dist/src/scenes/contracts.js

@@ -18,6 +18,7 @@ function validateTemplate(value, registered) {
 	const template = sceneTemplateSchema.parse(value);
 	for (const provider of template.contextProviders) if (!registered.contextProviders.includes(provider)) throw new Error(`Unknown scene context provider: ${provider}`);
 	for (const handler of template.allowedEffectHandlers) if (!registered.effectHandlers.includes(handler)) throw new Error(`Unknown scene effect handler: ${handler}`);
+	if (registered.executionAdapters && !registered.executionAdapters.includes(template.execution.kind)) throw new Error(`Unknown scene execution adapter: ${template.execution.kind}`);
 	return template;
 }
 function intersectPermissions(...permissions) {

package/dist/src/scenes/execution.d.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
-import { type SceneModelUsage, type SceneActivation, type ScenePermission, type SceneTemplate } from './contracts.js';
+import type { AiUsageContext } from '../usage/types.js';
+import { type SceneActivation, type ScenePermission, type SceneTemplate } from './contracts.js';
 import { SceneRepository } from './repository.js';
+import { SceneCapabilityRegistry } from './registry.js';
 export declare const readOnlyResultSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         artifact: "artifact";
@@ -27,6 +29,10 @@ export interface SceneEvidence {
 }
 export interface SceneContextProvider {
     id: string;
+    setupIssues?(activation: SceneActivation): string[];
+    authorization?(activation: SceneActivation): string[] | null;
+    tracksHealth?: boolean;
+    requiresAccountIdentity?: boolean;
     read(input: {
         activation: SceneActivation;
         subjectId: string;
@@ -41,7 +47,7 @@ export interface SceneReadOnlyExecutor {
         goal: string;
         evidence: SceneEvidence[];
         signal: AbortSignal;
-        onUsage?: (usage: SceneModelUsage) => void;
+        usage: AiUsageContext;
     }): Promise<unknown>;
 }
 /** Runs one durable claim without exposing messaging, filesystem or write tools. */
@@ -51,6 +57,6 @@ export declare class SceneExecutionService {
     private readonly executor;
     private readonly authorize;
     private readonly clock;
-    constructor(repository: SceneRepository, providers: readonly SceneContextProvider[], executor: SceneReadOnlyExecutor, authorize: (activation: SceneActivation) => Promise<ScenePermission>, clock?: () => number);
+    constructor(repository: SceneRepository, providers: SceneCapabilityRegistry<SceneContextProvider>, executor: SceneReadOnlyExecutor, authorize: (activation: SceneActivation) => Promise<ScenePermission>, clock?: () => number);
     runNext(worker: string, outerSignal?: AbortSignal): Promise<'idle' | 'completed' | 'discarded' | 'failed' | 'deferred'>;
 }

package/dist/src/scenes/execution.js

@@ -36,7 +36,6 @@ var SceneExecutionService = class {
 		this.executor = executor;
 		this.authorize = authorize;
 		this.clock = clock;
-		if (new Set(providers.map((provider) => provider.id)).size !== providers.length) throw new Error("Duplicate scene context providers");
 	}
 	async runNext(worker, outerSignal) {
 		outerSignal?.throwIfAborted();
@@ -46,6 +45,7 @@ var SceneExecutionService = class {
 		if (!runInput) return "discarded";
 		const { activation, subjectId, accountId, notBefore } = runInput;
 		const template = this.repository.getTemplate(activation.templateKey, activation.templateVersion);
+		if (template.execution.kind !== "agent") throw new SceneExecutionRejected("executor_unavailable");
 		if (!this.repository.renewLease(claim, this.clock(), template.execution.limits.timeoutSeconds * 1e3 + 5e3)) return "discarded";
 		const controller = new AbortController();
 		const abort = () => controller.abort(outerSignal?.reason);
@@ -69,7 +69,7 @@ var SceneExecutionService = class {
 			try {
 				granted = await this.authorize(activation);
 			} catch (error) {
-				if (template.contextProviders.includes("mail")) this.repository.recordSourceHealth(activation, sceneSourceFailureReason(error), this.clock(), this.clock() + 6e4);
+				if (template.contextProviders.some((id) => this.providers.get(id).tracksHealth)) this.repository.recordSourceHealth(activation, sceneSourceFailureReason(error), this.clock(), this.clock() + 6e4);
 				throw error;
 			}
 			assertCurrent();
@@ -80,12 +80,11 @@ var SceneExecutionService = class {
 			});
 			const evidence = [];
 			for (const providerId of template.contextProviders) {
+				const provider = this.providers.get(providerId);
 				if (!permissions.contextProviders.includes(providerId)) {
-					if (providerId === "mail") this.repository.recordSourceHealth(activation, "needs_permission", this.clock(), this.clock() + 6e4);
+					if (provider.tracksHealth) this.repository.recordSourceHealth(activation, "needs_permission", this.clock(), this.clock() + 6e4);
 					throw new SceneExecutionRejected("needs_permission");
 				}
-				const provider = this.providers.find((item) => item.id === providerId);
-				if (!provider) throw new SceneExecutionRejected("provider_unavailable");
 				let items;
 				try {
 					items = await provider.read({
@@ -96,11 +95,11 @@ var SceneExecutionService = class {
 						signal: controller.signal
 					});
 				} catch (error) {
-					if (providerId === "mail" && !outerSignal?.aborted) this.repository.recordSourceHealth(activation, sceneSourceFailureReason(error), this.clock(), this.clock() + 6e4);
+					if (provider.tracksHealth && !outerSignal?.aborted) this.repository.recordSourceHealth(activation, sceneSourceFailureReason(error), this.clock(), this.clock() + 6e4);
 					throw error;
 				}
 				assertCurrent();
-				if (providerId === "mail" && items.some((item) => item.accountId === void 0)) throw new SceneExecutionRejected("missing_account_identity");
+				if (provider.requiresAccountIdentity && items.some((item) => item.accountId === void 0)) throw new SceneExecutionRejected("missing_account_identity");
 				if (items.some((item) => !evidenceAllowed(item, activation, permissions, this.clock()))) throw new SceneExecutionRejected("unauthorized_or_stale_evidence");
 				evidence.push(...items);
 			}
@@ -108,7 +107,7 @@ var SceneExecutionService = class {
 			if (new Set(evidence.map((item) => item.id)).size !== evidence.length) throw new SceneExecutionRejected("duplicate_evidence");
 			evidence.sort((left, right) => left.id.localeCompare(right.id));
 			const fingerprint = sceneContentHash(evidence.map(({ freshUntil: _freshUntil, ...item }) => item));
-			if (template.contextProviders.includes("mail")) this.repository.recordSourceHealth(activation, null, this.clock());
+			if (template.contextProviders.some((id) => this.providers.get(id).tracksHealth)) this.repository.recordSourceHealth(activation, null, this.clock());
 			return {
 				evidence,
 				fingerprint,
@@ -137,9 +136,11 @@ var SceneExecutionService = class {
 				goal: activation.goal,
 				evidence: snapshot.evidence,
 				signal: controller.signal,
-				onUsage: (usage) => {
-					assertCurrent();
-					this.repository.recordModelUsage(claim, usage, this.clock());
+				usage: {
+					operation: "scene.execute",
+					traceId: claim.id,
+					runId: claim.id,
+					...activation.scope.kind === "conversation" ? { conversationId: activation.scope.id } : {}
 				}
 			});
 			assertCurrent();

package/dist/src/scenes/httpServices.d.ts

@@ -6,10 +6,13 @@ import type { SceneApplicationService } from './service.js';
 import type { SceneMailContextProvider } from './mailContext.js';
 import type { ScenePreferenceService } from './preferences.js';
 import type { SceneMetrics } from './metrics.js';
-import type { TaskFollowUpService } from './taskFollowUp/service.js';
+import type { SceneActivationAdapter } from './activationAdapter.js';
+import type { SceneCapabilityRegistry } from './registry.js';
+import type { SceneSourceRegistry } from './taskFollowUp/contracts.js';
 /** An explicitly installed scene domain; never resolves to the old runtime. */
 export interface SceneHttpServices {
-    followUps?: TaskFollowUpService;
+    activationAdapters: SceneCapabilityRegistry<SceneActivationAdapter>;
+    sourceProviders: SceneSourceRegistry;
     repository: SceneRepository;
     application: SceneApplicationService;
     inbox: SceneInboxService;

package/dist/src/scenes/mailContext.d.ts

@@ -6,7 +6,11 @@ export declare class SceneMailContextProvider implements SceneContextProvider {
     private readonly db;
     private readonly clock;
     readonly id = "mail";
+    readonly tracksHealth = true;
+    readonly requiresAccountIdentity = true;
     constructor(db: DatabaseSync, clock?: () => number);
+    setupIssues(activation: SceneActivation): string[];
+    authorization(activation: SceneActivation): string[] | null;
     /** Resolve current account grants for the exact delegated source, including reconnects and revocation. */
     authorizedAccounts(activation: SceneActivation): string[];
     /** Picker metadata only; choosing an item still requires explicit activation consent. */

package/dist/src/scenes/mailContext.js

@@ -11,10 +11,19 @@ const accountPolicy = `a.enabled = 1 AND installation.enabled = 1 AND c.status =
 /** Reads a bounded, account-scoped thread from synchronized connector knowledge. */
 var SceneMailContextProvider = class {
 	id = "mail";
+	tracksHealth = true;
+	requiresAccountIdentity = true;
 	constructor(db, clock = Date.now) {
 		this.db = db;
 		this.clock = clock;
 	}
+	setupIssues(activation) {
+		return activation.scope.kind === "objects" && activation.scope.ids.length === 1 && activation.permissions.accountIds.length === 1 ? [] : ["one_mail_thread_and_account"];
+	}
+	authorization(activation) {
+		const accounts = this.authorizedAccounts(activation);
+		return accounts.length ? accounts : null;
+	}
 	/** Resolve current account grants for the exact delegated source, including reconnects and revocation. */
 	authorizedAccounts(activation) {
 		if (activation.scope.kind !== "objects" || activation.scope.ids.length !== 1) return [];

package/dist/src/scenes/maintenance.js

@@ -11,11 +11,7 @@ function maintainSceneStorage(db, now = Date.now()) {
 		db.prepare(`DELETE FROM scene_mail_sources WHERE id IN (SELECT s.id FROM scene_mail_sources s
       WHERE s.selected_at < ? AND NOT EXISTS (SELECT 1 FROM scene_activations a, json_each(a.scope_json, '$.ids') ids WHERE ids.value = s.id)
       ORDER BY selected_at LIMIT 100)`).run(now - 30 * 864e5);
-		for (const table of [
-			"scene_context_snapshots",
-			"scene_model_reservations",
-			"scene_model_usage"
-		]) db.prepare(`DELETE FROM ${table} WHERE run_id IN (SELECT DISTINCT r.id FROM scene_runs r JOIN ${table} t ON t.run_id = r.id
+		for (const table of ["scene_context_snapshots", "scene_model_reservations"]) db.prepare(`DELETE FROM ${table} WHERE run_id IN (SELECT DISTINCT r.id FROM scene_runs r JOIN ${table} t ON t.run_id = r.id
         WHERE r.status NOT IN ('running', 'retry_wait') AND r.created_at < ? ORDER BY r.created_at LIMIT 100)`).run(cutoff);
 		db.prepare("DELETE FROM notification_attention_budget WHERE dedupe_key IN (SELECT dedupe_key FROM notification_attention_budget WHERE created_at < ? LIMIT 100)").run(cutoff);
 	});

package/dist/src/scenes/metrics.d.ts

@@ -11,12 +11,6 @@ export declare class SceneMetrics {
         currentModel: string;
         pendingChecks: number;
         oldestDueWaitMs: number;
-        lastSevenDays: {
-            modelCalls: number;
-            connectorReads: number;
-            tokens: number;
-            estimatedCost: number;
-        };
         notifications: Record<string, import("node:sqlite").SQLOutputValue>[];
         activations: Record<string, import("node:sqlite").SQLOutputValue>[];
     };

package/dist/src/scenes/metrics.js

@@ -12,11 +12,6 @@ var SceneMetrics = class {
 		const queue = this.db.prepare(`SELECT COUNT(*) AS depth, MIN(i.due_at) AS oldest
       FROM scene_trigger_intents i JOIN scene_activations a ON a.id = i.activation_id
       WHERE a.owner_id = ? AND a.workspace_id = ? AND i.status = 'pending'`).get(principal.ownerId, principal.workspaceId);
-		const usage = this.db.prepare(`SELECT COUNT(*) AS calls, COALESCE(SUM(u.total_tokens), 0) AS tokens,
-      COALESCE(SUM(u.estimated_cost), 0) AS cost FROM scene_model_usage u JOIN scene_runs r ON r.id = u.run_id
-      JOIN scene_activations a ON a.id = r.activation_id WHERE a.owner_id = ? AND a.workspace_id = ? AND u.recorded_at >= ?`).get(principal.ownerId, principal.workspaceId, now - 7 * 864e5);
-		const connectorReads = Number(this.db.prepare(`SELECT COALESCE(SUM(request_count), 0) AS count FROM scene_connector_usage
-      WHERE owner_id = ? AND workspace_id = ? AND utc_day >= ?`).get(principal.ownerId, principal.workspaceId, Math.floor(now / 864e5) - 6)?.count);
 		const notifications = this.db.prepare(`SELECT status, COUNT(*) AS count FROM notification_dispatches
       WHERE owner_id = ? AND workspace_id = ? GROUP BY status`).all(principal.ownerId, principal.workspaceId);
 		const activations = this.db.prepare(`SELECT a.id, a.status,
@@ -49,12 +44,6 @@ var SceneMetrics = class {
 			currentModel,
 			pendingChecks: Number(queue.depth),
 			oldestDueWaitMs: queue.oldest == null ? 0 : Math.max(0, now - Number(queue.oldest)),
-			lastSevenDays: {
-				modelCalls: Number(usage.calls),
-				connectorReads,
-				tokens: Number(usage.tokens),
-				estimatedCost: Number(usage.cost)
-			},
 			notifications,
 			activations
 		};

package/dist/src/scenes/registry.d.ts

@@ -0,0 +1,11 @@
+/** Small immutable registry used by scene capabilities at the composition root. */
+export declare class SceneCapabilityRegistry<T extends {
+    id: string;
+}> {
+    private readonly items;
+    constructor(items: readonly T[]);
+    ids(): string[];
+    list(): T[];
+    has(id: string): boolean;
+    get(id: string): T;
+}

package/dist/src/scenes/registry.js

@@ -0,0 +1,28 @@
+//#region src/scenes/registry.ts
+/** Small immutable registry used by scene capabilities at the composition root. */
+var SceneCapabilityRegistry = class {
+	items = /* @__PURE__ */ new Map();
+	constructor(items) {
+		for (const item of items) {
+			if (!item.id.trim()) throw new Error("Scene capability id is required");
+			if (this.items.has(item.id)) throw new Error(`Duplicate scene capability: ${item.id}`);
+			this.items.set(item.id, item);
+		}
+	}
+	ids() {
+		return [...this.items.keys()];
+	}
+	list() {
+		return [...this.items.values()];
+	}
+	has(id) {
+		return this.items.has(id);
+	}
+	get(id) {
+		const item = this.items.get(id);
+		if (!item) throw new Error(`Scene capability unavailable: ${id}`);
+		return item;
+	}
+};
+//#endregion
+export { SceneCapabilityRegistry };

package/dist/src/scenes/repository.d.ts

@@ -1,4 +1,3 @@
-import type { SceneModelUsage } from './contracts.js';
 import type { DatabaseSync } from 'node:sqlite';
 import { type ActivationStatus, type SceneActivation, type ScenePrincipal, type SceneTemplate } from './contracts.js';
 export interface SceneEventInput {
@@ -70,8 +69,6 @@ export declare class SceneRepository {
         accountId: string;
         dueAt: number;
     }, now: number): SceneWorkItem;
-    /** Internal worker scan; identity comes from persisted ownership, never an event payload. */
-    recordModelUsage(claim: SceneRunClaim, usage: SceneModelUsage, now: number): void;
     listMailObservationItems(afterId?: string, now?: number): Array<{
         principal: ScenePrincipal;
         item: SceneWorkItem;
@@ -99,6 +96,7 @@ export declare class SceneRepository {
     }, now: number): string;
     acceptManualCheck(principal: ScenePrincipal, activationId: string, triggerKey: string, requestId: string, now: number): string;
     claimNext(worker: string, now: number, leaseMs?: number): SceneRunClaim | null;
+    claimIntentForAdapter(principal: ScenePrincipal, activationId: string, intentId: string, adapterId: string, worker: string, now: number, leaseMs: number): SceneRunClaim;
     renewLease(claim: SceneRunClaim, now: number, leaseMs: number): boolean;
     reserveModelCall(claim: SceneRunClaim, now: number, limits?: {
         activation: number;
@@ -117,6 +115,11 @@ export declare class SceneRepository {
         summary: string;
         evidenceIds: string[];
     }, now: number): boolean;
+    finishAdapterRun(claim: SceneRunClaim, result: {
+        kind: 'artifact' | 'decision' | 'receipt';
+        summary: string;
+        [key: string]: unknown;
+    }, now: number): boolean;
     listInbox(principal: ScenePrincipal, limit?: number, afterId?: string, activationId?: string | null): {
         createdAt: number;
         sources: {

package/dist/src/scenes/repository.js

@@ -238,11 +238,6 @@ var SceneRepository = class {
 			};
 		});
 	}
-	/** Internal worker scan; identity comes from persisted ownership, never an event payload. */
-	recordModelUsage(claim, usage, now) {
-		if (!this.isCurrentClaim(claim, now)) return;
-		this.db.prepare(`INSERT OR IGNORE INTO scene_model_usage VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(claim.id, claim.leaseEpoch, usage.provider, usage.model, usage.inputTokens, usage.outputTokens, usage.totalTokens, usage.estimatedCost, now);
-	}
 	listMailObservationItems(afterId = "", now = Date.now()) {
 		return this.db.prepare(`SELECT w.*, a.owner_id, a.workspace_id FROM scene_work_items w
       JOIN scene_activations a ON a.id = w.activation_id
@@ -525,7 +520,9 @@ var SceneRepository = class {
 			this.db.prepare(`UPDATE scene_trigger_intents SET status = 'resolved' WHERE status = 'claimed'
         AND id IN (SELECT intent_id FROM scene_runs WHERE status = 'failed')`).run();
 			const retry = this.db.prepare(`SELECT r.* FROM scene_runs r JOIN scene_activations a ON a.id = r.activation_id
+        JOIN scene_template_versions t ON t.template_key = a.template_key AND t.version = a.template_version
         WHERE a.status = 'active' AND a.revision = r.activation_revision AND ${checksAllowed}
+        AND json_extract(t.manifest_json, '$.execution.kind') = 'agent'
         AND (r.attempt < 3 OR (r.status = 'retry_wait' AND r.reason IN ('source_not_ready', 'daily_budget')))
         AND ((r.status = 'running' AND r.lease_until <= ?) OR (r.status = 'retry_wait' AND r.retry_at <= ?))
         ORDER BY r.created_at, r.id LIMIT 1`).get(now / 1e3, now, now);
@@ -535,7 +532,9 @@ var SceneRepository = class {
 				return this.readClaim(String(retry.id));
 			}
 			const intent = this.db.prepare(`SELECT i.* FROM scene_trigger_intents i JOIN scene_activations a ON a.id = i.activation_id
+        JOIN scene_template_versions t ON t.template_key = a.template_key AND t.version = a.template_version
         WHERE i.status = 'pending' AND i.due_at <= ? AND a.status = 'active' AND a.revision = i.activation_revision AND ${checksAllowed}
+        AND json_extract(t.manifest_json, '$.execution.kind') = 'agent'
         AND NOT EXISTS (SELECT 1 FROM scene_runs r WHERE r.activation_id = a.id AND r.status IN ('running', 'retry_wait'))
         ORDER BY i.due_at, i.id LIMIT 1`).get(now, now / 1e3);
 			if (!intent) return null;
@@ -546,6 +545,21 @@ var SceneRepository = class {
 			return this.readClaim(id);
 		});
 	}
+	claimIntentForAdapter(principal, activationId, intentId, adapterId, worker, now, leaseMs) {
+		if (!adapterId.trim() || !worker.trim() || !Number.isSafeInteger(now) || now < 0 || !Number.isSafeInteger(leaseMs) || leaseMs < 1) throw new Error("Invalid scene lease");
+		return this.transaction(() => {
+			const activation = this.getActivation(principal, activationId);
+			if (this.getTemplate(activation.templateKey, activation.templateVersion).execution.kind !== adapterId) throw new SceneConflictError("Scene execution adapter changed");
+			if (!this.db.prepare(`SELECT * FROM scene_trigger_intents
+        WHERE id = ? AND activation_id = ? AND activation_revision = ? AND status = 'pending' AND due_at <= ?`).get(intentId, activationId, activation.revision, now)) throw new SceneConflictError("Scene trigger is no longer available");
+			if (this.db.prepare("SELECT 1 FROM scene_runs WHERE activation_id = ? AND status IN ('running', 'retry_wait')").get(activationId)) throw new SceneConflictError("Scene already has an active run");
+			const id = randomUUID();
+			this.db.prepare(`INSERT INTO scene_runs (id, intent_id, activation_id, activation_revision, status, attempt, lease_epoch, lease_owner, lease_until, created_at)
+        VALUES (?, ?, ?, ?, 'running', 1, 1, ?, ?, ?)`).run(id, intentId, activationId, activation.revision, worker, now + leaseMs, now);
+			this.db.prepare("UPDATE scene_trigger_intents SET status = 'claimed' WHERE id = ?").run(intentId);
+			return this.readClaim(id);
+		});
+	}
 	renewLease(claim, now, leaseMs) {
 		if (!Number.isSafeInteger(leaseMs) || leaseMs < 1) throw new Error("Invalid scene lease");
 		return this.db.prepare(`UPDATE scene_runs SET lease_until = ? WHERE id = ? AND status = 'running'
@@ -639,6 +653,30 @@ var SceneRepository = class {
 			return true;
 		});
 	}
+	finishAdapterRun(claim, result, now) {
+		return this.transaction(() => {
+			if (!this.isCurrentClaim(claim, now)) return false;
+			const row = this.db.prepare(`SELECT t.manifest_json, a.owner_id, a.workspace_id FROM scene_activations a JOIN scene_template_versions t
+        ON a.template_key = t.template_key AND a.template_version = t.version WHERE a.id = ?`).get(claim.activationId);
+			const template = sceneTemplateSchema.parse(JSON.parse(String(row.manifest_json)));
+			if (template.execution.kind === "agent" || !template.allowedOutcomeKinds.includes(result.kind)) throw new Error("Scene result kind is not allowed");
+			if (!result.summary.trim()) throw new Error("Scene result needs a summary");
+			const outcomeId = randomUUID();
+			this.db.prepare(`UPDATE scene_presentations AS p SET status = 'withdrawn', withdrawn_at = ? WHERE p.outcome_id IN (
+        SELECT o.id FROM scene_outcomes o JOIN scene_runs r ON r.id = o.run_id
+        WHERE r.activation_id = ?
+      )`).run(now, claim.activationId);
+			this.db.prepare("INSERT INTO scene_outcomes VALUES (?, ?, ?, ?, ?)").run(outcomeId, claim.id, result.kind, JSON.stringify(result), now);
+			const presentationId = randomUUID();
+			this.db.prepare("INSERT INTO scene_presentations(id, outcome_id, destination, status, created_at) VALUES (?, ?, 'inbox', 'unread', ?)").run(presentationId, outcomeId, now);
+			this.db.prepare(`INSERT INTO notification_result_outbox
+        (id, owner_id, workspace_id, subject_id, status, attempt, next_attempt_at, created_at, updated_at)
+        VALUES (?, ?, ?, ?, 'pending', 0, ?, ?, ?)`).run(presentationId, row.owner_id, row.workspace_id, presentationId, now, now, now);
+			this.db.prepare("UPDATE scene_runs SET status = 'succeeded', reason = NULL, lease_owner = NULL, lease_until = NULL WHERE id = ?").run(claim.id);
+			this.db.prepare("UPDATE scene_trigger_intents SET status = 'resolved' WHERE id = ?").run(claim.intentId);
+			return true;
+		});
+	}
 	listInbox(principal, limit = 50, afterId = "", activationId = null) {
 		this.assertPrincipal(principal);
 		const now = Date.now();

package/dist/src/scenes/service.d.ts

@@ -1,5 +1,6 @@
 import { type SceneActivation, type ScenePermission, type ScenePrincipal } from './contracts.js';
 import type { SceneContextProvider } from './execution.js';
+import { SceneCapabilityRegistry } from './registry.js';
 import { SceneRepository } from './repository.js';
 export declare class SceneSetupError extends Error {
     readonly missing: string[];
@@ -12,7 +13,7 @@ export declare class SceneApplicationService {
     private readonly authorize;
     private readonly clock;
     private readonly modelReadiness;
-    constructor(repository: SceneRepository, providers: readonly SceneContextProvider[], authorize: (activation: SceneActivation) => Promise<ScenePermission>, clock?: () => number, modelReadiness?: () => string[]);
+    constructor(repository: SceneRepository, providers: SceneCapabilityRegistry<SceneContextProvider>, authorize: (activation: SceneActivation) => Promise<ScenePermission>, clock?: () => number, modelReadiness?: () => string[]);
     get database(): import("node:sqlite").DatabaseSync;
     preflight(principal: ScenePrincipal, value: unknown): Promise<{
         ready: boolean;

package/dist/src/scenes/service.js

@@ -37,8 +37,9 @@ var SceneApplicationService = class {
 	async checkReadiness(activation) {
 		const input = activation;
 		const template = validateTemplate(this.repository.getTemplate(input.templateKey, input.templateVersion), {
-			contextProviders: this.providers.map((provider) => provider.id),
-			effectHandlers: []
+			contextProviders: this.providers.ids(),
+			effectHandlers: [],
+			executionAdapters: ["agent"]
 		});
 		const permissions = intersectPermissions(input.permissions, await this.authorize(activation));
 		const missing = template.contextProviders.filter((provider) => !permissions.contextProviders.includes(provider)).map((id) => `context:${id}`);
@@ -46,8 +47,7 @@ var SceneApplicationService = class {
 		missing.push(...input.permissions.accountIds.filter((id) => !permissions.accountIds.includes(id)).map((id) => `account:${id}`));
 		if (input.permissions.effectHandlers.length > 0) missing.push("read_only_execution");
 		if (input.permissions.contextProviders.some((id) => !template.contextProviders.includes(id))) missing.push("unrequested_context");
-		if (template.key === "mail-follow-up" && (input.scope.kind !== "objects" || input.scope.ids.length !== 1 || input.permissions.accountIds.length !== 1)) missing.push("one_mail_thread_and_account");
-		if (template.contextProviders.includes("user_notes") && input.scope.kind !== "personal") missing.push("personal_notes_scope");
+		for (const providerId of template.contextProviders) missing.push(...this.providers.get(providerId).setupIssues?.(activation) ?? []);
 		return {
 			ready: missing.length === 0,
 			missing
@@ -79,7 +79,7 @@ var SceneApplicationService = class {
 	async prepareTransition(principal, id, value) {
 		const input = SceneTransitionSchema.parse(value);
 		const activation = this.repository.getActivation(principal, id);
-		if (activation.templateKey === "task-follow-up") throw new SceneConflictError("Use the task follow-up controls");
+		if (this.repository.getTemplate(activation.templateKey, activation.templateVersion).execution.kind !== "agent") throw new SceneConflictError("Use the activation execution adapter");
 		if (activation.revision !== input.expectedRevision) throw new SceneConflictError("Scene activation changed");
 		if (input.status === "active") {
 			const result = await this.checkReadiness(activation);
@@ -89,11 +89,13 @@ var SceneApplicationService = class {
 	/** The exact revision fences changes made while asynchronous readiness checks were running. */
 	transitionAfterPreflight(principal, id, value) {
 		const input = SceneTransitionSchema.parse(value);
-		if (this.repository.getActivation(principal, id).templateKey === "task-follow-up") throw new SceneConflictError("Use the task follow-up controls");
+		const activation = this.repository.getActivation(principal, id);
+		if (this.repository.getTemplate(activation.templateKey, activation.templateVersion).execution.kind !== "agent") throw new SceneConflictError("Use the activation execution adapter");
 		return this.repository.transitionActivation(principal, id, input.expectedRevision, input.status, this.clock());
 	}
 	configure(principal, id, value) {
-		if (this.repository.getActivation(principal, id).templateKey === "task-follow-up") throw new SceneConflictError("Use the task follow-up controls");
+		const activation = this.repository.getActivation(principal, id);
+		if (this.repository.getTemplate(activation.templateKey, activation.templateVersion).execution.kind !== "agent") throw new SceneConflictError("Use the activation execution adapter");
 		const { expectedRevision, ...input } = SceneConfigureSchema.parse(value);
 		return this.repository.configureActivation(principal, id, expectedRevision, input);
 	}

package/dist/src/scenes/taskFollowUp/contracts.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { type ScenePrincipal } from '../contracts.js';
+import { SceneCapabilityRegistry } from '../registry.js';
 export declare const taskFollowUpTemplate: {
     schemaVersion: 1;
     key: string;
@@ -20,7 +21,39 @@ export declare const taskFollowUpTemplate: {
         type: "schedule";
     })[];
     execution: {
-        kind: "agent";
+        kind: string;
+        instruction: string;
+        limits: {
+            timeoutSeconds: number;
+            maxIterations: number;
+            maxToolCalls: number;
+            maxOutputTokens: number;
+        };
+    };
+    allowedOutcomeKinds: ("artifact" | "receipt" | "decision" | "observation" | "no_change" | "state_change" | "effect_proposal")[];
+    allowedEffectHandlers: string[];
+};
+export declare const decisionLogTemplate: {
+    schemaVersion: 1;
+    key: string;
+    version: string;
+    title: string;
+    description: string;
+    goalMode: "finite" | "ongoing";
+    contextProviders: string[];
+    triggers: ({
+        id: string;
+        type: "manual";
+    } | {
+        id: string;
+        type: "event";
+        eventType: string;
+    } | {
+        id: string;
+        type: "schedule";
+    })[];
+    execution: {
+        kind: string;
         instruction: string;
         limits: {
             timeoutSeconds: number;
@@ -43,7 +76,7 @@ export type SourceSnapshot = {
     observedAt: number;
 };
 /** Adapters own source syntax and permission checks, never task or execution policy. */
-export interface TaskSourceAdapter {
+export interface SceneSourceAdapter {
     id: string;
     label: string;
     normalize(reference: Record<string, string>): Record<string, string>;
@@ -56,14 +89,11 @@ export interface TaskSourceAdapter {
     }>;
     resolveLink?(principal: ScenePrincipal, accountId: string, url: string, signal: AbortSignal): Promise<Record<string, string>>;
 }
-export declare class TaskSourceRegistry {
-    private readonly adapters;
-    constructor(adapters: TaskSourceAdapter[]);
-    list(): {
+export declare class SceneSourceRegistry extends SceneCapabilityRegistry<SceneSourceAdapter> {
+    providers(): {
         id: string;
         label: string;
     }[];
-    get(id: string): TaskSourceAdapter;
     normalize(source: SourceReference): SourceReference;
 }
 export declare const taskFollowUpInputSchema: z.ZodObject<{