@xopcai/xopc 0.0.313 → 0.0.315

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

@@ -0,0 +1,187 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,151 @@
+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,108 +1,5 @@
-import { z } from 'zod';
-export declare const sceneOutcomeKinds: readonly ["no_change", "observation", "artifact", "decision", "state_change", "effect_proposal", "receipt"];
-export declare const activationStatuses: readonly ["needs_setup", "active", "paused", "completed", "archived"];
-export type ActivationStatus = typeof activationStatuses[number];
-export declare const sceneScopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"personal">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"project">;
-    id: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"conversation">;
-    id: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"objects">;
-    ids: z.ZodArray<z.ZodString>;
-}, z.core.$strict>], "kind">;
-export type SceneScope = z.infer<typeof sceneScopeSchema>;
-export declare const sceneTemplateSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
-    key: z.ZodString;
-    version: z.ZodString;
-    title: z.ZodString;
-    description: z.ZodString;
-    goalMode: z.ZodEnum<{
-        finite: "finite";
-        ongoing: "ongoing";
-    }>;
-    contextProviders: z.ZodArray<z.ZodString>;
-    triggers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodLiteral<"manual">;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodLiteral<"event">;
-        eventType: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodLiteral<"schedule">;
-    }, z.core.$strict>], "type">>;
-    execution: z.ZodObject<{
-        kind: z.ZodLiteral<"agent">;
-        instruction: z.ZodString;
-        limits: z.ZodObject<{
-            timeoutSeconds: z.ZodNumber;
-            maxIterations: z.ZodNumber;
-            maxToolCalls: z.ZodNumber;
-            maxOutputTokens: z.ZodNumber;
-        }, z.core.$strict>;
-    }, z.core.$strict>;
-    allowedOutcomeKinds: z.ZodArray<z.ZodEnum<{
-        artifact: "artifact";
-        receipt: "receipt";
-        decision: "decision";
-        observation: "observation";
-        no_change: "no_change";
-        state_change: "state_change";
-        effect_proposal: "effect_proposal";
-    }>>;
-    allowedEffectHandlers: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type SceneTemplate = z.infer<typeof sceneTemplateSchema>;
-export interface ScenePrincipal {
-    ownerId: string;
-    workspaceId: string;
-}
-export declare const scenePermissionSchema: z.ZodObject<{
-    accountIds: z.ZodArray<z.ZodString>;
-    contextProviders: z.ZodArray<z.ZodString>;
-    effectHandlers: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type ScenePermission = z.infer<typeof scenePermissionSchema>;
-export declare const sceneNotesSchema: z.ZodObject<{
-    expectedRevision: z.ZodNumber;
-    content: z.ZodString;
-    validUntil: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-}, z.core.$strict>;
-export declare const activationInputSchema: z.ZodObject<{
-    templateKey: z.ZodString;
-    templateVersion: z.ZodString;
-    goal: z.ZodString;
-    scope: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"personal">;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"project">;
-        id: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"conversation">;
-        id: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"objects">;
-        ids: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>], "kind">;
-    permissions: z.ZodObject<{
-        accountIds: z.ZodArray<z.ZodString>;
-        contextProviders: z.ZodArray<z.ZodString>;
-        effectHandlers: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type ActivationInput = z.infer<typeof activationInputSchema>;
-export interface SceneActivation extends ActivationInput, ScenePrincipal {
-    id: string;
-    status: ActivationStatus;
-    setupMissing?: string[];
-    revision: number;
-}
+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'>): SceneTemplate;

package/dist/src/scenes/contracts.js

@@ -1,93 +1,8 @@
+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";
-import { z } from "zod";
 //#region src/scenes/contracts.ts
-const identifier = z.string().trim().min(1).max(200);
-const uniqueIds = z.array(identifier).max(100).refine((items) => new Set(items).size === items.length, "Duplicate identifiers");
-const sceneOutcomeKinds = [
-	"no_change",
-	"observation",
-	"artifact",
-	"decision",
-	"state_change",
-	"effect_proposal",
-	"receipt"
-];
-const activationStatuses = [
-	"needs_setup",
-	"active",
-	"paused",
-	"completed",
-	"archived"
-];
-const sceneScopeSchema = z.discriminatedUnion("kind", [
-	z.strictObject({ kind: z.literal("personal") }),
-	z.strictObject({
-		kind: z.literal("project"),
-		id: identifier
-	}),
-	z.strictObject({
-		kind: z.literal("conversation"),
-		id: identifier
-	}),
-	z.strictObject({
-		kind: z.literal("objects"),
-		ids: uniqueIds.refine((ids) => ids.length > 0)
-	})
-]);
-const limitsSchema = z.strictObject({
-	timeoutSeconds: z.number().int().min(1).max(600),
-	maxIterations: z.number().int().min(1).max(30),
-	maxToolCalls: z.number().int().min(0).max(100),
-	maxOutputTokens: z.number().int().min(1).max(32768)
-});
-const sceneTemplateSchema = z.strictObject({
-	schemaVersion: z.literal(1),
-	key: z.string().regex(/^[a-z][a-z0-9-]{0,79}$/),
-	version: z.string().regex(/^\d+\.\d+\.\d+$/),
-	title: z.string().trim().min(1).max(120),
-	description: z.string().trim().min(1).max(2e3),
-	goalMode: z.enum(["finite", "ongoing"]),
-	contextProviders: uniqueIds,
-	triggers: z.array(z.discriminatedUnion("type", [
-		z.strictObject({
-			id: identifier,
-			type: z.literal("manual")
-		}),
-		z.strictObject({
-			id: identifier,
-			type: z.literal("event"),
-			eventType: identifier
-		}),
-		z.strictObject({
-			id: identifier,
-			type: z.literal("schedule")
-		})
-	])).min(1).max(20).refine((items) => new Set(items.map((item) => item.id)).size === items.length, "Duplicate trigger IDs"),
-	execution: z.strictObject({
-		kind: z.literal("agent"),
-		instruction: z.string().trim().min(1).max(32e3),
-		limits: limitsSchema
-	}),
-	allowedOutcomeKinds: z.array(z.enum(sceneOutcomeKinds)).min(1),
-	allowedEffectHandlers: uniqueIds
-});
-const scenePermissionSchema = z.strictObject({
-	accountIds: uniqueIds,
-	contextProviders: uniqueIds,
-	effectHandlers: uniqueIds
-});
-const sceneNotesSchema = z.strictObject({
-	expectedRevision: z.number().int().nonnegative(),
-	content: z.string().trim().max(32e3),
-	validUntil: z.number().int().nonnegative().nullable().default(null)
-});
-const activationInputSchema = z.strictObject({
-	templateKey: identifier,
-	templateVersion: identifier,
-	goal: z.string().trim().min(1).max(12e3),
-	scope: sceneScopeSchema,
-	permissions: scenePermissionSchema
-});
+init_src();
 /** Stable JSON hashing binds approvals and immutable versions to exact content. */
 function sceneContentHash(value) {
 	const canonical = (item) => {

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

@@ -5,8 +5,8 @@ export declare const readOnlyResultSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         artifact: "artifact";
         decision: "decision";
-        observation: "observation";
         no_change: "no_change";
+        observation: "observation";
     }>;
     summary: z.ZodString;
     evidenceIds: z.ZodArray<z.ZodString>;

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

@@ -6,8 +6,10 @@ 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';
 /** An explicitly installed scene domain; never resolves to the old runtime. */
 export interface SceneHttpServices {
+    followUps?: TaskFollowUpService;
     repository: SceneRepository;
     application: SceneApplicationService;
     inbox: SceneInboxService;

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

@@ -5,6 +5,7 @@ export declare class SceneInboxService {
     private readonly db;
     private readonly clock;
     constructor(db: DatabaseSync, clock?: () => number);
+    get database(): DatabaseSync;
     setRead(principal: ScenePrincipal, id: string, read: boolean): void;
     feedback(principal: ScenePrincipal, id: string, value: unknown): number;
     getFeedback(principal: ScenePrincipal, id: string): {

package/dist/src/scenes/inbox.js

@@ -1,12 +1,9 @@
+import { SceneFeedbackSchema } from "../../packages/gateway-contract/src/scenes.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { SceneConflictError, SceneNotFoundError } from "./repository.js";
 import { randomUUID } from "node:crypto";
-import { z } from "zod";
 //#region src/scenes/inbox.ts
-const feedbackSchema = z.strictObject({
-	expectedRevision: z.number().int().nonnegative(),
-	rating: z.enum(["useful", "not_useful"]),
-	note: z.string().trim().max(2e3).optional()
-});
+init_src();
 const actionable = `withdrawn_at IS NULL AND (expires_at IS NULL OR expires_at > ?)
   AND (status IN ('unread', 'read') OR (status = 'snoozed' AND snoozed_until <= ?))`;
 /** Feedback records a user's judgment, never an inferred successful action. */
@@ -15,6 +12,9 @@ var SceneInboxService = class {
 		this.db = db;
 		this.clock = clock;
 	}
+	get database() {
+		return this.db;
+	}
 	setRead(principal, id, read) {
 		if (typeof read !== "boolean") throw new Error("Read state must be a boolean");
 		this.assertVisible(principal, id);
@@ -22,7 +22,7 @@ var SceneInboxService = class {
 		if (this.db.prepare(`UPDATE scene_presentations SET status = ?, revision = revision + 1, updated_at = ? WHERE id = ? AND ${actionable}`).run(read ? "read" : "unread", now, id, now, now).changes !== 1) throw new SceneConflictError("Scene presentation was withdrawn");
 	}
 	feedback(principal, id, value) {
-		const input = feedbackSchema.parse(value);
+		const input = SceneFeedbackSchema.parse(value);
 		this.assertVisible(principal, id);
 		this.db.exec("SAVEPOINT scene_feedback_write");
 		try {

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

@@ -1,33 +1,12 @@
 import type { DatabaseSync } from 'node:sqlite';
-import { z } from 'zod';
 import type { ScenePrincipal } from './contracts.js';
-export declare const scenePreferencesSchema: z.ZodObject<{
-    level: z.ZodDefault<z.ZodEnum<{
-        active: "active";
-        quiet: "quiet";
-        balanced: "balanced";
-    }>>;
-    timezone: z.ZodDefault<z.ZodString>;
-    quietStartHour: z.ZodDefault<z.ZodNumber>;
-    quietEndHour: z.ZodDefault<z.ZodNumber>;
-    dailyNotificationLimit: z.ZodDefault<z.ZodNumber>;
-    digestEnabled: z.ZodDefault<z.ZodBoolean>;
-    digestHour: z.ZodDefault<z.ZodNumber>;
-    digestMinute: z.ZodDefault<z.ZodNumber>;
-    preferredChannel: z.ZodDefault<z.ZodEnum<{
-        browser: "browser";
-        in_app: "in_app";
-    }>>;
-    suppressWhileViewing: z.ZodDefault<z.ZodBoolean>;
-    checksPaused: z.ZodDefault<z.ZodBoolean>;
-    checksPausedUntil: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    notificationsMuted: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strict>;
-export type ScenePreferences = z.infer<typeof scenePreferencesSchema>;
+import { type ScenePreferences } from '@xopcai/gateway-contract';
+export { scenePreferencesSchema, type ScenePreferences } from '@xopcai/gateway-contract';
 /** Owner-scoped choices. Muting presentation never changes check permissions or deletes work. */
 export declare class ScenePreferenceService {
     private readonly db;
     constructor(db: DatabaseSync);
+    get database(): DatabaseSync;
     get(principal: ScenePrincipal): ScenePreferences & {
         revision: number;
     };