@nikelyh/offscript 0.0.0-stage → 1.0.0

package/dist/packages/orchestration/tools/browser-interaction-tools.js

@@ -0,0 +1,74 @@
+import { argumentsObject, argumentText } from "./arguments.js";
+export function browserInteractionTools(tool, browserSession, onActivity) {
+    const text = { type: "string", minLength: 1 };
+    return [
+        tool("browser_navigate", "Navigate to an authorized URL or path in the target web application.", { url: text }, async (value) => {
+            const args = argumentsObject(value, ["url"]);
+            const url = argumentText(args.url);
+            onActivity?.("navigate", url);
+            const result = await browserSession.navigate(url);
+            if (!result.success)
+                throw new Error(result.error || "Navigation failed.");
+            return { currentUrl: result.url };
+        }),
+        tool("browser_inspect", "Inspect current page DOM and accessibility tree, returning visible text, title, and interactive element handles.", {}, async () => {
+            onActivity?.("inspect");
+            const snapshot = await browserSession.inspect();
+            return {
+                url: snapshot.url,
+                title: snapshot.title,
+                textSummary: snapshot.textSummary,
+                ariaSnapshot: snapshot.ariaSnapshot,
+                elements: snapshot.elements.map((el) => ({
+                    ref: el.ref,
+                    role: el.role,
+                    name: el.name,
+                    text: el.text,
+                    disabled: el.disabled,
+                    ...(el.type ? { type: el.type } : {}),
+                    ...(el.placeholder ? { placeholder: el.placeholder } : {}),
+                    ...(el.checked !== undefined ? { checked: el.checked } : {}),
+                    ...(el.expanded !== undefined ? { expanded: el.expanded } : {}),
+                })),
+            };
+        }),
+        tool("browser_click", "Click an interactive element on the current page using its opaque reference (e.g. elem_1).", { ref: text }, async (value) => {
+            const args = argumentsObject(value, ["ref"]);
+            const ref = argumentText(args.ref);
+            onActivity?.("click", ref);
+            const result = await browserSession.click(ref);
+            if (!result.success)
+                throw new Error(result.error || "Click failed.");
+            return { currentUrl: result.url };
+        }),
+        tool("browser_type", "Type text into an input or editable element using its opaque reference.", { ref: text, text: { type: "string" } }, async (value) => {
+            const args = argumentsObject(value, ["ref", "text"]);
+            const ref = argumentText(args.ref);
+            const inputContent = typeof args.text === "string" ? args.text : "";
+            onActivity?.("type", ref);
+            const result = await browserSession.type(ref, inputContent);
+            if (!result.success)
+                throw new Error(result.error || "Type failed.");
+            return { currentUrl: result.url };
+        }),
+        tool("browser_scroll", "Scroll the page up or down to reveal hidden content or elements below the fold.", { direction: { type: "string", enum: ["up", "down"] } }, async (value) => {
+            const args = argumentsObject(value, ["direction"]);
+            const dir = args.direction === "up" ? "up" : "down";
+            onActivity?.("scroll", dir);
+            const result = await browserSession.scroll(dir);
+            if (!result.success)
+                throw new Error(result.error || "Scroll failed.");
+            return { currentUrl: result.url };
+        }),
+        tool("browser_select", "Select an option on a select or dropdown element using its opaque reference (e.g. elem_1) and option value.", { ref: text, value: text }, async (value) => {
+            const args = argumentsObject(value, ["ref", "value"]);
+            const ref = argumentText(args.ref);
+            const val = argumentText(args.value);
+            onActivity?.("select", `${ref}=${val}`);
+            const result = await browserSession.select(ref, val);
+            if (!result.success)
+                throw new Error(result.error || "Select failed.");
+            return { currentUrl: result.url };
+        }),
+    ];
+}

package/dist/packages/orchestration/tools/exploration-tools.js

@@ -0,0 +1,119 @@
+import { randomUUID } from "node:crypto";
+import { createObservation, evidenceId, investigationId, observationId } from "../../domain/index.js";
+import { parseSemanticEvent } from "../../contracts/index.js";
+import { executeCompleteInvestigation, executeRequestInvestigation } from "../../application/index.js";
+import { sessionStorage } from "../session-storage.js";
+import { argumentsObject, argumentText } from "./arguments.js";
+export function explorationTools(state, id, publish, storage = sessionStorage(state)) {
+    function tool(name, description, properties, invoke) {
+        return {
+            type: "function", name, description, strict: true,
+            parameters: { type: "object", properties, required: Object.keys(properties), additionalProperties: false },
+            async invoke(args) {
+                try {
+                    if (state.closed || !state.permissions.get(id)?.has(name))
+                        throw new Error("Tool action is not allowed in this session.");
+                    return await invoke(args);
+                }
+                catch (cause) {
+                    state.fail(`tool:${name}`, id, cause);
+                    return { error: "Tool action rejected or failed. No permission was granted by this response." };
+                }
+            },
+        };
+    }
+    const text = { type: "string", minLength: 1 };
+    const tools = [
+        tool("inspect_application", "Inspect the local simulated cart before or after reload. This is not a real browser.", {
+            phase: { type: "string", enum: ["before_reload", "after_reload"] },
+        }, async (value) => {
+            const args = argumentsObject(value, ["phase"]);
+            if (args.phase !== "before_reload" && args.phase !== "after_reload")
+                throw new Error("Unknown inspection phase.");
+            return { location: "/cart", itemCount: args.phase === "before_reload" ? 1 : 0, source: "simulated-fixture" };
+        }),
+        tool("record_observation", "Record noticed behavior as untrusted observation data, without confirming a defect.", {
+            description: text, location: text,
+        }, async (value) => {
+            const args = argumentsObject(value, ["description", "location"]);
+            const desc = argumentText(args.description);
+            const loc = argumentText(args.location);
+            for (const existing of state.observations.values()) {
+                if (existing.simulationId === state.simulation.id && existing.agentId === id &&
+                    existing.description === desc && existing.context.location === loc) {
+                    return { observationId: existing.id, evidenceId: existing.evidenceIds[0] ?? "" };
+                }
+            }
+            const eid = evidenceId(`ev-${randomUUID()}`);
+            const observation = createObservation({
+                id: observationId(randomUUID()), simulationId: state.simulation.id, agentId: id,
+                observedAt: new Date().toISOString(), description: desc,
+                context: { location: loc }, evidenceIds: [eid],
+            });
+            if (await storage.observations.createObservation(observation) !== "created")
+                throw new Error("Observation identity already exists.");
+            state.observations.set(observation.id, observation);
+            publish(parseSemanticEvent({
+                eventId: randomUUID(), type: "observation.created", schemaVersion: 1, occurredAt: observation.observedAt,
+                simulationId: state.simulation.id, origin: { kind: "agent", agentId: id },
+                correlationId: state.simulation.id, payload: { observation },
+            }));
+            return { observationId: observation.id, evidenceId: eid };
+        }),
+        tool("request_investigation", "Request collaborative examination of existing observations, without assigning or confirming findings.", {
+            hypothesis: text, observationIds: { type: "array", items: text, minItems: 1, uniqueItems: true },
+        }, async (value) => {
+            const args = argumentsObject(value, ["hypothesis", "observationIds"]);
+            if (!Array.isArray(args.observationIds))
+                throw new Error("Expected observation identities.");
+            const references = Array.from(args.observationIds, (entry) => observationId(argumentText(entry)));
+            const result = await executeRequestInvestigation({
+                investigationId: investigationId(randomUUID()), simulationId: state.simulation.id, requestedBy: id,
+                observationIds: references, hypothesis: argumentText(args.hypothesis), requestedAt: new Date().toISOString(),
+                eventId: randomUUID(), correlationId: state.simulation.id,
+            }, {
+                simulations: { async findSimulation(key) { return key === state.simulation.id ? state.simulation : undefined; } },
+                observations: storage.observations,
+                investigations: storage.investigations,
+            });
+            return { investigationId: result.investigation.id, publication: result.publication.status };
+        }),
+        tool("complete_investigation", "Record an assessment outcome for an assigned investigation with explanation and evidence references.", {
+            investigationId: text,
+            outcome: { type: "string", enum: ["supported", "contradicted", "inconclusive"] },
+            explanation: text,
+            evidenceIds: { type: "array", items: text },
+        }, async (value) => {
+            const args = argumentsObject(value, ["investigationId", "outcome", "explanation", "evidenceIds"]);
+            if (args.outcome !== "supported" && args.outcome !== "contradicted" && args.outcome !== "inconclusive") {
+                throw new Error("Invalid investigation outcome.");
+            }
+            const evidence = Array.isArray(args.evidenceIds)
+                ? args.evidenceIds.map((item) => argumentText(item))
+                : [];
+            const result = await executeCompleteInvestigation({
+                investigationId: investigationId(argumentText(args.investigationId)),
+                simulationId: state.simulation.id,
+                completedBy: id,
+                result: {
+                    outcome: args.outcome,
+                    explanation: argumentText(args.explanation),
+                    evidenceIds: evidence.map(evidenceId),
+                },
+                origin: { kind: "agent", agentId: id },
+                completedAt: new Date().toISOString(),
+                eventId: randomUUID(),
+                correlationId: state.simulation.id,
+            }, {
+                simulations: { async findSimulation(key) { return key === state.simulation.id ? state.simulation : undefined; } },
+                investigations: storage.investigations,
+            });
+            return {
+                investigationId: result.investigation.id,
+                outcome: result.investigation.lifecycle.result.outcome,
+                status: result.investigation.lifecycle.status,
+            };
+        }),
+    ];
+    return tools.filter((entry) => state.permissions.get(id)?.has(entry.name));
+}

package/dist/packages/persistence/codecs/investigation.js

@@ -0,0 +1,30 @@
+import { asc, eq } from "drizzle-orm";
+import { parseInvestigationSummary } from "../../contracts/index.js";
+import { investigations, investigationAgents, investigationObservations } from "../schema/index.js";
+import { PersistenceError } from "../errors.js";
+import { json, stored } from "./values.js";
+export function readInvestigation(db, id) {
+    const row = db.select().from(investigations).where(eq(investigations.id, id)).get();
+    if (!row)
+        return undefined;
+    const links = db.select().from(investigationObservations).where(eq(investigationObservations.investigationId, id)).orderBy(asc(investigationObservations.position)).all();
+    const agents = db.select().from(investigationAgents).where(eq(investigationAgents.investigationId, id)).orderBy(asc(investigationAgents.position)).all();
+    return stored(() => {
+        if (links.some((link) => link.simulationId !== row.simulationId) || agents.some((agent) => agent.simulationId !== row.simulationId)) {
+            throw new PersistenceError("INVALID_STORED_DATA", "Investigation links cross simulation scope.");
+        }
+        if (row.status === "requested" && agents.length)
+            throw new PersistenceError("INVALID_STORED_DATA", "Requested investigation has assignees.");
+        const lifecycle = row.status === "requested" ? { status: row.status } : {
+            status: row.status, agentIds: agents.map((agent) => agent.agentId), assignedAt: row.assignedAt,
+            ...(row.status === "completed" ? { completedAt: row.completedAt, completedBy: row.completedBy, result: row.result === null ? null : json(row.result) } : {}),
+        };
+        const investigation = parseInvestigationSummary({
+            id: row.id, simulationId: row.simulationId, requestedBy: row.requestedBy, hypothesis: row.hypothesis,
+            requestedAt: row.requestedAt, observationIds: links.map((link) => link.observationId), lifecycle,
+        });
+        if (!Number.isSafeInteger(row.revision) || row.revision < 0)
+            throw new PersistenceError("INVALID_STORED_DATA", "Invalid storage revision.");
+        return Object.freeze({ investigation, revision: row.revision });
+    });
+}

package/dist/packages/persistence/codecs/simulation.js

@@ -0,0 +1,69 @@
+import { createAgent, createAgentProfile, createSimulation, transitionSimulation, updateSimulationAgent } from "../../domain/index.js";
+import { parseAgentSummary, parseSimulationSummary } from "../../contracts/index.js";
+import { agents, simulations } from "../schema/index.js";
+import { PersistenceError } from "../errors.js";
+import { json, object, stored, text } from "./values.js";
+function profile(value) {
+    const input = object(value, ["name", "personality", "goals", "capabilities"]);
+    if (!Array.isArray(input.goals) || !Array.isArray(input.capabilities)) {
+        throw new PersistenceError("INVALID_STORED_DATA", "Stored profile goals/capabilities must be arrays.");
+    }
+    return createAgentProfile({
+        name: text(input.name), personality: text(input.personality),
+        goals: Array.from(input.goals, (goal) => ({ description: text(object(goal, ["description"]).description) })),
+        capabilities: Array.from(input.capabilities, (capability) => text(capability)),
+    });
+}
+function lifecycle(row) {
+    return row.reason === null ? { status: row.status } : { status: row.status, reason: row.reason };
+}
+export function restoreSimulation(row, members) {
+    return stored(() => {
+        const summary = parseSimulationSummary({
+            id: row.id, environment: { kind: row.environment, deployment: row.deployment },
+            lifecycle: lifecycle(row), agentIds: members.map((member) => member.id),
+        });
+        const parsed = members.map((member) => {
+            if (member.simulationId !== row.id)
+                throw new PersistenceError("INVALID_STORED_DATA", "Agent belongs to another simulation.");
+            const parsedProfile = profile(json(member.profile));
+            return { profile: parsedProfile, summary: parseAgentSummary({
+                    id: member.id, simulationId: row.id, name: parsedProfile.name, lifecycle: lifecycle(member),
+                }) };
+        });
+        let simulation = createSimulation(summary.id, summary.environment, parsed.map((member) => createAgent(member.summary.id, member.profile)));
+        const status = summary.lifecycle.status;
+        if (status !== "created") {
+            if (status === "cancelled" && parsed.length === 0)
+                return transitionSimulation(simulation, { status: "cancelled" });
+            simulation = transitionSimulation(simulation, { status: "running" });
+            for (const member of parsed) {
+                const target = member.summary.lifecycle;
+                if (target.status === "ready")
+                    continue;
+                if (target.status !== "cancelled")
+                    simulation = updateSimulationAgent(simulation, member.summary.id, { status: "running" });
+                if (target.status !== "running")
+                    simulation = updateSimulationAgent(simulation, member.summary.id, target);
+            }
+            if (status !== "running")
+                simulation = transitionSimulation(simulation, summary.lifecycle);
+        }
+        if (parsed.some((member, index) => JSON.stringify(member.summary.lifecycle) !== JSON.stringify(simulation.agents[index]?.lifecycle))) {
+            throw new PersistenceError("INVALID_STORED_DATA", "Simulation and participation lifecycles are inconsistent.");
+        }
+        return simulation;
+    });
+}
+export function simulationRows(simulation) {
+    const row = {
+        id: simulation.id, environment: simulation.environment.kind, deployment: simulation.environment.deployment,
+        status: simulation.lifecycle.status, reason: simulation.lifecycle.status === "failed" ? simulation.lifecycle.reason : null,
+    };
+    const members = simulation.agents.map((agent, position) => ({
+        simulationId: simulation.id, id: agent.id, position, profile: JSON.stringify(agent.profile),
+        status: agent.lifecycle.status, reason: agent.lifecycle.status === "failed" ? agent.lifecycle.reason : null,
+    }));
+    restoreSimulation(row, members);
+    return { row, members };
+}

package/dist/packages/persistence/codecs/values.js

@@ -0,0 +1,24 @@
+import { PersistenceError } from "../errors.js";
+export function object(value, fields) {
+    if (!value || typeof value !== "object" || Array.isArray(value) ||
+        Reflect.ownKeys(value).some((key) => typeof key !== "string" || !fields.includes(key))) {
+        throw new PersistenceError("INVALID_STORED_DATA", "Invalid stored object shape.");
+    }
+    return value;
+}
+export function text(value) {
+    if (typeof value !== "string" || !value.trim())
+        throw new PersistenceError("INVALID_STORED_DATA", "Expected stored nonblank text.");
+    return value;
+}
+export function json(value) { return JSON.parse(value); }
+export function stored(read) {
+    try {
+        return read();
+    }
+    catch (cause) {
+        if (cause instanceof PersistenceError)
+            throw cause;
+        throw new PersistenceError("INVALID_STORED_DATA", "Stored data failed domain/contract validation.", { cause });
+    }
+}

package/dist/packages/persistence/connection.js

@@ -0,0 +1,29 @@
+import { mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+export function openConnection(options) {
+    if (!options.projectRoot.trim())
+        throw new Error("An explicit project root is required.");
+    if (options.dataDirectory !== undefined && !options.dataDirectory.trim())
+        throw new Error("Data directory must not be blank.");
+    const timeout = options.busyTimeoutMs ?? 2_500;
+    if (!Number.isSafeInteger(timeout) || timeout < 0 || timeout > 30_000)
+        throw new Error("Busy timeout must be between 0 and 30000 ms.");
+    const dataDirectory = resolve(options.projectRoot, options.dataDirectory ?? ".offscript");
+    mkdirSync(dataDirectory, { recursive: true });
+    const databasePath = resolve(dataDirectory, "offscript.sqlite");
+    const client = new Database(databasePath, { timeout });
+    try {
+        client.pragma("foreign_keys = ON");
+        if (client.pragma("journal_mode = WAL", { simple: true }) !== "wal")
+            throw new Error("SQLite WAL mode could not be enabled.");
+        client.pragma("synchronous = FULL");
+        client.pragma(`busy_timeout = ${timeout}`);
+        return { client, db: drizzle(client), databasePath };
+    }
+    catch (error) {
+        client.close();
+        throw error;
+    }
+}

package/dist/packages/persistence/errors.js

@@ -0,0 +1,8 @@
+export class PersistenceError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "PersistenceError";
+        this.code = code;
+    }
+}

package/dist/packages/persistence/index.js

@@ -0,0 +1,22 @@
+import { openConnection } from "./connection.js";
+import { migrateDatabase } from "./migrate.js";
+import { simulationRepository } from "./repositories/simulations.js";
+import { observationRepository } from "./repositories/observations.js";
+import { investigationRepository } from "./repositories/investigations.js";
+import { investigationCommitter } from "./outbox/committer.js";
+import { outboxStore } from "./outbox/store.js";
+import { configurationRepository } from "./repositories/configurations.js";
+export function openPersistence(options) {
+    const connection = openConnection(options);
+    return Object.freeze({
+        databasePath: connection.databasePath,
+        migrate() { migrateDatabase(connection.db); },
+        simulations: simulationRepository(connection.db), observations: observationRepository(connection.db),
+        investigations: Object.freeze({ ...investigationRepository(connection.db), ...investigationCommitter(connection.db) }),
+        outbox: outboxStore(connection.db),
+        configurations: configurationRepository(connection.db),
+        close() { if (connection.client.open)
+            connection.client.close(); },
+    });
+}
+export { PersistenceError } from "./errors.js";

package/dist/packages/persistence/migrate.js

@@ -0,0 +1,40 @@
+import { fileURLToPath } from "node:url";
+import { sql } from "drizzle-orm";
+import { readMigrationFiles } from "drizzle-orm/migrator";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { PersistenceError } from "./errors.js";
+const history = sqliteTable("__offscript_migrations", {
+    version: integer("version").primaryKey(), hash: text("hash").notNull(), createdAt: integer("created_at").notNull(),
+});
+const defaultFolder = fileURLToPath(new URL("./migrations", import.meta.url));
+export function migrateDatabase(db, folder = defaultFolder) {
+    try {
+        const migrations = readMigrationFiles({ migrationsFolder: folder });
+        db.transaction((tx) => {
+            tx.run(sql `CREATE TABLE IF NOT EXISTS __offscript_migrations (version INTEGER PRIMARY KEY, hash TEXT NOT NULL, created_at INTEGER NOT NULL)`);
+            const applied = tx.select().from(history).orderBy(history.version).all();
+            if (applied.length > migrations.length)
+                throw new PersistenceError("INCOMPATIBLE_SCHEMA", "Database has migrations unknown to this version.");
+            for (const [index, row] of applied.entries()) {
+                const migration = migrations[index];
+                if (!migration || row.version !== index + 1 || row.hash !== migration.hash || row.createdAt !== migration.folderMillis) {
+                    throw new PersistenceError("INCOMPATIBLE_SCHEMA", "Migration history or checksum does not match this version.");
+                }
+            }
+            for (let index = applied.length; index < migrations.length; index++) {
+                const migration = migrations[index];
+                if (!migration)
+                    throw new PersistenceError("MIGRATION_FAILED", "Missing migration metadata.");
+                for (const statement of migration.sql)
+                    if (statement.trim())
+                        tx.run(sql.raw(statement));
+                tx.insert(history).values({ version: index + 1, hash: migration.hash, createdAt: migration.folderMillis }).run();
+            }
+        }, { behavior: "immediate" });
+    }
+    catch (cause) {
+        if (cause instanceof PersistenceError)
+            throw cause;
+        throw new PersistenceError("MIGRATION_FAILED", "Could not apply storage migrations; transaction rolled back.", { cause });
+    }
+}

package/dist/packages/persistence/migrations/0000_initial_domain_storage.sql

@@ -0,0 +1,92 @@
+CREATE TABLE `agents` (
+	`simulation_id` text NOT NULL,
+	`id` text NOT NULL,
+	`position` integer NOT NULL,
+	`profile` text NOT NULL,
+	`status` text NOT NULL,
+	`reason` text,
+	PRIMARY KEY(`simulation_id`, `id`),
+	FOREIGN KEY (`simulation_id`) REFERENCES `simulations`(`id`) ON UPDATE no action ON DELETE no action,
+	CONSTRAINT "agent_nonnegative_position" CHECK("agents"."position" >= 0),
+	CONSTRAINT "agent_profile_json" CHECK(json_valid("agents"."profile")),
+	CONSTRAINT "agent_status" CHECK("agents"."status" in ('ready','running','completed','failed','cancelled')),
+	CONSTRAINT "agent_reason" CHECK(("agents"."status" = 'failed' and "agents"."reason" is not null and length(trim("agents"."reason")) > 0) or ("agents"."status" != 'failed' and "agents"."reason" is null))
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `agent_position` ON `agents` (`simulation_id`,`position`);--> statement-breakpoint
+CREATE TABLE `investigation_agents` (
+	`investigation_id` text NOT NULL,
+	`simulation_id` text NOT NULL,
+	`agent_id` text NOT NULL,
+	`position` integer NOT NULL,
+	PRIMARY KEY(`investigation_id`, `agent_id`),
+	FOREIGN KEY (`investigation_id`,`simulation_id`) REFERENCES `investigations`(`id`,`simulation_id`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (`simulation_id`,`agent_id`) REFERENCES `agents`(`simulation_id`,`id`) ON UPDATE no action ON DELETE no action,
+	CONSTRAINT "investigation_agent_nonnegative_position" CHECK("investigation_agents"."position" >= 0)
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `investigation_agent_position` ON `investigation_agents` (`investigation_id`,`position`);--> statement-breakpoint
+CREATE TABLE `investigation_observations` (
+	`investigation_id` text NOT NULL,
+	`simulation_id` text NOT NULL,
+	`observation_id` text NOT NULL,
+	`position` integer NOT NULL,
+	PRIMARY KEY(`investigation_id`, `observation_id`),
+	FOREIGN KEY (`investigation_id`,`simulation_id`) REFERENCES `investigations`(`id`,`simulation_id`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (`observation_id`,`simulation_id`) REFERENCES `observations`(`id`,`simulation_id`) ON UPDATE no action ON DELETE no action,
+	CONSTRAINT "investigation_observation_nonnegative_position" CHECK("investigation_observations"."position" >= 0)
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `investigation_observation_position` ON `investigation_observations` (`investigation_id`,`position`);--> statement-breakpoint
+CREATE TABLE `investigations` (
+	`id` text PRIMARY KEY NOT NULL,
+	`simulation_id` text NOT NULL,
+	`requested_by` text NOT NULL,
+	`hypothesis` text NOT NULL,
+	`requested_at` text NOT NULL,
+	`status` text NOT NULL,
+	`assigned_at` text,
+	`completed_at` text,
+	`completed_by` text,
+	`result` text,
+	`revision` integer DEFAULT 0 NOT NULL,
+	FOREIGN KEY (`simulation_id`) REFERENCES `simulations`(`id`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (`simulation_id`,`requested_by`) REFERENCES `agents`(`simulation_id`,`id`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (`simulation_id`,`completed_by`) REFERENCES `agents`(`simulation_id`,`id`) ON UPDATE no action ON DELETE no action,
+	CONSTRAINT "investigation_revision" CHECK("investigations"."revision" >= 0 and "investigations"."revision" <= 9007199254740991),
+	CONSTRAINT "investigation_state" CHECK((
+    ("investigations"."status" = 'requested' and "investigations"."assigned_at" is null and "investigations"."completed_at" is null and "investigations"."completed_by" is null and "investigations"."result" is null)
+    or ("investigations"."status" = 'assigned' and "investigations"."assigned_at" is not null and "investigations"."completed_at" is null and "investigations"."completed_by" is null and "investigations"."result" is null)
+    or ("investigations"."status" = 'completed' and "investigations"."assigned_at" is not null and "investigations"."completed_at" is not null and "investigations"."completed_by" is not null and "investigations"."result" is not null)
+  )),
+	CONSTRAINT "investigation_result_json" CHECK("investigations"."result" is null or json_valid("investigations"."result"))
+);
+--> statement-breakpoint
+CREATE INDEX `investigation_simulation_status` ON `investigations` (`simulation_id`,`status`,`requested_at`,`id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `investigation_scope` ON `investigations` (`id`,`simulation_id`);--> statement-breakpoint
+CREATE TABLE `observations` (
+	`id` text PRIMARY KEY NOT NULL,
+	`simulation_id` text NOT NULL,
+	`agent_id` text NOT NULL,
+	`observed_at` text NOT NULL,
+	`description` text NOT NULL,
+	`location` text NOT NULL,
+	`evidence_ids` text NOT NULL,
+	FOREIGN KEY (`simulation_id`) REFERENCES `simulations`(`id`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (`simulation_id`,`agent_id`) REFERENCES `agents`(`simulation_id`,`id`) ON UPDATE no action ON DELETE no action,
+	CONSTRAINT "observation_evidence_json" CHECK(json_valid("observations"."evidence_ids"))
+);
+--> statement-breakpoint
+CREATE INDEX `observation_simulation_time` ON `observations` (`simulation_id`,`observed_at`,`id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `observation_scope` ON `observations` (`id`,`simulation_id`);--> statement-breakpoint
+CREATE TABLE `simulations` (
+	`id` text PRIMARY KEY NOT NULL,
+	`environment` text NOT NULL,
+	`deployment` text NOT NULL,
+	`status` text NOT NULL,
+	`reason` text,
+	CONSTRAINT "simulation_environment" CHECK("simulations"."environment" = 'web'),
+	CONSTRAINT "simulation_deployment" CHECK("simulations"."deployment" in ('local','development','test','staging','production')),
+	CONSTRAINT "simulation_status" CHECK("simulations"."status" in ('created','running','completed','failed','cancelled')),
+	CONSTRAINT "simulation_reason" CHECK(("simulations"."status" = 'failed' and "simulations"."reason" is not null and length(trim("simulations"."reason")) > 0) or ("simulations"."status" != 'failed' and "simulations"."reason" is null))
+);

package/dist/packages/persistence/migrations/0001_transactional_outbox.sql

@@ -0,0 +1,26 @@
+CREATE TABLE `event_outbox` (
+	`sequence` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`event_id` text NOT NULL,
+	`simulation_id` text NOT NULL,
+	`investigation_id` text NOT NULL,
+	`revision` integer NOT NULL,
+	`event_json` text NOT NULL,
+	`status` text DEFAULT 'pending' NOT NULL,
+	`attempts` integer DEFAULT 0 NOT NULL,
+	`available_at` integer DEFAULT 0 NOT NULL,
+	`lease_token` text,
+	`lease_until` integer,
+	`accepted_at` integer,
+	`last_error` text,
+	FOREIGN KEY (`investigation_id`,`simulation_id`) REFERENCES `investigations`(`id`,`simulation_id`) ON UPDATE no action ON DELETE no action,
+	CONSTRAINT "outbox_json" CHECK(json_valid("event_outbox"."event_json")),
+	CONSTRAINT "outbox_numbers" CHECK("event_outbox"."revision" >= 0 and "event_outbox"."attempts" >= 0 and "event_outbox"."available_at" >= 0),
+	CONSTRAINT "outbox_status" CHECK("event_outbox"."status" in ('pending','leased','accepted','failed')),
+	CONSTRAINT "outbox_lease" CHECK(("event_outbox"."status" = 'leased' and "event_outbox"."lease_token" is not null and "event_outbox"."lease_until" is not null) or ("event_outbox"."status" != 'leased' and "event_outbox"."lease_token" is null and "event_outbox"."lease_until" is null)),
+	CONSTRAINT "outbox_acceptance" CHECK(("event_outbox"."status" = 'accepted' and "event_outbox"."accepted_at" is not null) or ("event_outbox"."status" != 'accepted' and "event_outbox"."accepted_at" is null))
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `event_outbox_event_id_unique` ON `event_outbox` (`event_id`);--> statement-breakpoint
+CREATE INDEX `outbox_ready` ON `event_outbox` (`status`,`available_at`,`sequence`);--> statement-breakpoint
+CREATE INDEX `outbox_aggregate_order` ON `event_outbox` (`investigation_id`,`sequence`,`status`);--> statement-breakpoint
+CREATE UNIQUE INDEX `outbox_investigation_revision` ON `event_outbox` (`investigation_id`,`revision`);

package/dist/packages/persistence/migrations/0002_simulation_configuration.sql

@@ -0,0 +1,7 @@
+CREATE TABLE `simulation_configurations` (
+	`simulation_id` text PRIMARY KEY NOT NULL,
+	`configuration` text NOT NULL,
+	FOREIGN KEY (`simulation_id`) REFERENCES `simulations`(`id`) ON UPDATE no action ON DELETE no action,
+	CONSTRAINT "configuration_json" CHECK(json_valid("simulation_configurations"."configuration") and json_type("simulation_configurations"."configuration") = 'object'),
+	CONSTRAINT "configuration_identity" CHECK(json_type("simulation_configurations"."configuration", '$.simulationId') is 'text' and json_extract("simulation_configurations"."configuration", '$.simulationId') = "simulation_configurations"."simulation_id")
+);