@xopcai/xopc 0.0.391 → 0.0.393

package/dist/src/scenes/capabilities/read.js

@@ -1,187 +0,0 @@
-import { ProductReadContracts } from "../../../packages/gateway-contract/src/capabilities.js";
-import { init_src } from "../../../packages/gateway-contract/src/index.js";
-import { CapabilityError } from "../../capabilities/runtime/errors.js";
-import { defineReadCapability } from "../../capabilities/runtime/dispatcher.js";
-import { SceneNotFoundError } from "../repository.js";
-//#region src/scenes/capabilities/read.ts
-init_src();
-function registerSceneReadCapabilities(dispatcher, getAccess) {
-	const policy = {
-		majorVersion: 1,
-		effect: "read",
-		surfaces: ["http", "agent"],
-		scopes: ["gateway.admin"]
-	};
-	const read = async (context, fn) => {
-		const access = getAccess(context);
-		if (!access) throw new CapabilityError("UNAVAILABLE", "Scene service is unavailable");
-		try {
-			return await fn(access);
-		} catch (error) {
-			if (error instanceof SceneNotFoundError) throw new CapabilityError("NOT_FOUND", "Scene not found");
-			throw error;
-		}
-	};
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.mail_accounts",
-		description: "List eligible scene mail accounts under current account policy.",
-		...ProductReadContracts["xopc.scenes.mail_accounts"],
-		execute: (_input, context) => read(context, ({ services, principal }) => ({ accounts: services.mailDiscovery?.listAccounts(principal) ?? [] }))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.mail_sources",
-		description: "List cached eligible mail source metadata without fetching message bodies.",
-		...ProductReadContracts["xopc.scenes.mail_sources"],
-		execute: ({ limit, afterId }, context) => read(context, ({ services, principal }) => {
-			const sources = services.mail.listSources(principal, limit, afterId);
-			return {
-				sources,
-				nextCursor: sources.length === limit ? sources.at(-1).id : null
-			};
-		})
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.results",
-		description: "List visible scene outcomes scoped to the trusted owner and workspace.",
-		...ProductReadContracts["xopc.scenes.results"],
-		execute: ({ limit, afterId, activationId }, context) => read(context, ({ services, principal }) => {
-			const outcomes = services.repository.listInbox(principal, limit, afterId, activationId ?? null);
-			return ProductReadContracts["xopc.scenes.results"].output.parse({
-				outcomes,
-				nextCursor: outcomes.length === limit ? outcomes.at(-1).id : null
-			});
-		})
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.get_presentation",
-		description: "Read one visible scene presentation.",
-		...ProductReadContracts["xopc.scenes.get_presentation"],
-		execute: ({ id }, context) => read(context, ({ services, principal }) => ProductReadContracts["xopc.scenes.get_presentation"].output.parse({ outcome: services.repository.getPresentation(principal, id) }))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.get_feedback",
-		description: "Read feedback for an authorized scene presentation.",
-		...ProductReadContracts["xopc.scenes.get_feedback"],
-		execute: ({ id }, context) => read(context, ({ services, principal }) => ProductReadContracts["xopc.scenes.get_feedback"].output.parse({ feedback: services.inbox.getFeedback(principal, id) }))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.digest_results",
-		description: "Read a page of authorized digest outcomes.",
-		...ProductReadContracts["xopc.scenes.digest_results"],
-		execute: ({ id, limit, afterId }, context) => read(context, ({ services, principal }) => ProductReadContracts["xopc.scenes.digest_results"].output.parse(services.repository.listDigestResults(principal, id, limit, afterId)))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.metrics",
-		description: "Read owner-scoped scene usefulness metrics in an explicit time window.",
-		...ProductReadContracts["xopc.scenes.metrics"],
-		execute: ({ days }, context) => read(context, ({ services, principal }) => services.metrics.forUser(principal, days))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.diagnostics",
-		description: "Read bounded scene queue and execution diagnostics.",
-		...ProductReadContracts["xopc.scenes.diagnostics"],
-		execute: (_input, context) => read(context, ({ services, principal }) => ProductReadContracts["xopc.scenes.diagnostics"].output.parse(services.metrics.diagnostics(principal)))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.get_preferences",
-		description: "Read owner-scoped scene preferences without changing execution policy.",
-		...ProductReadContracts["xopc.scenes.get_preferences"],
-		execute: (_input, context) => read(context, ({ services, principal }) => services.preferences.get(principal))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.preflight",
-		description: "Check scene setup and requested account/provider permissions without starting execution.",
-		...ProductReadContracts["xopc.scenes.preflight"],
-		execute: (input, context) => read(context, ({ services, principal }) => services.application.preflight(principal, input))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.templates",
-		description: "List installed scene templates.",
-		...ProductReadContracts["xopc.scenes.templates"],
-		execute: (_input, context) => read(context, ({ services }) => ({ templates: services.repository.listTemplates() }))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.get_template",
-		description: "Read an exact installed scene template version.",
-		...ProductReadContracts["xopc.scenes.get_template"],
-		execute: ({ key, version }, context) => read(context, ({ services }) => ({ template: services.repository.getTemplate(key, version) }))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.list",
-		description: "List scenes within the trusted owner and workspace boundary.",
-		...ProductReadContracts["xopc.scenes.list"],
-		execute: ({ limit, afterId }, context) => read(context, ({ services, principal }) => {
-			const activations = services.repository.listActivations(principal, limit, afterId);
-			return {
-				activations,
-				nextCursor: activations.length === limit ? activations.at(-1).id : null
-			};
-		})
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.get",
-		description: "Read a scene and its runs and schedules under the same resource authorization.",
-		...ProductReadContracts["xopc.scenes.get"],
-		execute: ({ id }, context) => read(context, ({ services, principal }) => ProductReadContracts["xopc.scenes.get"].output.parse({
-			activation: services.repository.getActivation(principal, id),
-			runs: services.repository.listRuns(principal, id),
-			schedules: services.repository.listSchedules(principal, id)
-		}))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.read_notes",
-		description: "Read scene notes at their stored revision.",
-		...ProductReadContracts["xopc.scenes.read_notes"],
-		execute: ({ id }, context) => read(context, ({ services, principal }) => ProductReadContracts["xopc.scenes.read_notes"].output.parse({ notes: services.repository.readNotes(principal, id) }))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.list_runs",
-		description: "Page through runs belonging to an authorized scene.",
-		...ProductReadContracts["xopc.scenes.list_runs"],
-		execute: ({ id, limit, afterId }, context) => read(context, ({ services, principal }) => {
-			const runs = services.repository.listRuns(principal, id, limit, afterId);
-			return ProductReadContracts["xopc.scenes.list_runs"].output.parse({
-				runs,
-				nextCursor: runs.length === limit ? runs.at(-1).id : null
-			});
-		})
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.list_schedules",
-		description: "Read the schedules of an authorized scene.",
-		...ProductReadContracts["xopc.scenes.list_schedules"],
-		execute: ({ id }, context) => read(context, ({ services, principal }) => ProductReadContracts["xopc.scenes.list_schedules"].output.parse({ schedules: services.repository.listSchedules(principal, id) }))
-	}));
-	dispatcher.register(defineReadCapability({
-		...policy,
-		id: "xopc.scenes.list_work_items",
-		description: "Page through work items belonging to an authorized scene.",
-		...ProductReadContracts["xopc.scenes.list_work_items"],
-		execute: ({ id, limit, afterId }, context) => read(context, ({ services, principal }) => {
-			const workItems = services.repository.listWorkItems(principal, id, limit, afterId);
-			return ProductReadContracts["xopc.scenes.list_work_items"].output.parse({
-				workItems,
-				nextCursor: workItems.length === limit ? workItems.at(-1).id : null
-			});
-		})
-	}));
-}
-//#endregion
-export { registerSceneReadCapabilities };

package/dist/src/scenes/capabilities/write.d.ts

@@ -1,3 +0,0 @@
-import { type CapabilityContext, type CapabilityDispatcher } from '../../capabilities/runtime/dispatcher.js';
-import type { SceneAccess } from '../httpServices.js';
-export declare function registerSceneWriteCapabilities(dispatcher: CapabilityDispatcher, getAccess: (context: CapabilityContext) => SceneAccess | undefined): void;

package/dist/src/scenes/capabilities/write.js

@@ -1,151 +0,0 @@
-import { getSqliteDatabase, init_transaction } from "../../storage/sqlite/transaction.js";
-import { SceneWriteContracts } from "../../../packages/gateway-contract/src/capabilities.js";
-import { init_src } from "../../../packages/gateway-contract/src/index.js";
-import { CapabilityError } from "../../capabilities/runtime/errors.js";
-import { defineAtomicCapability } from "../../capabilities/runtime/dispatcher.js";
-import { SceneConflictError, SceneInputError, SceneNotFoundError } from "../repository.js";
-import { SceneSetupError } from "../service.js";
-import { z } from "zod";
-//#region src/scenes/capabilities/write.ts
-init_src();
-init_transaction();
-function registerSceneWriteCapabilities(dispatcher, getAccess) {
-	const policy = {
-		majorVersion: 1,
-		effect: "local-write",
-		surfaces: ["http", "agent"],
-		scopes: ["gateway.admin"],
-		requestScope: (context) => {
-			const access = getAccess(context);
-			if (!access) throw new CapabilityError("UNAVAILABLE", "Scene service is unavailable");
-			return JSON.stringify([access.principal.ownerId, access.principal.workspaceId]);
-		}
-	};
-	const write = (context, fn) => {
-		const access = getAccess(context);
-		if (!access) throw new CapabilityError("UNAVAILABLE", "Scene service is unavailable");
-		if (access.services.application.database !== getSqliteDatabase()) throw new CapabilityError("UNAVAILABLE", "Scene writes require the operation database");
-		try {
-			return fn(access);
-		} catch (error) {
-			if (error instanceof SceneNotFoundError) throw new CapabilityError("NOT_FOUND", "Scene not found");
-			if (error instanceof SceneConflictError) throw new CapabilityError("REVISION_CONFLICT", error.message);
-			if (error instanceof SceneInputError || error instanceof z.ZodError) throw new CapabilityError("INVALID_INPUT", error.message);
-			throw error;
-		}
-	};
-	const prepare = async (context, fn) => {
-		const access = getAccess(context);
-		if (!access) throw new CapabilityError("UNAVAILABLE", "Scene service is unavailable");
-		try {
-			await fn(access);
-		} catch (error) {
-			if (error instanceof SceneSetupError) {
-				const failure = new CapabilityError("INVALID_INPUT", error.message);
-				failure.cause = error;
-				throw failure;
-			}
-			if (error instanceof SceneNotFoundError) throw new CapabilityError("NOT_FOUND", "Scene not found");
-			if (error instanceof SceneConflictError) throw new CapabilityError("REVISION_CONFLICT", error.message);
-			throw error;
-		}
-	};
-	dispatcher.register(defineAtomicCapability({
-		...policy,
-		id: "xopc.scenes.start",
-		description: "Start a scene after authorization and readiness checks, with an atomic durable receipt.",
-		...SceneWriteContracts["xopc.scenes.start"],
-		prepare: (input, context) => prepare(context, async ({ services, principal }) => {
-			const result = await services.application.preflight(principal, input);
-			if (!result.ready) throw new SceneSetupError(result.missing);
-		}),
-		execute: (input, context) => write(context, ({ services, principal }) => ({ activation: services.application.startAfterPreflight(principal, input, context.idempotencyKey) }))
-	}));
-	dispatcher.register(defineAtomicCapability({
-		...policy,
-		id: "xopc.scenes.transition",
-		description: "Transition a scene at its exact revision, checking readiness before activation.",
-		...SceneWriteContracts["xopc.scenes.transition"],
-		prepare: ({ id, ...input }, context) => prepare(context, ({ services, principal }) => services.application.prepareTransition(principal, id, input)),
-		execute: ({ id, ...input }, context) => write(context, ({ services, principal }) => ({ activation: services.application.transitionAfterPreflight(principal, id, input) }))
-	}));
-	dispatcher.register(defineAtomicCapability({
-		...policy,
-		id: "xopc.scenes.schedule",
-		description: "Update a scene schedule at its exact revision.",
-		...SceneWriteContracts["xopc.scenes.schedule"],
-		execute: ({ id, triggerKey, ...input }, context) => write(context, ({ services, principal }) => ({ revision: services.application.setSchedule(principal, id, triggerKey, input) }))
-	}));
-	dispatcher.register(defineAtomicCapability({
-		...policy,
-		id: "xopc.scenes.set_preferences",
-		description: "Update owner-scoped scene preferences at their exact revision.",
-		...SceneWriteContracts["xopc.scenes.set_preferences"],
-		execute: (input, context) => write(context, ({ services, principal }) => {
-			if (services.preferences.database !== getSqliteDatabase()) throw new CapabilityError("UNAVAILABLE", "Scene preferences require the operation database");
-			return services.preferences.update(principal, input);
-		})
-	}));
-	dispatcher.register(defineAtomicCapability({
-		...policy,
-		id: "xopc.scenes.feedback",
-		description: "Record an explicit user judgment at the exact feedback revision.",
-		...SceneWriteContracts["xopc.scenes.feedback"],
-		execute: ({ id, ...input }, context) => write(context, ({ services, principal }) => {
-			if (services.inbox.database !== getSqliteDatabase()) throw new CapabilityError("UNAVAILABLE", "Scene feedback requires the operation database");
-			return { revision: services.inbox.feedback(principal, id, input) };
-		})
-	}));
-	dispatcher.register(defineAtomicCapability({
-		...policy,
-		id: "xopc.scenes.mark_read",
-		description: "Set the read state of an actionable scene presentation once per request.",
-		...SceneWriteContracts["xopc.scenes.mark_read"],
-		execute: ({ id, read }, context) => write(context, ({ services, principal }) => {
-			if (services.inbox.database !== getSqliteDatabase()) throw new CapabilityError("UNAVAILABLE", "Scene presentation requires the operation database");
-			services.inbox.setRead(principal, id, read);
-			return {
-				ok: true,
-				presentationId: id,
-				read
-			};
-		})
-	}));
-	dispatcher.register(defineAtomicCapability({
-		...policy,
-		id: "xopc.scenes.configure",
-		description: "Configure a scene at an exact revision and invalidate prior pending work atomically.",
-		...SceneWriteContracts["xopc.scenes.configure"],
-		execute: ({ id, ...input }, context) => write(context, ({ services, principal }) => ({ activation: services.application.configure(principal, id, input) }))
-	}));
-	dispatcher.register(defineAtomicCapability({
-		...policy,
-		id: "xopc.scenes.check",
-		description: "Queue a scene check exactly once per request; this does not imply model execution completed.",
-		...SceneWriteContracts["xopc.scenes.check"],
-		execute: ({ id }, context) => write(context, ({ services, principal }) => ({ intentId: services.application.check(principal, id, context.idempotencyKey) }))
-	}));
-	dispatcher.register(defineAtomicCapability({
-		...policy,
-		id: "xopc.scenes.notes",
-		description: "Replace scene notes at an exact notes revision, canceling stale work in the same transaction.",
-		...SceneWriteContracts["xopc.scenes.notes"],
-		execute: ({ id, ...input }, context) => write(context, ({ services, principal }) => ({ revision: services.application.writeNotes(principal, id, input) }))
-	}));
-	dispatcher.register(defineAtomicCapability({
-		...policy,
-		id: "xopc.scenes.work_item",
-		description: "Create an authorized scene work item with a durable request receipt.",
-		...SceneWriteContracts["xopc.scenes.work_item"],
-		execute: ({ id, ...input }, context) => write(context, ({ services, principal }) => ({ workItem: services.application.createWorkItem(principal, id, input) }))
-	}));
-	dispatcher.register(defineAtomicCapability({
-		...policy,
-		id: "xopc.scenes.update_work_item",
-		description: "Edit an authorized scene work item at its exact revision.",
-		...SceneWriteContracts["xopc.scenes.update_work_item"],
-		execute: ({ id, ...input }, context) => write(context, ({ services, principal }) => ({ workItem: services.application.updateWorkItem(principal, id, input) }))
-	}));
-}
-//#endregion
-export { registerSceneWriteCapabilities };

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

@@ -1,9 +0,0 @@
-export { sceneOutcomeKinds, activationStatuses, sceneScopeSchema, sceneTemplateSchema, scenePermissionSchema, sceneNotesSchema, activationInputSchema, type ActivationStatus, type SceneScope, type SceneTemplate, type ScenePrincipal, type ScenePermission, type ActivationInput, type SceneActivation, } from '@xopcai/gateway-contract';
-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'> & {
-    executionAdapters?: string[];
-}): SceneTemplate;
-export declare function intersectPermissions(...permissions: ScenePermission[]): ScenePermission;
-export declare function canTransitionActivation(from: ActivationStatus, to: ActivationStatus): boolean;

package/dist/src/scenes/contracts.js

@@ -1,61 +0,0 @@
-import { activationInputSchema, activationStatuses, sceneNotesSchema, sceneOutcomeKinds, scenePermissionSchema, sceneScopeSchema, sceneTemplateSchema } from "../../packages/gateway-contract/src/scenes.js";
-import { init_src } from "../../packages/gateway-contract/src/index.js";
-import { createHash } from "node:crypto";
-//#region src/scenes/contracts.ts
-init_src();
-/** Stable JSON hashing binds approvals and immutable versions to exact content. */
-function sceneContentHash(value) {
-	const canonical = (item) => {
-		if (item === null || typeof item === "string" || typeof item === "boolean") return JSON.stringify(item);
-		if (typeof item === "number" && Number.isFinite(item)) return JSON.stringify(item);
-		if (Array.isArray(item)) return `[${item.map(canonical).join(",")}]`;
-		if (typeof item === "object" && Object.getPrototypeOf(item) === Object.prototype) return `{${Object.keys(item).sort().map((key) => `${JSON.stringify(key)}:${canonical(item[key])}`).join(",")}}`;
-		throw new Error("Scene content must be finite JSON");
-	};
-	return createHash("sha256").update(canonical(value)).digest("hex");
-}
-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) {
-	if (permissions.length === 0) return {
-		accountIds: [],
-		contextProviders: [],
-		effectHandlers: []
-	};
-	const common = (key) => [...new Set(permissions[0][key])].filter((id) => permissions.every((permission) => permission[key].includes(id))).sort();
-	return {
-		accountIds: common("accountIds"),
-		contextProviders: common("contextProviders"),
-		effectHandlers: common("effectHandlers")
-	};
-}
-function canTransitionActivation(from, to) {
-	return {
-		needs_setup: [
-			"active",
-			"paused",
-			"archived"
-		],
-		active: [
-			"needs_setup",
-			"paused",
-			"completed",
-			"archived"
-		],
-		paused: [
-			"needs_setup",
-			"active",
-			"completed",
-			"archived"
-		],
-		completed: ["archived"],
-		archived: []
-	}[from].includes(to);
-}
-//#endregion
-export { activationInputSchema, activationStatuses, canTransitionActivation, intersectPermissions, sceneContentHash, sceneNotesSchema, sceneOutcomeKinds, scenePermissionSchema, sceneScopeSchema, sceneTemplateSchema, validateTemplate };

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

@@ -1,62 +0,0 @@
-import { z } from 'zod';
-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<{
-        decision: "decision";
-        artifact: "artifact";
-        observation: "observation";
-        no_change: "no_change";
-    }>;
-    summary: z.ZodString;
-    evidenceIds: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type ReadOnlySceneResult = z.infer<typeof readOnlyResultSchema>;
-export interface SceneEvidence {
-    id: string;
-    subjectId: string;
-    ownerId: string;
-    workspaceId: string;
-    accountId?: string;
-    projectId?: string;
-    conversationId?: string;
-    revision: string;
-    occurredAt?: number;
-    freshUntil: number;
-    content: string;
-}
-export interface SceneContextProvider {
-    id: string;
-    setupIssues?(activation: SceneActivation): string[];
-    authorization?(activation: SceneActivation): string[] | null;
-    tracksHealth?: boolean;
-    requiresAccountIdentity?: boolean;
-    read(input: {
-        activation: SceneActivation;
-        subjectId: string;
-        permissions: ScenePermission;
-        notBefore?: number;
-        signal: AbortSignal;
-    }): Promise<SceneEvidence[]>;
-}
-export interface SceneReadOnlyExecutor {
-    execute(input: {
-        template: SceneTemplate;
-        goal: string;
-        evidence: SceneEvidence[];
-        signal: AbortSignal;
-        usage: AiUsageContext;
-    }): Promise<unknown>;
-}
-/** Runs one durable claim without exposing messaging, filesystem or write tools. */
-export declare class SceneExecutionService {
-    private readonly repository;
-    private readonly providers;
-    private readonly executor;
-    private readonly authorize;
-    private readonly clock;
-    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

@@ -1,169 +0,0 @@
-import { intersectPermissions, sceneContentHash } from "./contracts.js";
-import { SceneSourceNotReady, sceneSourceFailureReason } from "./readiness.js";
-import { z } from "zod";
-//#region src/scenes/execution.ts
-const readOnlyResultSchema = z.strictObject({
-	kind: z.enum([
-		"no_change",
-		"observation",
-		"artifact",
-		"decision"
-	]),
-	summary: z.string().max(32e3),
-	evidenceIds: z.array(z.string().min(1)).max(100)
-}).refine((result) => result.kind === "no_change" || result.summary.trim().length > 0 && result.evidenceIds.length > 0, "A useful result requires evidence");
-var SceneExecutionRejected = class extends Error {
-	constructor(reason) {
-		super(reason);
-		this.reason = reason;
-	}
-};
-function evidenceAllowed(item, activation, permissions, now) {
-	if (!item.id || !item.revision || !Number.isFinite(item.freshUntil) || item.freshUntil <= now) return false;
-	if (item.ownerId !== activation.ownerId || item.workspaceId !== activation.workspaceId) return false;
-	if (item.accountId !== void 0 && !permissions.accountIds.includes(item.accountId)) return false;
-	const scope = activation.scope;
-	if (scope.kind === "objects") return scope.ids.includes(item.subjectId);
-	if (scope.kind === "project") return item.projectId === scope.id;
-	if (scope.kind === "conversation") return item.conversationId === scope.id;
-	return true;
-}
-/** Runs one durable claim without exposing messaging, filesystem or write tools. */
-var SceneExecutionService = class {
-	constructor(repository, providers, executor, authorize, clock = Date.now) {
-		this.repository = repository;
-		this.providers = providers;
-		this.executor = executor;
-		this.authorize = authorize;
-		this.clock = clock;
-	}
-	async runNext(worker, outerSignal) {
-		outerSignal?.throwIfAborted();
-		const claim = this.repository.claimNext(worker, this.clock(), 62e4);
-		if (!claim) return "idle";
-		const runInput = this.repository.getRunInput(claim, this.clock());
-		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);
-		outerSignal?.addEventListener("abort", abort, { once: true });
-		if (outerSignal?.aborted) abort();
-		const timeout = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("Scene execution timed out")), template.execution.limits.timeoutSeconds * 1e3);
-		let stopWaiting;
-		const aborted = new Promise((_, reject) => {
-			const listener = () => reject(controller.signal.reason ?? /* @__PURE__ */ new Error("Scene execution aborted"));
-			controller.signal.addEventListener("abort", listener, { once: true });
-			stopWaiting = () => controller.signal.removeEventListener("abort", listener);
-			if (controller.signal.aborted) listener();
-		});
-		const assertCurrent = () => {
-			controller.signal.throwIfAborted();
-			if (!this.repository.getRunInput(claim, this.clock())) throw new SceneExecutionRejected("activation_changed");
-		};
-		const readContext = async () => {
-			assertCurrent();
-			let granted;
-			try {
-				granted = await this.authorize(activation);
-			} catch (error) {
-				if (template.contextProviders.some((id) => this.providers.get(id).tracksHealth)) this.repository.recordSourceHealth(activation, sceneSourceFailureReason(error), this.clock(), this.clock() + 6e4);
-				throw error;
-			}
-			assertCurrent();
-			const permissions = intersectPermissions(granted, activation.permissions, {
-				accountIds: accountId === void 0 ? activation.permissions.accountIds : [accountId],
-				contextProviders: template.contextProviders,
-				effectHandlers: []
-			});
-			const evidence = [];
-			for (const providerId of template.contextProviders) {
-				const provider = this.providers.get(providerId);
-				if (!permissions.contextProviders.includes(providerId)) {
-					if (provider.tracksHealth) this.repository.recordSourceHealth(activation, "needs_permission", this.clock(), this.clock() + 6e4);
-					throw new SceneExecutionRejected("needs_permission");
-				}
-				let items;
-				try {
-					items = await provider.read({
-						activation,
-						subjectId,
-						permissions,
-						notBefore,
-						signal: controller.signal
-					});
-				} catch (error) {
-					if (provider.tracksHealth && !outerSignal?.aborted) this.repository.recordSourceHealth(activation, sceneSourceFailureReason(error), this.clock(), this.clock() + 6e4);
-					throw error;
-				}
-				assertCurrent();
-				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);
-			}
-			if (evidence.length > 100 || evidence.reduce((size, item) => size + item.content.length, 0) > 12e4) throw new SceneExecutionRejected("context_budget_exceeded");
-			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.some((id) => this.providers.get(id).tracksHealth)) this.repository.recordSourceHealth(activation, null, this.clock());
-			return {
-				evidence,
-				fingerprint,
-				permissions
-			};
-		};
-		const execute = async () => {
-			const snapshot = await readContext();
-			if (!this.repository.saveSnapshot(claim, snapshot.fingerprint, snapshot.evidence.map((item) => item.id), this.clock())) return "discarded";
-			if (this.repository.reuseUnchangedResult(claim, snapshot.fingerprint, this.clock(), true)) {
-				const current = await readContext();
-				assertCurrent();
-				if (current.fingerprint !== snapshot.fingerprint || sceneContentHash(current.permissions) !== sceneContentHash(snapshot.permissions)) throw new SceneExecutionRejected("source_changed");
-				if (this.repository.reuseUnchangedResult(claim, snapshot.fingerprint, this.clock())) return "completed";
-			}
-			if (snapshot.evidence.length > 0 && !this.repository.reserveModelCall(claim, this.clock())) {
-				const now = this.clock();
-				return this.repository.deferRun(claim, now, "daily_budget", (Math.floor(now / 864e5) + 1) * 864e5);
-			}
-			const raw = snapshot.evidence.length === 0 ? {
-				kind: "no_change",
-				summary: "",
-				evidenceIds: []
-			} : await this.executor.execute({
-				template,
-				goal: activation.goal,
-				evidence: snapshot.evidence,
-				signal: controller.signal,
-				usage: {
-					operation: "scene.execute",
-					traceId: claim.id,
-					runId: claim.id,
-					...activation.scope.kind === "conversation" ? { conversationId: activation.scope.id } : {}
-				}
-			});
-			assertCurrent();
-			const result = readOnlyResultSchema.parse(raw);
-			if (!template.allowedOutcomeKinds.includes(result.kind)) throw new SceneExecutionRejected("invalid_model_result");
-			if (result.evidenceIds.some((id) => !snapshot.evidence.some((item) => item.id === id))) throw new SceneExecutionRejected("unknown_evidence");
-			const current = await readContext();
-			assertCurrent();
-			if (current.fingerprint !== snapshot.fingerprint || sceneContentHash(current.permissions) !== sceneContentHash(snapshot.permissions)) throw new SceneExecutionRejected("source_changed");
-			return this.repository.finishReadOnlyRun(claim, result, this.clock()) ? "completed" : "discarded";
-		};
-		try {
-			return await Promise.race([execute(), aborted]);
-		} catch (error) {
-			if (!controller.signal.aborted && error instanceof SceneSourceNotReady) return this.repository.deferRun(claim, this.clock(), "source_not_ready", this.clock() + 6e4);
-			this.repository.failRun(claim, this.clock(), controller.signal.aborted ? "execution_aborted" : error instanceof SceneExecutionRejected ? error.reason : error instanceof z.ZodError || error instanceof SyntaxError ? "invalid_model_result" : "execution_failed");
-			return "failed";
-		} finally {
-			clearTimeout(timeout);
-			stopWaiting?.();
-			outerSignal?.removeEventListener("abort", abort);
-		}
-	}
-};
-//#endregion
-export { SceneExecutionService, readOnlyResultSchema };