@xopcai/xopc 0.0.332 → 0.0.333

package/dist/src/infra/domain-outbox-dispatcher.d.ts

@@ -1,6 +1,3 @@
-import type { AutomationEvent } from '../automations/domain/types.js';
 export declare class DomainOutboxDispatcher {
-    private readonly publish;
-    constructor(publish: (event: AutomationEvent) => void);
     drain(limit?: number, subjectKind?: string): number;
 }

package/dist/src/infra/domain-outbox-dispatcher.js

@@ -1,26 +1,34 @@
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { automationEventPublisher } from "../automations/events/event-repository.js";
 //#region src/infra/domain-outbox-dispatcher.ts
 init_transaction();
 var DomainOutboxDispatcher = class {
-	constructor(publish) {
-		this.publish = publish;
-	}
 	drain(limit = 100, subjectKind) {
-		const rows = getSqliteDatabase().prepare(`SELECT event_id, event_type, payload_json, created_at, subject_kind, operation_id
+		const rows = getSqliteDatabase().prepare(`SELECT event_id, event_type, payload_json, created_at, subject_kind, subject_id, operation_id
        FROM domain_outbox WHERE published_at IS NULL AND (? IS NULL OR subject_kind = ?)
-       ORDER BY created_at, event_id LIMIT ?`).all(subjectKind ?? null, subjectKind ?? null, Math.max(1, Math.min(500, Math.floor(limit))));
+       ORDER BY created_at, rowid LIMIT ?`).all(subjectKind ?? null, subjectKind ?? null, Math.max(1, Math.min(500, Math.floor(limit))));
 		let published = 0;
 		for (const row of rows) try {
 			const payload = JSON.parse(row.payload_json);
-			this.publish({
+			automationEventPublisher.publish({
+				id: row.event_id,
 				type: row.event_type,
 				source: row.subject_kind === "note" ? "notes" : row.subject_kind === "project" ? "projects" : row.subject_kind === "scene" ? "scenes" : row.subject_kind === "local_app" ? "local_apps" : "tasks",
+				schemaVersion: 1,
+				subject: {
+					kind: row.subject_kind,
+					id: row.subject_id
+				},
 				payload: {
 					...payload,
 					sourceEventId: row.event_id,
 					...row.operation_id ? { operationId: row.operation_id } : {}
 				},
-				occurredAtMs: row.created_at
+				occurredAtMs: row.created_at,
+				correlationId: typeof payload.correlationId === "string" ? payload.correlationId : row.event_id,
+				causationId: typeof payload.causationId === "string" ? payload.causationId : void 0,
+				dedupeKey: row.event_id,
+				trust: "system"
 			});
 			runSqliteWriteTransaction((db) => {
 				db.prepare(`UPDATE domain_outbox SET published_at = ?, attempts = attempts + 1

package/dist/src/local-apps/service.js

@@ -511,7 +511,7 @@ var LocalAppService = class {
 		});
 	}
 	flushAcceptanceEvents() {
-		new DomainOutboxDispatcher((event) => this.options.emit(event.type, event.payload)).drain(100, "local_app");
+		new DomainOutboxDispatcher().drain(100, "local_app");
 	}
 	releaseRoot(appId) {
 		return join(resolveStateDir(), "local-apps", "releases", appId);

package/dist/src/notes/service.js

@@ -8,7 +8,6 @@ import { init_notes_repository, listNoteProjectSummaries } from "../storage/sqli
 import { changedFieldsFromPatch, emitActivity, previewText, systemActivityActor, systemActivitySource } from "../activity/emitter.js";
 import { getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
 import { DomainOutboxDispatcher } from "../infra/domain-outbox-dispatcher.js";
-import { publishAutomationProductEvent } from "../automations/product-events.js";
 import { completeWithResolvedCredentials } from "../providers/model-call.js";
 import { partitionAttachmentsByReference } from "./note-attachment-sync.js";
 import { buildNoteAgentContextArtifact, getCachedNoteAgentContextArtifact } from "./agent-context.js";
@@ -153,7 +152,7 @@ async function buildAiCatalysisReport(note, config) {
 		role: "user",
 		content: buildCatalysisPrompt(note),
 		timestamp: Date.now()
-	}] }, { temperature: .2 });
+	}] }, { temperature: .2 }, void 0, { operation: "note.generate" });
 	let responseText = "";
 	if (Array.isArray(response.content)) {
 		for (const part of response.content) if (part && typeof part === "object" && part.type === "text") responseText += String(part.text || "");
@@ -173,7 +172,7 @@ var NotesService = class {
 	flushCommittedEffects() {
 		this.store.drainAttachmentCleanup();
 		this.store.drainDeletionCleanup();
-		new DomainOutboxDispatcher(publishAutomationProductEvent).drain(100, "note");
+		new DomainOutboxDispatcher().drain(100, "note");
 	}
 	async quickCapture(markdown, source, idempotencyKey) {
 		const note = this.quickCaptureAtomically(markdown, source, idempotencyKey);

package/dist/src/projects/project-service.js

@@ -8,7 +8,6 @@ import { enqueueProjectChanged } from "./project-change-events.js";
 import { ProjectWorkspaceConflictError, ProjectWorkspaceMissingError, canonicalWorkspacePath, inferProjectNameFromWorkspaceRoot, isPathSameOrInsideWorkspace, isSafeAutoCreateWorkspaceRoot, resolveWorkspaceProjectRoot, workspaceDirectoryExists } from "./workspace-project.js";
 import { drainProjectWorkspaceCreation, queueProjectWorkspaceCreation } from "./project-workspace-creation.js";
 import { DomainOutboxDispatcher } from "../infra/domain-outbox-dispatcher.js";
-import { publishAutomationProductEvent } from "../automations/product-events.js";
 import { listPendingProjectUnderstandingRuns } from "../work-discovery/repository.js";
 import { inferProjectExecutionMode } from "./project-kind.js";
 import { bindSessionToProject, listProjectConversationIds, unbindSessionFromProject } from "./session-bind.js";
@@ -280,7 +279,7 @@ var ProjectService = class {
 	}
 	flushCommittedEffects(projectId) {
 		drainProjectWorkspaceCreation(projectId);
-		new DomainOutboxDispatcher(publishAutomationProductEvent).drain(100, "project");
+		new DomainOutboxDispatcher().drain(100, "project");
 	}
 	listUpdates(projectId, limit) {
 		return this.store.listUpdates(projectId, limit);

package/dist/src/projects/project-skill-service.js

@@ -1,8 +1,8 @@
 import { init_paths, resolveBundledSkillsDir } from "../config/paths.js";
-import { resolveWorkspaceSkillsDir, resolveWorkspaceSkillsLockPath } from "../agent/skills/workspace-skills-dir.js";
-import { loadSkills, loadWorkspaceSkillInventory } from "../agent/skills/index.js";
 import { removeSkillsLockEntry } from "../agent/skills/hub-lock.js";
 import { deleteManagedSkill, installSkillFromZip, isValidSkillId } from "../agent/skills/managed-store.js";
+import { resolveWorkspaceSkillsDir, resolveWorkspaceSkillsLockPath } from "../agent/skills/workspace-skills-dir.js";
+import { loadSkills, loadWorkspaceSkillInventory } from "../agent/skills/index.js";
 import { pullSkillFromSource } from "../agent/skills/hub-pull.js";
 import { downloadFromMarketplace } from "../agent/skills/skills-marketplace.js";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";

package/dist/src/providers/model-call.d.ts

@@ -1,5 +1,6 @@
 import { type Api, type AssistantMessage, type Context, type Model, type SimpleStreamOptions } from '@earendil-works/pi-ai/compat';
 import type { CredentialResolverOptions } from '../auth/credentials.js';
+import type { AiUsageContext } from '../usage/types.js';
 export declare function isLocalModelBaseUrl(baseUrl: string | undefined): boolean;
 /** Codex Responses rejects the temperature request parameter. */
 export declare function supportsModelTemperature(model: Model<Api>): boolean;
@@ -8,10 +9,10 @@ export declare function resolveModelCallOptions(model: Model<Api>, options?: Sim
 /**
  * Complete a one-shot request with xopc credential resolution and extension-provider routing.
  */
-export declare function completeWithResolvedCredentials(model: Model<Api>, context: Context, options?: SimpleStreamOptions, credentialOptions?: CredentialResolverOptions): Promise<AssistantMessage>;
+export declare function completeWithResolvedCredentials(model: Model<Api>, context: Context, options: SimpleStreamOptions, credentialOptions: CredentialResolverOptions | undefined, usageContext: AiUsageContext): Promise<AssistantMessage>;
 /**
  * Start a model stream with xopc credential resolution and extension-provider routing.
  * Callers that need live visible output should consume the returned stream before calling
  * its `result()` method.
  */
-export declare function createResolvedModelStream(model: Model<Api>, context: Context, options?: SimpleStreamOptions, credentialOptions?: CredentialResolverOptions): Promise<import("@earendil-works/pi-ai/compat").AssistantMessageEventStream>;
+export declare function createResolvedModelStream(model: Model<Api>, context: Context, options: SimpleStreamOptions, credentialOptions: CredentialResolverOptions | undefined, usageContext: AiUsageContext): Promise<import("@earendil-works/pi-ai/compat").AssistantMessageEventStream>;

package/dist/src/providers/model-call.js

@@ -1,6 +1,7 @@
 import { init_constants } from "./constants.js";
 import { getApiKey, init_providers } from "./index.js";
 import { createExtensionAwareStreamFn } from "./extension-stream-bridge.js";
+import { finishAiUsageFromMessage, observeAiUsageStream, startAiUsageCall } from "../usage/recorder.js";
 import { completeSimple, normalizeContext } from "@earendil-works/pi-ai/compat";
 //#region src/providers/model-call.ts
 init_constants();
@@ -40,19 +41,43 @@ async function resolveModelCallOptions(model, options = {}, credentialOptions) {
 /**
 * Complete a one-shot request with xopc credential resolution and extension-provider routing.
 */
-async function completeWithResolvedCredentials(model, context, options = {}, credentialOptions) {
+async function completeWithResolvedCredentials(model, context, options, credentialOptions, usageContext) {
 	const resolvedOptions = await resolveModelCallOptions(model, options, credentialOptions);
-	if (model.baseUrl === "extension://provider-plugin") return await (await createExtensionAwareStreamFn()(model, normalizeContext(context), resolvedOptions)).result();
-	return await completeSimple(model, context, resolvedOptions);
+	const usageCall = startAiUsageCall(model, usageContext);
+	try {
+		if (model.baseUrl === "extension://provider-plugin") {
+			const result = await (await createExtensionAwareStreamFn()(model, normalizeContext(context), resolvedOptions)).result();
+			finishAiUsageFromMessage(usageCall, result);
+			return result;
+		}
+		const result = await completeSimple(model, context, resolvedOptions);
+		finishAiUsageFromMessage(usageCall, result);
+		return result;
+	} catch (error) {
+		usageCall?.finish({
+			status: "failed",
+			errorSummary: error instanceof Error ? error.message : String(error)
+		});
+		throw error;
+	}
 }
 /**
 * Start a model stream with xopc credential resolution and extension-provider routing.
 * Callers that need live visible output should consume the returned stream before calling
 * its `result()` method.
 */
-async function createResolvedModelStream(model, context, options = {}, credentialOptions) {
+async function createResolvedModelStream(model, context, options, credentialOptions, usageContext) {
 	const resolvedOptions = await resolveModelCallOptions(model, options, credentialOptions);
-	return await createExtensionAwareStreamFn()(model, normalizeContext(context), resolvedOptions);
+	const usageCall = startAiUsageCall(model, usageContext);
+	try {
+		return observeAiUsageStream(await createExtensionAwareStreamFn()(model, normalizeContext(context), resolvedOptions), usageCall);
+	} catch (error) {
+		usageCall?.finish({
+			status: "failed",
+			errorSummary: error instanceof Error ? error.message : String(error)
+		});
+		throw error;
+	}
 }
 //#endregion
 export { completeWithResolvedCredentials, createResolvedModelStream, isLocalModelBaseUrl, resolveModelCallApiKey, resolveModelCallOptions, supportsModelTemperature };

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

@@ -0,0 +1,19 @@
+import type { ScenePrincipal, SceneTemplate } from './contracts.js';
+/** Extension point for activation shapes that need more than the core read-only setup. */
+export interface SceneActivationAdapter {
+    id: string;
+    preflight(principal: ScenePrincipal, template: SceneTemplate, configuration: unknown): Promise<{
+        ready: boolean;
+        missing: string[];
+    }>;
+    create(principal: ScenePrincipal, template: SceneTemplate, configuration: unknown): Promise<unknown>;
+    get(principal: ScenePrincipal, activationId: string): unknown;
+    configure(principal: ScenePrincipal, activationId: string, expectedRevision: number, configuration: unknown): Promise<unknown>;
+    transition(principal: ScenePrincipal, activationId: string, expectedRevision: number, status: 'active' | 'paused' | 'archived'): Promise<unknown>;
+    tick(): Promise<void>;
+    stop(): Promise<void>;
+    executeTask?(runId: string, conversationId: string): Promise<boolean>;
+    allowsTaskNotification?(taskId: string): boolean;
+    listProjectBranches?(principal: ScenePrincipal, projectId: string): Promise<unknown>;
+    associateBranch?(principal: ScenePrincipal, input: unknown): Promise<unknown>;
+}

package/dist/src/scenes/activationAdapter.js

@@ -0,0 +1 @@
+export {};

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: {