@ekairos/domain 1.22.36-beta.development.0 → 1.22.36

package/dist/cli/create-app.js

@@ -1,14 +1,19 @@
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
+import { createServer } from "node:net";
 import { access, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
 import { PlatformApi } from "@instantdb/platform";
 import { i } from "@instantdb/core";
 import { domain } from "../index.js";
-const TEMPLATE_NEXT_VERSION = "15.5.7";
-const TEMPLATE_REACT_VERSION = "19.2.1";
-const TEMPLATE_TYPESCRIPT_VERSION = "^5.9.2";
-const TEMPLATE_INSTANT_VERSION = "0.22.126";
-const TEMPLATE_WORKFLOW_VERSION = "^5.0.0-beta.1";
+export const CREATE_DOMAIN_APP_TEMPLATES = ["empty", "supply-chain", "agent"];
+const TEMPLATE_NEXT_VERSION = "16.2.6";
+const TEMPLATE_REACT_VERSION = "19.2.6";
+const TEMPLATE_TYPESCRIPT_VERSION = "^6.0.3";
+const TEMPLATE_INSTANT_VERSION = "1.0.39";
+const TEMPLATE_INSTANT_REACT_VERSION = "1.0.39";
+const TEMPLATE_WORKFLOW_VERSION = "5.0.0-beta.6";
+const TEMPLATE_VERCEL_OIDC_VERSION = "3.4.1";
+const TEMPLATE_EVENTS_VERSION = "1.22.82-beta.development.0";
 function trimOrEmpty(value) {
     return typeof value === "string" ? value.trim() : "";
 }
@@ -67,52 +72,371 @@ async function readDomainPackageVersion() {
     const parsed = JSON.parse(raw);
     return trimOrEmpty(parsed.version) || "latest";
 }
-function createScaffoldSchema() {
-    const scaffoldDomain = domain("ekairos.app").schema({
+export function normalizeCreateAppTemplate(value) {
+    const normalized = trimOrEmpty(value);
+    if (!normalized)
+        return null;
+    if (CREATE_DOMAIN_APP_TEMPLATES.includes(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Unsupported template: ${normalized}. Supported templates: ${CREATE_DOMAIN_APP_TEMPLATES.join(", ")}.`);
+}
+function resolveCreateAppTemplate(params) {
+    if (params.template) {
+        if (params.demo && params.template !== "supply-chain") {
+            throw new Error("--demo only supports --template=supply-chain.");
+        }
+        return params.template;
+    }
+    return params.demo ? "supply-chain" : "empty";
+}
+function createScaffoldSchema(template) {
+    if (template === "supply-chain")
+        return createSupplyChainScaffoldSchema();
+    if (template === "agent")
+        return createAgentScaffoldSchema();
+    return createEmptyScaffoldSchema();
+}
+function createEmptyScaffoldSchema() {
+    const scaffoldDomain = domain("app").withSchema({
+        entities: {},
+        links: {},
+        rooms: {},
+    });
+    return scaffoldDomain.toInstantSchema();
+}
+function createSupplyChainScaffoldSchema() {
+    const supplierNetworkDomain = domain("supplierNetwork").withSchema({
+        entities: {
+            supplierNetwork_supplier: i.entity({
+                name: i.string().indexed(),
+                region: i.string().indexed(),
+                risk: i.string().indexed(),
+                score: i.number().indexed(),
+                createdAt: i.number().indexed(),
+            }),
+        },
+        links: {},
+        rooms: {},
+    });
+    const procurementDomain = domain("procurement")
+        .includes(supplierNetworkDomain)
+        .withSchema({
+        entities: {
+            procurement_order: i.entity({
+                reference: i.string().indexed(),
+                status: i.string().indexed(),
+                spend: i.number().indexed(),
+                createdAt: i.number().indexed(),
+            }),
+        },
+        links: {
+            procurement_orderSupplier: {
+                forward: { on: "procurement_order", has: "one", label: "supplier" },
+                reverse: { on: "supplierNetwork_supplier", has: "many", label: "orders" },
+            },
+        },
+        rooms: {},
+    });
+    const inventoryDomain = domain("inventory")
+        .includes(procurementDomain)
+        .withSchema({
         entities: {
-            app_tasks: i.entity({
-                title: i.string().indexed(),
+            inventory_stockItem: i.entity({
+                sku: i.string().indexed(),
+                warehouse: i.string().indexed(),
+                available: i.number().indexed(),
+                safetyStock: i.number().indexed(),
+                createdAt: i.number().indexed(),
+            }),
+        },
+        links: {
+            inventory_stockItemOrder: {
+                forward: { on: "inventory_stockItem", has: "one", label: "order" },
+                reverse: { on: "procurement_order", has: "many", label: "stockItems" },
+            },
+        },
+        rooms: {},
+    });
+    const transportationDomain = domain("transportation")
+        .includes(procurementDomain)
+        .withSchema({
+        entities: {
+            transportation_shipment: i.entity({
+                carrier: i.string().indexed(),
+                lane: i.string().indexed(),
                 status: i.string().indexed(),
+                etaHours: i.number().indexed(),
                 createdAt: i.number().indexed(),
             }),
-            app_task_comments: i.entity({
-                body: i.string(),
+        },
+        links: {
+            transportation_shipmentOrder: {
+                forward: { on: "transportation_shipment", has: "one", label: "order" },
+                reverse: { on: "procurement_order", has: "many", label: "shipments" },
+            },
+        },
+        rooms: {},
+    });
+    const qualityControlDomain = domain("qualityControl")
+        .includes(transportationDomain)
+        .withSchema({
+        entities: {
+            qualityControl_inspection: i.entity({
+                result: i.string().indexed(),
+                severity: i.string().indexed(),
+                note: i.string(),
                 createdAt: i.number().indexed(),
             }),
         },
         links: {
-            taskComments: {
-                forward: { on: "app_tasks", has: "many", label: "comments" },
-                reverse: { on: "app_task_comments", has: "one", label: "task" },
+            qualityControl_inspectionShipment: {
+                forward: { on: "qualityControl_inspection", has: "one", label: "shipment" },
+                reverse: { on: "transportation_shipment", has: "many", label: "inspections" },
             },
         },
         rooms: {},
     });
+    const scaffoldDomain = domain("supplyChain")
+        .includes(inventoryDomain)
+        .includes(qualityControlDomain)
+        .withSchema({ entities: {}, links: {}, rooms: {} });
     return scaffoldDomain.toInstantSchema();
 }
-function createScaffoldPerms() {
+function createAgentScaffoldSchema() {
+    return domain("events")
+        .withSchema({
+        entities: {
+            event_contexts: i.entity({
+                createdAt: i.date(),
+                updatedAt: i.date().optional(),
+                key: i.string().optional().indexed().unique(),
+                name: i.string().optional(),
+                status: i.string().optional().indexed(),
+                content: i.any().optional(),
+                reactor: i.json().optional(),
+            }),
+            event_items: i.entity({
+                channel: i.string().indexed(),
+                createdAt: i.date().indexed(),
+                type: i.string().optional().indexed(),
+                content: i.any().optional(),
+                status: i.string().optional().indexed(),
+            }),
+            event_executions: i.entity({
+                createdAt: i.date(),
+                updatedAt: i.date().optional(),
+                status: i.string().optional().indexed(),
+                workflowRunId: i.string().optional().indexed(),
+                activeStreamId: i.string().optional().indexed(),
+                activeStreamClientId: i.string().optional().indexed(),
+                lastStreamId: i.string().optional().indexed(),
+                lastStreamClientId: i.string().optional().indexed(),
+            }),
+            event_steps: i.entity({
+                createdAt: i.date().indexed(),
+                updatedAt: i.date().optional(),
+                status: i.string().optional().indexed(),
+                iteration: i.number().indexed(),
+                errorText: i.string().optional(),
+                streamId: i.string().optional().indexed(),
+                streamClientId: i.string().optional().indexed(),
+                streamStartedAt: i.date().optional().indexed(),
+                streamFinishedAt: i.date().optional().indexed(),
+                streamAbortReason: i.string().optional(),
+            }),
+            event_parts: i.entity({
+                key: i.string().unique().indexed(),
+                stepId: i.string().indexed(),
+                idx: i.number().indexed(),
+                type: i.string().optional().indexed(),
+                part: i.json().optional(),
+                metadata: i.json().optional(),
+                updatedAt: i.date().optional(),
+            }),
+            event_trace_events: i.entity({
+                key: i.string().unique().indexed(),
+                workflowRunId: i.string().indexed(),
+                seq: i.number().indexed(),
+                eventId: i.string().indexed(),
+                eventKind: i.string().indexed(),
+                eventAt: i.date().optional(),
+                ingestedAt: i.date().optional(),
+                orgId: i.string().optional().indexed(),
+                projectId: i.string().optional().indexed(),
+                contextKey: i.string().optional().indexed(),
+                contextId: i.string().optional().indexed(),
+                executionId: i.string().optional().indexed(),
+                stepId: i.string().optional().indexed(),
+                contextEventId: i.string().optional().indexed(),
+                toolCallId: i.string().optional().indexed(),
+                partKey: i.string().optional().indexed(),
+                partIdx: i.number().optional().indexed(),
+                spanId: i.string().optional().indexed(),
+                parentSpanId: i.string().optional().indexed(),
+                isDeleted: i.boolean().optional(),
+                aiProvider: i.string().optional().indexed(),
+                aiModel: i.string().optional().indexed(),
+                promptTokens: i.number().optional(),
+                promptTokensCached: i.number().optional(),
+                promptTokensUncached: i.number().optional(),
+                completionTokens: i.number().optional(),
+                totalTokens: i.number().optional(),
+                latencyMs: i.number().optional(),
+                cacheCostUsd: i.number().optional(),
+                computeCostUsd: i.number().optional(),
+                costUsd: i.number().optional(),
+                payload: i.any().optional(),
+            }),
+            event_trace_runs: i.entity({
+                workflowRunId: i.string().unique().indexed(),
+                orgId: i.string().optional().indexed(),
+                projectId: i.string().optional().indexed(),
+                firstEventAt: i.date().optional().indexed(),
+                lastEventAt: i.date().optional().indexed(),
+                lastIngestedAt: i.date().optional().indexed(),
+                eventsCount: i.number().optional(),
+                status: i.string().optional().indexed(),
+                payload: i.any().optional(),
+            }),
+            event_trace_spans: i.entity({
+                spanId: i.string().unique().indexed(),
+                parentSpanId: i.string().optional().indexed(),
+                workflowRunId: i.string().indexed(),
+                executionId: i.string().optional().indexed(),
+                stepId: i.string().optional().indexed(),
+                kind: i.string().optional().indexed(),
+                name: i.string().optional().indexed(),
+                status: i.string().optional().indexed(),
+                startedAt: i.date().optional().indexed(),
+                endedAt: i.date().optional().indexed(),
+                durationMs: i.number().optional(),
+                payload: i.any().optional(),
+            }),
+            document_documents: i.entity({
+                name: i.string().optional().indexed(),
+                mimeType: i.string().optional(),
+                size: i.number().optional(),
+                ownerId: i.string().optional().indexed(),
+                orgId: i.string().optional().indexed(),
+                createdAt: i.date().optional().indexed(),
+                processedAt: i.date().optional().indexed(),
+                updatedAt: i.date().optional(),
+                lastJobId: i.string().optional(),
+                content: i.json().optional(),
+            }),
+        },
+        links: {
+            contextItemsContext: {
+                forward: { on: "event_items", has: "one", label: "context" },
+                reverse: { on: "event_contexts", has: "many", label: "items" },
+            },
+            contextExecutionsContext: {
+                forward: { on: "event_executions", has: "one", label: "context" },
+                reverse: { on: "event_contexts", has: "many", label: "executions" },
+            },
+            contextCurrentExecution: {
+                forward: { on: "event_contexts", has: "one", label: "currentExecution" },
+                reverse: { on: "event_executions", has: "one", label: "currentOf" },
+            },
+            contextExecutionsTrigger: {
+                forward: { on: "event_executions", has: "one", label: "trigger" },
+                reverse: { on: "event_items", has: "many", label: "executionsAsTrigger" },
+            },
+            contextExecutionsReaction: {
+                forward: { on: "event_executions", has: "one", label: "reaction" },
+                reverse: { on: "event_items", has: "many", label: "executionsAsReaction" },
+            },
+            contextStepsExecution: {
+                forward: { on: "event_steps", has: "one", label: "execution" },
+                reverse: { on: "event_executions", has: "many", label: "steps" },
+            },
+            contextExecutionItems: {
+                forward: { on: "event_items", has: "one", label: "execution" },
+                reverse: { on: "event_executions", has: "many", label: "items" },
+            },
+            contextPartsStep: {
+                forward: { on: "event_parts", has: "one", label: "step" },
+                reverse: { on: "event_steps", has: "many", label: "parts" },
+            },
+            contextStepStream: {
+                forward: { on: "event_steps", has: "one", label: "stream" },
+                reverse: { on: "$streams", has: "many", label: "step" },
+            },
+            contextExecutionActiveStream: {
+                forward: { on: "event_executions", has: "one", label: "activeStream" },
+                reverse: { on: "$streams", has: "many", label: "activeOf" },
+            },
+            contextExecutionLastStream: {
+                forward: { on: "event_executions", has: "one", label: "lastStream" },
+                reverse: { on: "$streams", has: "many", label: "lastOf" },
+            },
+            documentFile: {
+                forward: { on: "document_documents", has: "one", label: "file" },
+                reverse: { on: "$files", has: "one", label: "document" },
+            },
+        },
+        rooms: {},
+    })
+        .toInstantSchema();
+}
+function createScaffoldPerms(template) {
+    if (template === "supply-chain")
+        return createSupplyChainScaffoldPerms();
+    if (template === "agent")
+        return createAgentScaffoldPerms();
+    return createEmptyScaffoldPerms();
+}
+function createEmptyScaffoldPerms() {
     return {
         attrs: {
             allow: { create: "true" },
         },
-        app_tasks: {
-            bind: ["isLoggedIn", "auth.id != null"],
-            allow: {
-                view: "true",
-                create: "isLoggedIn",
-                update: "isLoggedIn",
-                delete: "false",
-            },
+    };
+}
+function createSupplyChainScaffoldPerms() {
+    const entityRules = {
+        bind: ["isLoggedIn", "auth.id != null"],
+        allow: {
+            view: "true",
+            create: "isLoggedIn",
+            update: "isLoggedIn",
+            delete: "false",
         },
-        app_task_comments: {
-            bind: ["isLoggedIn", "auth.id != null"],
-            allow: {
-                view: "true",
-                create: "isLoggedIn",
-                update: "isLoggedIn",
-                delete: "false",
-            },
+    };
+    return {
+        attrs: {
+            allow: { create: "true" },
         },
+        supplierNetwork_supplier: entityRules,
+        procurement_order: entityRules,
+        inventory_stockItem: entityRules,
+        transportation_shipment: entityRules,
+        qualityControl_inspection: entityRules,
+    };
+}
+function createAgentScaffoldPerms() {
+    const entityRules = {
+        allow: {
+            view: "true",
+            create: "true",
+            update: "true",
+            delete: "false",
+        },
+    };
+    return {
+        attrs: {
+            allow: { create: "true" },
+        },
+        event_contexts: entityRules,
+        event_items: entityRules,
+        event_executions: entityRules,
+        event_steps: entityRules,
+        event_parts: entityRules,
+        event_trace_events: entityRules,
+        event_trace_runs: entityRules,
+        event_trace_spans: entityRules,
+        document_documents: entityRules,
     };
 }
 function installCommandFor(packageManager) {
@@ -133,6 +457,328 @@ function runScriptCommandFor(packageManager, script) {
         return `bun run ${script}`;
     return `npm run ${script}`;
 }
+function packageBinCommandFor(packageManager, command) {
+    void command;
+    return "ekairos domain";
+}
+function typecheckCommandFor(packageManager) {
+    if (packageManager === "pnpm")
+        return { command: "pnpm", args: ["typecheck"] };
+    if (packageManager === "yarn")
+        return { command: "yarn", args: ["typecheck"] };
+    if (packageManager === "bun")
+        return { command: "bun", args: ["run", "typecheck"] };
+    return { command: "npm", args: ["run", "typecheck"] };
+}
+function nextDevCommandFor(targetDir, port) {
+    return {
+        command: process.execPath,
+        args: [
+            join(targetDir, "node_modules", "next", "dist", "bin", "next"),
+            "dev",
+            "--hostname",
+            "127.0.0.1",
+            "--port",
+            String(port),
+        ],
+    };
+}
+async function runCommand(params) {
+    const timeoutMs = params.timeoutMs ?? 2 * 60 * 1000;
+    await new Promise((resolveRun, rejectRun) => {
+        const child = spawn(params.command, params.args, {
+            cwd: params.targetDir,
+            env: process.env,
+            shell: process.platform === "win32",
+            stdio: "pipe",
+        });
+        let output = "";
+        const timer = setTimeout(() => {
+            stopProcess(child.pid);
+            rejectRun(new Error(`${params.command} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            output += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            output += chunk.toString();
+        });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            rejectRun(error);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolveRun();
+                return;
+            }
+            rejectRun(new Error(output.trim() || `${params.command} failed with exit code ${code ?? "unknown"}`));
+        });
+    });
+}
+async function reservePort() {
+    return await new Promise((resolvePort, rejectPort) => {
+        const server = createServer();
+        server.once("error", rejectPort);
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                rejectPort(new Error("Failed to reserve smoke port"));
+                return;
+            }
+            const port = address.port;
+            server.close((error) => {
+                if (error)
+                    rejectPort(error);
+                else
+                    resolvePort(port);
+            });
+        });
+    });
+}
+function stopProcess(pid) {
+    if (!pid)
+        return;
+    if (process.platform === "win32") {
+        spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+        });
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch {
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch {
+            // Process already exited.
+        }
+    }
+}
+function quotePowerShellString(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function startDetachedWindowsProcess(params) {
+    const argumentList = params.args.map(quotePowerShellString).join(", ");
+    const script = [
+        `$p = Start-Process -FilePath ${quotePowerShellString(params.command)} ` +
+            `-ArgumentList @(${argumentList}) ` +
+            `-WorkingDirectory ${quotePowerShellString(params.targetDir)} ` +
+            "-WindowStyle Hidden -PassThru",
+        "Write-Output $p.Id",
+    ].join("; ");
+    const result = spawnSync("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], {
+        encoding: "utf8",
+        stdio: "pipe",
+    });
+    if ((result.status ?? 1) !== 0) {
+        throw new Error(result.stderr?.trim() ||
+            result.stdout?.trim() ||
+            "Failed to start detached Next dev server");
+    }
+    const pid = Number(String(result.stdout ?? "").trim().split(/\s+/).pop());
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+async function fetchJsonWithTimeout(url, init, timeoutMs = 10000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            ...init,
+            signal: controller.signal,
+        });
+        const data = await response.json().catch(() => null);
+        return { response, data: data };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function waitForDomainEndpoint(params) {
+    const endpoint = `${params.baseUrl}/api/ekairos/domain`;
+    const deadline = Date.now() + 3 * 60 * 1000;
+    let lastError = "";
+    while (Date.now() < deadline) {
+        if (params.processExited()) {
+            throw new Error(`Next dev server exited before smoke endpoint was ready.\n${params.readLogs()}`);
+        }
+        try {
+            const { response, data } = await fetchJsonWithTimeout(endpoint);
+            if (response.ok && data?.ok === true)
+                return data;
+            lastError = `status:${response.status}`;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+        }
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, 1000));
+    }
+    throw new Error(`Timed out waiting for ${endpoint}: ${lastError}\n${params.readLogs()}`);
+}
+function countCollection(value) {
+    if (Array.isArray(value))
+        return value.length;
+    if (value && typeof value === "object")
+        return Object.keys(value).length;
+    return 0;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+async function postSmokeJson(baseUrl, body) {
+    const { response, data } = await fetchJsonWithTimeout(`${baseUrl}/api/ekairos/domain`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    }, 30000);
+    if (!response.ok || data?.ok !== true) {
+        throw new Error(data?.error || `Smoke request failed with status ${response.status}`);
+    }
+    return data;
+}
+async function runSmoke(params) {
+    await emitProgress(params.onProgress, {
+        stage: "smoke",
+        status: "running",
+        message: "Running typecheck",
+        progress: 97,
+    });
+    const typecheck = typecheckCommandFor(params.packageManager);
+    await runCommand({
+        targetDir: params.targetDir,
+        command: typecheck.command,
+        args: typecheck.args,
+    });
+    const port = await reservePort();
+    const baseUrl = `http://127.0.0.1:${port}`;
+    const dev = nextDevCommandFor(params.targetDir, port);
+    let logs = "";
+    let smokePassed = false;
+    let detachedPid = null;
+    const child = params.keepServer && process.platform === "win32"
+        ? null
+        : spawn(dev.command, dev.args, {
+            cwd: params.targetDir,
+            env: process.env,
+            detached: params.keepServer,
+            shell: false,
+            stdio: params.keepServer ? "ignore" : "pipe",
+        });
+    if (params.keepServer && process.platform === "win32") {
+        detachedPid = startDetachedWindowsProcess({
+            targetDir: params.targetDir,
+            command: dev.command,
+            args: dev.args,
+        });
+    }
+    if (child && !params.keepServer) {
+        child.stdout?.on("data", (chunk) => {
+            logs += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            logs += chunk.toString();
+        });
+    }
+    try {
+        await emitProgress(params.onProgress, {
+            stage: "smoke",
+            status: "running",
+            message: `Waiting for ${baseUrl}`,
+            progress: 98,
+        });
+        const manifest = await waitForDomainEndpoint({
+            baseUrl,
+            processExited: () => (child ? child.exitCode !== null : false),
+            readLogs: () => logs,
+        });
+        let launchedOrder = false;
+        let orders = [];
+        let shipments = 0;
+        let inspections = 0;
+        if (params.demo) {
+            const launch = await postSmokeJson(baseUrl, {
+                op: "action",
+                action: "supplyChain.order.launch",
+                input: {
+                    reference: "PO-SMOKE-7842",
+                    sku: "DRV-2048",
+                    supplierName: "Marula Components",
+                },
+                admin: true,
+            });
+            if (String(launch.action ?? "") !== "supplyChain.order.launch") {
+                throw new Error("Smoke launch order action returned an unexpected action");
+            }
+            launchedOrder = true;
+            const query = await postSmokeJson(baseUrl, {
+                op: "query",
+                query: {
+                    procurement_order: {
+                        supplier: {},
+                        stockItems: {},
+                        shipments: {
+                            inspections: {},
+                        },
+                    },
+                },
+                admin: true,
+            });
+            orders = asArray(query?.data?.procurement_order);
+            shipments = orders.reduce((total, order) => {
+                return total + asArray(order?.shipments).length;
+            }, 0);
+            inspections = orders.reduce((total, order) => {
+                const orderShipments = asArray(order?.shipments);
+                return total + orderShipments.reduce((shipmentTotal, shipment) => {
+                    return shipmentTotal + asArray(shipment?.inspections).length;
+                }, 0);
+            }, 0);
+        }
+        smokePassed = true;
+        const result = {
+            ok: true,
+            baseUrl,
+            keepServer: params.keepServer,
+            pid: detachedPid ?? child?.pid ?? null,
+            typecheck: true,
+            domainEndpoint: true,
+            inspect: {
+                entities: countCollection(manifest?.domain?.entities),
+                actions: countCollection(manifest?.actions),
+            },
+            launchedOrder,
+            query: {
+                inspections,
+                orders: orders.length,
+                shipments,
+            },
+        };
+        await emitProgress(params.onProgress, {
+            stage: "smoke",
+            status: "completed",
+            message: params.keepServer
+                ? `Smoke passed and server is running at ${baseUrl}`
+                : "Smoke passed",
+            progress: 99,
+        });
+        if (params.keepServer) {
+            params.onKeepServer?.({
+                unref() {
+                    child?.unref();
+                },
+            });
+        }
+        return result;
+    }
+    finally {
+        if (!params.keepServer || !smokePassed) {
+            stopProcess(detachedPid ?? child?.pid);
+        }
+    }
+}
 async function provisionInstantApp(params) {
     const api = new PlatformApi({
         auth: { token: params.instantToken },
@@ -140,8 +786,8 @@ async function provisionInstantApp(params) {
     const created = await api.createApp({
         title: `ekairos-${trimOrEmpty(params.directory.split(/[\\/]/).pop()) || "app"}`,
         orgId: trimOrEmpty(params.orgId) || undefined,
-        schema: createScaffoldSchema(),
-        perms: createScaffoldPerms(),
+        schema: createScaffoldSchema(params.template),
+        perms: createScaffoldPerms(params.template),
     });
     const appId = trimOrEmpty(created?.app?.id);
     const adminToken = trimOrEmpty(created?.app?.adminToken);
@@ -219,20 +865,27 @@ async function writeScaffoldFiles(targetDir, files) {
         await writeFile(absolutePath, content, "utf8");
     }
 }
-function resolveDomainDependencyVersion(version, targetDir, workspacePath) {
+function resolveWorkspacePackageDependencyVersion(packageName, version, targetDir, workspacePath) {
     const workspaceRoot = trimOrEmpty(workspacePath);
     if (!workspaceRoot) {
         return version;
     }
-    const packageRoot = resolve(workspaceRoot, "packages/domain");
+    const packageRoot = resolve(workspaceRoot, "packages", packageName.split("/").pop() || packageName);
     const relativePath = toPosix(relative(targetDir, packageRoot));
     if (!relativePath)
         return "file:.";
     const prefixed = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
     return `file:${prefixed}`;
 }
+function resolveDomainDependencyVersion(version, targetDir, workspacePath) {
+    return resolveWorkspacePackageDependencyVersion("@ekairos/domain", version, targetDir, workspacePath);
+}
 function buildNextTemplateFiles(params) {
-    const domainDependency = resolveDomainDependencyVersion(params.domainVersion, params.targetDir, params.workspacePath);
+    const workspaceRoot = trimOrEmpty(params.workspacePath);
+    const domainDependency = params.template === "agent" && !workspaceRoot
+        ? TEMPLATE_EVENTS_VERSION
+        : resolveDomainDependencyVersion(params.domainVersion, params.targetDir, params.workspacePath);
+    const eventsDependency = resolveWorkspacePackageDependencyVersion("@ekairos/events", TEMPLATE_EVENTS_VERSION, params.targetDir, params.workspacePath);
     const packageJson = {
         name: trimOrEmpty(params.targetDir.split(/[\\/]/).pop()) || "ekairos-app",
         private: true,
@@ -246,12 +899,15 @@ function buildNextTemplateFiles(params) {
         },
         dependencies: {
             "@ekairos/domain": domainDependency,
+            "@vercel/oidc": TEMPLATE_VERCEL_OIDC_VERSION,
             "@instantdb/admin": TEMPLATE_INSTANT_VERSION,
             "@instantdb/core": TEMPLATE_INSTANT_VERSION,
+            "@instantdb/react": TEMPLATE_INSTANT_REACT_VERSION,
             next: TEMPLATE_NEXT_VERSION,
             react: TEMPLATE_REACT_VERSION,
             "react-dom": TEMPLATE_REACT_VERSION,
             workflow: TEMPLATE_WORKFLOW_VERSION,
+            zod: "^4.3.6",
         },
         devDependencies: {
             "@types/node": "^24.5.0",
@@ -265,6 +921,651 @@ function buildNextTemplateFiles(params) {
                 ? "yarn@1"
                 : undefined,
     };
+    if (params.template === "agent") {
+        ;
+        packageJson.dependencies["@ekairos/events"] = eventsDependency;
+        if (params.packageManager === "pnpm") {
+            ;
+            packageJson.pnpm = {
+                overrides: {
+                    "@ekairos/domain": domainDependency,
+                    "@instantdb/admin": TEMPLATE_INSTANT_VERSION,
+                    "@instantdb/core": TEMPLATE_INSTANT_VERSION,
+                },
+            };
+        }
+    }
+    if (params.template === "empty") {
+        return {
+            ".gitignore": [".next", "node_modules", ".env.local", ".workflow-data"].join("\n"),
+            ".env.example": [
+                "NEXT_PUBLIC_INSTANT_APP_ID=",
+                "INSTANT_ADMIN_TOKEN=",
+                "",
+                "# Optional: use this only while provisioning new apps with the CLI.",
+                "INSTANT_PERSONAL_ACCESS_TOKEN=",
+            ].join("\n"),
+            "DOMAIN.md": [
+                "# Ekairos App Domain",
+                "",
+                "This app starts empty on purpose.",
+                "",
+                "Add your first domain in `src/domain.ts`, then expose it through `src/runtime.ts` and `/api/ekairos/domain`.",
+                "",
+                "Suggested first step:",
+                "- create one domain with camelCase name",
+                "- name entities as `<domainName>_<entityName>`",
+                "- add one `defineAction` for the first business write",
+            ].join("\n"),
+            "instant.schema.ts": [
+                'import appDomain from "./src/domain";',
+                "",
+                "const schema = appDomain.toInstantSchema();",
+                "",
+                "export default schema;",
+            ].join("\n"),
+            "next-env.d.ts": [
+                '/// <reference types="next" />',
+                '/// <reference types="next/image-types/global" />',
+                "",
+                "// This file is managed by Next.js.",
+            ].join("\n"),
+            "next.config.ts": [
+                'import type { NextConfig } from "next";',
+                'import { withWorkflow } from "workflow/next";',
+                "",
+                "const nextConfig: NextConfig = {",
+                "  transpilePackages: [\"@ekairos/domain\"],",
+                "};",
+                "",
+                "export default withWorkflow(nextConfig) as NextConfig;",
+            ].join("\n"),
+            "src/app/api/ekairos/domain/route.ts": [
+                'import { createRuntimeRouteHandler } from "@ekairos/domain/next";',
+                'import { createRuntime } from "@/runtime";',
+                "",
+                "export const { GET, POST } = createRuntimeRouteHandler({",
+                "  createRuntime,",
+                "});",
+            ].join("\n"),
+            "package.json": `${JSON.stringify(packageJson, null, 2)}\n`,
+            "tsconfig.json": [
+                "{",
+                '  "compilerOptions": {',
+                '    "target": "ES2022",',
+                '    "lib": ["dom", "dom.iterable", "es2022"],',
+                '    "allowJs": false,',
+                '    "skipLibCheck": true,',
+                '    "strict": true,',
+                '    "noEmit": true,',
+                '    "esModuleInterop": true,',
+                '    "module": "esnext",',
+                '    "moduleResolution": "bundler",',
+                '    "resolveJsonModule": true,',
+                '    "isolatedModules": true,',
+                '    "jsx": "react-jsx",',
+                '    "incremental": true,',
+                '    "paths": {',
+                '      "@/*": ["./src/*"]',
+                "    },",
+                '    "plugins": [',
+                '      { "name": "next" }',
+                "    ]",
+                "  },",
+                '  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts", ".next/dev/types/**/*.ts"],',
+                '  "exclude": ["node_modules"]',
+                "}",
+            ].join("\n"),
+            "src/app/globals.css": [
+                ":root {",
+                "  color-scheme: light;",
+                "  --background: #f7f8f6;",
+                "  --foreground: #181b18;",
+                "  --muted: #626a63;",
+                "  --border: #d9ded7;",
+                "  --surface: #ffffff;",
+                "  --accent: #2f6f5d;",
+                "}",
+                "",
+                "* { box-sizing: border-box; }",
+                "html, body { margin: 0; min-height: 100%; }",
+                "body { min-height: 100dvh; background: var(--background); color: var(--foreground); font-family: \"Segoe UI\", sans-serif; }",
+                "button, input { font: inherit; }",
+                "main { width: min(980px, calc(100% - 40px)); margin: 0 auto; padding: 48px 0; }",
+                ".shell { display: grid; gap: 24px; }",
+                ".eyebrow { color: var(--accent); font-size: 12px; font-weight: 800; letter-spacing: 0.14em; text-transform: uppercase; }",
+                "h1 { max-width: 720px; margin: 0; font-size: clamp(2.4rem, 6vw, 4.8rem); letter-spacing: -0.05em; line-height: 0.96; }",
+                "p { max-width: 64ch; margin: 0; color: var(--muted); line-height: 1.65; }",
+                ".workspace { display: grid; gap: 14px; border: 1px solid var(--border); background: var(--surface); padding: 22px; }",
+                ".status-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); border: 1px solid var(--border); }",
+                ".status-grid div { display: grid; gap: 6px; padding: 14px; border-right: 1px solid var(--border); }",
+                ".status-grid div:last-child { border-right: 0; }",
+                ".status-grid span { color: var(--muted); font-size: 11px; font-weight: 800; letter-spacing: 0.12em; text-transform: uppercase; }",
+                ".status-grid strong { font-size: 1.4rem; }",
+                ".next-steps { display: grid; gap: 10px; margin: 0; padding: 0; list-style: none; }",
+                ".next-steps li { border-top: 1px solid var(--border); padding-top: 10px; color: var(--muted); }",
+                "code { font-family: \"Cascadia Code\", monospace; }",
+                "@media (max-width: 720px) { main { width: min(100% - 28px, 980px); } .status-grid { grid-template-columns: 1fr; } .status-grid div { border-right: 0; border-bottom: 1px solid var(--border); } }",
+            ].join("\n"),
+            "src/app/layout.tsx": [
+                'import "./globals.css";',
+                'import type { ReactNode } from "react";',
+                "",
+                "export const metadata = {",
+                '  title: "Ekairos App",',
+                '  description: "Scaffolded Ekairos app",',
+                "};",
+                "",
+                "export default function RootLayout({ children }: { children: ReactNode }) {",
+                "  return (",
+                '    <html lang="en">',
+                "      <body>{children}</body>",
+                "    </html>",
+                "  );",
+                "}",
+            ].join("\n"),
+            "src/app/page.tsx": [
+                'import DomainWorkbench from "./domain-workbench";',
+                "",
+                'export const dynamic = "force-dynamic";',
+                "",
+                "export default function HomePage() {",
+                "  return (",
+                "    <main>",
+                '      <section className="shell">',
+                '        <div className="eyebrow">Ekairos App</div>',
+                "        <h1>Empty app. Runtime ready.</h1>",
+                "        <p>",
+                "          Start here when you want a clean app with the Ekairos runtime,",
+                "          domain endpoint, Instant configuration, and a place to add your first domain.",
+                "        </p>",
+                "        <DomainWorkbench />",
+                "      </section>",
+                "    </main>",
+                "  );",
+                "}",
+            ].join("\n"),
+            "src/app/domain-workbench.tsx": [
+                "export default function DomainWorkbench() {",
+                "  return (",
+                '    <section className="workspace">',
+                '      <div className="status-grid">',
+                "        <div><span>Runtime</span><strong>Ready</strong></div>",
+                "        <div><span>Endpoint</span><strong>/api</strong></div>",
+                "        <div><span>Domains</span><strong>0</strong></div>",
+                "      </div>",
+                "      <p>Add your first domain in <code>src/domain.ts</code>. Keep writes behind typed domain actions.</p>",
+                '      <ul className="next-steps">',
+                "        <li>Name the domain in camelCase.</li>",
+                "        <li>Name entities as <code>{\"<domainName>_<entityName>\"}</code>.</li>",
+                "        <li>Expose the first write as a <code>defineAction</code>.</li>",
+                "      </ul>",
+                "    </section>",
+                "  );",
+                "}",
+            ].join("\n"),
+            "src/domain.ts": [
+                'import { domain } from "@ekairos/domain";',
+                "",
+                "const baseDomain = domain(\"app\").withSchema({",
+                "  entities: {},",
+                "  links: {},",
+                "  rooms: {},",
+                "});",
+                "",
+                "export const appDomain = baseDomain.withActions({});",
+                "",
+                "export default appDomain;",
+            ].join("\n"),
+            "src/runtime.ts": [
+                'import { init } from "@instantdb/admin";',
+                'import { EkairosRuntime } from "@ekairos/domain/runtime-handle";',
+                'import { configureRuntime } from "@ekairos/domain/runtime";',
+                'import appDomain from "./domain";',
+                "",
+                "export type AppRuntimeEnv = {",
+                "  actorEmail?: string | null;",
+                "  actorId?: string;",
+                "  adminToken?: string;",
+                "  appId?: string;",
+                "};",
+                "",
+                "function resolveRuntimeEnv(env: AppRuntimeEnv = {}): Required<Pick<AppRuntimeEnv, \"appId\" | \"adminToken\">> & AppRuntimeEnv {",
+                '  const appId = String(env.appId ?? process.env.NEXT_PUBLIC_INSTANT_APP_ID ?? "").trim();',
+                '  const adminToken = String(env.adminToken ?? process.env.INSTANT_ADMIN_TOKEN ?? "").trim();',
+                "  if (!appId || !adminToken) {",
+                '    throw new Error("Missing NEXT_PUBLIC_INSTANT_APP_ID or INSTANT_ADMIN_TOKEN. Copy .env.example to .env.local and fill both values.");',
+                "  }",
+                "  return { ...env, appId, adminToken };",
+                "}",
+                "",
+                "export class AppRuntime extends EkairosRuntime<AppRuntimeEnv, typeof appDomain, any> {",
+                "  protected getDomain() { return appDomain; }",
+                "  protected async resolveDb(env: AppRuntimeEnv) {",
+                "    const resolved = resolveRuntimeEnv(env);",
+                "    return init({",
+                "      appId: resolved.appId,",
+                "      adminToken: resolved.adminToken,",
+                "      schema: appDomain.toInstantSchema(),",
+                "      useDateObjects: true,",
+                "    } as any) as any;",
+                "  }",
+                "}",
+                "",
+                "export function createRuntime(env: AppRuntimeEnv = {}) {",
+                "  return new AppRuntime(resolveRuntimeEnv(env));",
+                "}",
+                "",
+                "export const runtimeConfig = configureRuntime<AppRuntimeEnv>({",
+                "  runtime: async (env) => {",
+                "    const runtime = createRuntime(env);",
+                "    return { db: await runtime.db() };",
+                "  },",
+                "  domain: { domain: appDomain },",
+                "});",
+            ].join("\n"),
+            "src/workflows/demo.workflow.ts": [
+                "export type DemoWorkflowInput = Record<string, never>;",
+                "",
+                "export async function runDemoWorkflow(_input: DemoWorkflowInput) {",
+                '  "use workflow";',
+                "  return { ok: true };",
+                "}",
+            ].join("\n"),
+        };
+    }
+    if (params.template === "agent") {
+        return {
+            ".gitignore": [".next", "node_modules", ".env.local", ".workflow-data"].join("\n"),
+            ".env.example": [
+                "NEXT_PUBLIC_INSTANT_APP_ID=",
+                "INSTANT_ADMIN_TOKEN=",
+                "",
+                "# Optional: use this only while provisioning new apps with the CLI.",
+                "INSTANT_PERSONAL_ACCESS_TOKEN=",
+            ].join("\n"),
+            "DOMAIN.md": [
+                "# Ekairos Agent Template",
+                "",
+                "This app is the minimal loop for Ekairos event contexts:",
+                "",
+                "1. create the app",
+                "2. start an agent context through `/api/agent/react`",
+                "3. open the Instant app in Workbench v2",
+                "4. iterate on `src/agent.ts`",
+                "",
+                "The scaffold uses the canonical `@ekairos/events` schema so Workbench v2 can inspect `event_contexts`.",
+                "It includes an Ekairos registry alias so domain UI components can be installed with shadcn and use `@ekairos/events` directly.",
+            ].join("\n"),
+            "components.json": [
+                "{",
+                '  "$schema": "https://ui.shadcn.com/schema.json",',
+                '  "style": "default",',
+                '  "rsc": false,',
+                '  "tsx": true,',
+                '  "tailwind": {',
+                '    "config": "",',
+                '    "css": "src/app/globals.css",',
+                '    "baseColor": "zinc",',
+                '    "cssVariables": true,',
+                '    "prefix": ""',
+                "  },",
+                '  "iconLibrary": "lucide",',
+                '  "aliases": {',
+                '    "components": "@/components",',
+                '    "utils": "@/lib/utils",',
+                '    "ui": "@/components/ui",',
+                '    "lib": "@/lib",',
+                '    "hooks": "@/hooks"',
+                "  },",
+                '  "registries": {',
+                '    "@ekairos": "https://registry.ekairos.dev/r/{name}.json"',
+                "  }",
+                "}",
+            ].join("\n"),
+            "instant.schema.ts": [
+                'import { eventsDomain } from "@ekairos/events/schema";',
+                "",
+                "const schema = eventsDomain.toInstantSchema();",
+                "",
+                "export default schema;",
+            ].join("\n"),
+            "next-env.d.ts": [
+                '/// <reference types="next" />',
+                '/// <reference types="next/image-types/global" />',
+                "",
+                "// This file is managed by Next.js.",
+            ].join("\n"),
+            "next.config.ts": [
+                'import type { NextConfig } from "next";',
+                'import { withWorkflow } from "workflow/next";',
+                "",
+                "const nextConfig: NextConfig = {",
+                "  transpilePackages: [\"@ekairos/domain\", \"@ekairos/events\"],",
+                "};",
+                "",
+                "export default withWorkflow(nextConfig) as NextConfig;",
+            ].join("\n"),
+            "package.json": `${JSON.stringify(packageJson, null, 2)}\n`,
+            "tsconfig.json": [
+                "{",
+                '  "compilerOptions": {',
+                '    "target": "ES2022",',
+                '    "lib": ["dom", "dom.iterable", "es2022"],',
+                '    "allowJs": false,',
+                '    "skipLibCheck": true,',
+                '    "strict": true,',
+                '    "noEmit": true,',
+                '    "esModuleInterop": true,',
+                '    "module": "esnext",',
+                '    "moduleResolution": "bundler",',
+                '    "resolveJsonModule": true,',
+                '    "isolatedModules": true,',
+                '    "jsx": "react-jsx",',
+                '    "incremental": true,',
+                '    "paths": {',
+                '      "@/*": ["./src/*"]',
+                "    },",
+                '    "plugins": [',
+                '      { "name": "next" }',
+                "    ]",
+                "  },",
+                '  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts", ".next/dev/types/**/*.ts"],',
+                '  "exclude": ["node_modules"]',
+                "}",
+            ].join("\n"),
+            "src/app/globals.css": [
+                ":root {",
+                "  color-scheme: light;",
+                "  --background: #f7f8f6;",
+                "  --foreground: #171a18;",
+                "  --muted: #626a63;",
+                "  --border: #d9ded7;",
+                "  --surface: #ffffff;",
+                "  --accent: #26715f;",
+                "}",
+                "* { box-sizing: border-box; }",
+                "html, body { margin: 0; min-height: 100%; }",
+                "body { min-height: 100dvh; background: var(--background); color: var(--foreground); font-family: \"Segoe UI\", sans-serif; }",
+                "button, textarea, input { font: inherit; }",
+                "main { width: min(980px, calc(100% - 32px)); margin: 0 auto; padding: 44px 0; }",
+                ".shell { display: grid; gap: 22px; }",
+                ".eyebrow { color: var(--accent); font-size: 12px; font-weight: 800; letter-spacing: 0.14em; text-transform: uppercase; }",
+                "h1 { max-width: 760px; margin: 0; font-size: clamp(2.1rem, 5vw, 4.4rem); line-height: 1; }",
+                "p { max-width: 68ch; margin: 0; color: var(--muted); line-height: 1.65; }",
+                ".panel { display: grid; gap: 16px; border: 1px solid var(--border); background: var(--surface); padding: 20px; }",
+                ".grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); border: 1px solid var(--border); }",
+                ".grid div { display: grid; gap: 6px; padding: 14px; border-right: 1px solid var(--border); }",
+                ".grid div:last-child { border-right: 0; }",
+                ".grid span { color: var(--muted); font-size: 11px; font-weight: 800; letter-spacing: 0.12em; text-transform: uppercase; }",
+                ".grid strong { font-size: 1rem; overflow-wrap: anywhere; }",
+                "textarea { width: 100%; min-height: 120px; resize: vertical; border: 1px solid var(--border); padding: 12px; }",
+                "button { width: fit-content; border: 0; background: var(--accent); color: white; padding: 10px 14px; font-weight: 700; cursor: pointer; }",
+                "button:disabled { cursor: wait; opacity: 0.65; }",
+                "pre { overflow: auto; margin: 0; border: 1px solid var(--border); background: #f2f4f1; padding: 14px; }",
+                "code { font-family: \"Cascadia Code\", monospace; }",
+                "@media (max-width: 720px) { .grid { grid-template-columns: 1fr; } .grid div { border-right: 0; border-bottom: 1px solid var(--border); } }",
+            ].join("\n"),
+            "src/app/layout.tsx": [
+                'import "./globals.css";',
+                'import type { ReactNode } from "react";',
+                "",
+                "export const metadata = {",
+                '  title: "Ekairos Agent",',
+                '  description: "Scaffolded Ekairos agent context app",',
+                "};",
+                "",
+                "export default function RootLayout({ children }: { children: ReactNode }) {",
+                "  return (",
+                '    <html lang="en">',
+                "      <body>{children}</body>",
+                "    </html>",
+                "  );",
+                "}",
+            ].join("\n"),
+            "src/app/page.tsx": [
+                'import AgentWorkbench from "./agent-workbench";',
+                "",
+                'export const dynamic = "force-dynamic";',
+                "",
+                "export default function HomePage() {",
+                "  return (",
+                "    <main>",
+                '      <section className="shell">',
+                '        <div className="eyebrow">Ekairos Agent Template</div>',
+                "        <h1>Start a context, inspect it in Workbench v2, iterate.</h1>",
+                "        <p>",
+                "          This template writes canonical @ekairos/events rows and returns the context id immediately.",
+                "        </p>",
+                "        <AgentWorkbench />",
+                "      </section>",
+                "    </main>",
+                "  );",
+                "}",
+            ].join("\n"),
+            "src/app/agent-workbench.tsx": [
+                '"use client";',
+                "",
+                "import { useMemo, useState } from \"react\";",
+                "",
+                "type AgentResult = {",
+                "  ok: boolean;",
+                "  appId?: string;",
+                "  contextId?: string;",
+                "  contextKey?: string | null;",
+                "  triggerEventId?: string;",
+                "  error?: string;",
+                "};",
+                "",
+                "export default function AgentWorkbench() {",
+                "  const [prompt, setPrompt] = useState(\"Create a deterministic template context.\");",
+                "  const [result, setResult] = useState<AgentResult | null>(null);",
+                "  const [pending, setPending] = useState(false);",
+                "",
+                "  const workbenchPath = useMemo(() => {",
+                "    if (!result?.appId || !result?.contextId) return \"\";",
+                "    return `/app/${result.appId}/contexts/${result.contextId}`;",
+                "  }, [result]);",
+                "",
+                "  async function startContext() {",
+                "    setPending(true);",
+                "    setResult(null);",
+                "    try {",
+                "      const response = await fetch(\"/api/agent/react\", {",
+                "        method: \"POST\",",
+                "        headers: { \"content-type\": \"application/json\" },",
+                "        body: JSON.stringify({ prompt }),",
+                "      });",
+                "      const data = (await response.json().catch(() => ({}))) as AgentResult;",
+                "      setResult(response.ok ? data : { ok: false, error: data.error || response.statusText });",
+                "    } catch (error) {",
+                "      setResult({ ok: false, error: error instanceof Error ? error.message : String(error) });",
+                "    } finally {",
+                "      setPending(false);",
+                "    }",
+                "  }",
+                "",
+                "  return (",
+                '    <section className="panel">',
+                '      <div className="grid">',
+                "        <div><span>Schema</span><strong>@ekairos/events</strong></div>",
+                "        <div><span>Route</span><strong>/api/agent/react</strong></div>",
+                "        <div><span>Mode</span><strong>scripted reactor</strong></div>",
+                "      </div>",
+                "      <textarea value={prompt} onChange={(event) => setPrompt(event.target.value)} />",
+                "      <button type=\"button\" disabled={pending} onClick={startContext}>",
+                "        {pending ? \"Starting context...\" : \"Start context\"}",
+                "      </button>",
+                "      {workbenchPath ? <p>Workbench v2 path: <code>{workbenchPath}</code></p> : null}",
+                "      {result ? <pre>{JSON.stringify(result, null, 2)}</pre> : null}",
+                "    </section>",
+                "  );",
+                "}",
+            ].join("\n"),
+            "src/app/api/agent/react/route.ts": [
+                'import { NextRequest, NextResponse } from "next/server";',
+                'import { agentContext, createTriggerEvent } from "@/agent";',
+                'import { createRuntime } from "@/runtime";',
+                "",
+                "export const maxDuration = 60;",
+                "",
+                "function readTrimmed(value: unknown) {",
+                "  return typeof value === \"string\" ? value.trim() : \"\";",
+                "}",
+                "",
+                "export async function POST(req: NextRequest) {",
+                "  try {",
+                "    const body = await req.json().catch(() => ({}));",
+                "    const prompt = readTrimmed((body as any).prompt) || \"Create a deterministic template context.\";",
+                "    const contextKey = readTrimmed((body as any).contextKey) || `agent-template:${Date.now()}`;",
+                "    const triggerEvent = createTriggerEvent(prompt);",
+                "    const reaction = await agentContext.react(triggerEvent, {",
+                "      runtime: createRuntime({ actorId: \"template-user\" }),",
+                "      context: { key: contextKey },",
+                "      durable: false,",
+                "    });",
+                "    if (reaction.run) await reaction.run;",
+                "    return NextResponse.json({",
+                "      ok: true,",
+                "      appId: process.env.NEXT_PUBLIC_INSTANT_APP_ID || null,",
+                "      contextId: String(reaction.context.id || \"\"),",
+                "      contextKey: reaction.context.key ?? contextKey,",
+                "      triggerEventId: triggerEvent.id,",
+                "    });",
+                "  } catch (error) {",
+                "    return NextResponse.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, { status: 500 });",
+                "  }",
+                "}",
+            ].join("\n"),
+            "src/agent.ts": [
+                "import {",
+                "  createContext,",
+                "  createScriptedReactor,",
+                "  defineAction,",
+                "  eventsDomain,",
+                "  type ContextItem,",
+                "} from \"@ekairos/events\";",
+                "import { z } from \"zod\";",
+                "",
+                "export type AgentEnv = {",
+                "  actorId?: string;",
+                "};",
+                "",
+                "const createMessageInput = z.object({",
+                "  message: z.string(),",
+                "  marker: z.string().optional(),",
+                "});",
+                "",
+                "const createMessageOutput = z.object({",
+                "  message: z.string(),",
+                "  marker: z.string(),",
+                "});",
+                "",
+                "async function createMessage(input: z.infer<typeof createMessageInput>) {",
+                "  \"use step\";",
+                "  return {",
+                "    message: input.message,",
+                "    marker: input.marker ?? \"AGENT_TEMPLATE_OK\",",
+                "  };",
+                "}",
+                "",
+                "function randomId() {",
+                "  return globalThis.crypto?.randomUUID?.() ?? `evt_${Date.now()}_${Math.random().toString(16).slice(2)}`;",
+                "}",
+                "",
+                "export function createTriggerEvent(text: string): ContextItem {",
+                "  return {",
+                "    id: randomId(),",
+                "    type: \"user_message_created\",",
+                "    channel: \"web\",",
+                "    createdAt: new Date().toISOString(),",
+                "    content: { parts: [{ type: \"text\", text }] },",
+                "  } as any;",
+                "}",
+                "",
+                "export const agentContext = createContext<AgentEnv>(\"agent.template\")",
+                "  .context((stored, env) => ({ ...(stored.content ?? {}), actorId: env.actorId ?? null }))",
+                "  .narrative(() => \"You are the minimal Ekairos agent template. Create one deterministic message.\")",
+                "  .actions(() => ({",
+                "    createMessage: defineAction<any, any, Record<string, never>, AgentEnv, typeof eventsDomain>({",
+                "      description: \"Create the deterministic template message.\",",
+                "      input: createMessageInput as any,",
+                "      output: createMessageOutput as any,",
+                "      execute: async ({ input }) => await createMessage(input),",
+                "    }),",
+                "  }))",
+                "  .reactor(",
+                "    createScriptedReactor({",
+                "      steps: [",
+                "        {",
+                "          assistantEvent: {",
+                "            content: {",
+                "              parts: [",
+                "                { type: \"text\", text: \"AGENT_TEMPLATE_OK context ready.\" },",
+                "                {",
+                "                  type: \"tool-createMessage\",",
+                "                  toolCallId: \"agent-template-create-message\",",
+                "                  input: { message: \"AGENT_TEMPLATE_OK context ready.\", marker: \"AGENT_TEMPLATE_OK\" },",
+                "                },",
+                "              ],",
+                "            },",
+                "          },",
+                "          actionRequests: [",
+                "            {",
+                "              actionRef: \"agent-template-create-message\",",
+                "              actionName: \"createMessage\",",
+                "              input: { message: \"AGENT_TEMPLATE_OK context ready.\", marker: \"AGENT_TEMPLATE_OK\" },",
+                "            },",
+                "          ],",
+                "          messagesForModel: [],",
+                "          llm: { provider: \"scripted\", model: \"agent-template\" },",
+                "        },",
+                "      ],",
+                "      repeatLast: true,",
+                "    }),",
+                "  )",
+                "  .shouldContinue(() => false)",
+                "  .build();",
+            ].join("\n"),
+            "src/runtime.ts": [
+                'import { init } from "@instantdb/admin";',
+                'import { EkairosRuntime } from "@ekairos/domain/runtime-handle";',
+                'import { eventsDomain } from "@ekairos/events/schema";',
+                "",
+                "export type AgentRuntimeEnv = {",
+                "  actorId?: string | null;",
+                "  adminToken?: string;",
+                "  appId?: string;",
+                "};",
+                "",
+                "function resolveRuntimeEnv(env: AgentRuntimeEnv = {}): Required<Pick<AgentRuntimeEnv, \"appId\" | \"adminToken\">> & AgentRuntimeEnv {",
+                "  const appId = String(env.appId ?? process.env.NEXT_PUBLIC_INSTANT_APP_ID ?? \"\").trim();",
+                "  const adminToken = String(env.adminToken ?? process.env.INSTANT_ADMIN_TOKEN ?? \"\").trim();",
+                "  if (!appId || !adminToken) {",
+                "    throw new Error(\"Missing NEXT_PUBLIC_INSTANT_APP_ID or INSTANT_ADMIN_TOKEN. Copy .env.example to .env.local and fill both values.\");",
+                "  }",
+                "  return { ...env, appId, adminToken };",
+                "}",
+                "",
+                "export class AgentRuntime extends EkairosRuntime<AgentRuntimeEnv, typeof eventsDomain, any> {",
+                "  protected getDomain() { return eventsDomain; }",
+                "  protected async resolveDb(env: AgentRuntimeEnv) {",
+                "    const resolved = resolveRuntimeEnv(env);",
+                "    return init({",
+                "      appId: resolved.appId,",
+                "      adminToken: resolved.adminToken,",
+                "      schema: eventsDomain.toInstantSchema(),",
+                "      useDateObjects: true,",
+                "    } as any) as any;",
+                "  }",
+                "}",
+                "",
+                "export function createRuntime(env: AgentRuntimeEnv = {}) {",
+                "  return new AgentRuntime(resolveRuntimeEnv(env));",
+                "}",
+            ].join("\n"),
+        };
+    }
     return {
         ".gitignore": [".next", "node_modules", ".env.local", ".workflow-data"].join("\n"),
         ".env.example": [
@@ -275,18 +1576,18 @@ function buildNextTemplateFiles(params) {
             "INSTANT_PERSONAL_ACCESS_TOKEN=",
         ].join("\n"),
         "DOMAIN.md": [
-            "# Ekairos App Domain",
+            "# Ekairos Supply Chain Domain",
             "",
-            "This scaffold ships a small task domain and a live domain showcase UI:",
-            "- inspect the domain through the well-known endpoint",
-            "- fetch the manifest and data directly from the app UI",
-            "- create tasks and seed demo data through domain actions",
-            "- query nested data through InstaQL",
+            "This scaffold ships a supply-chain control tower backed by separate domains:",
+            "- `supplierNetwork` owns supplier risk and score",
+            "- `procurement` owns purchase orders",
+            "- `inventory` owns stock position",
+            "- `transportation` owns shipments and ETA",
+            "- `qualityControl` owns arrival inspection",
             "",
             "Actions:",
-            "- `createTask` -> create one task",
-            "- `addTaskComment` -> attach one comment to a task",
-            "- `seedDemo` -> create demo data fast",
+            "- `launchOrder` -> creates and links supplier, order, stock, shipment, and inspection",
+            "- `expediteShipment` -> updates shipment status and ETA",
         ].join("\n"),
         "instant.schema.ts": [
             'import appDomain from "./src/domain";',
@@ -334,29 +1635,32 @@ function buildNextTemplateFiles(params) {
             '    "moduleResolution": "bundler",',
             '    "resolveJsonModule": true,',
             '    "isolatedModules": true,',
-            '    "jsx": "preserve",',
+            '    "jsx": "react-jsx",',
             '    "incremental": true,',
-            '    "baseUrl": ".",',
             '    "paths": {',
             '      "@/*": ["./src/*"]',
-            "    }",
+            "    },",
+            '    "plugins": [',
+            '      { "name": "next" }',
+            "    ]",
             "  },",
-            '  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],',
+            '  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts", ".next/dev/types/**/*.ts"],',
             '  "exclude": ["node_modules"]',
             "}",
         ].join("\n"),
         "src/app/globals.css": [
             ":root {",
             "  color-scheme: light;",
-            "  --bg: #efe7da;",
-            "  --panel: #fffdf7;",
-            "  --panel-strong: #fff8ec;",
-            "  --ink: #1d1b19;",
-            "  --muted: #60584d;",
-            "  --accent: #0f766e;",
-            "  --accent-soft: #d9f3ef;",
-            "  --border: #d7cebf;",
-            "  --danger: #b42318;",
+            "  --bg: #f7f8f6;",
+            "  --surface: #ffffff;",
+            "  --surface-2: #f0f2ef;",
+            "  --ink: #171a18;",
+            "  --muted: #646b66;",
+            "  --accent: #26715f;",
+            "  --accent-soft: #dfece7;",
+            "  --border: #d9ded9;",
+            "  --line: #b9c1ba;",
+            "  --danger: #9f2f28;",
             "}",
             "",
             "* {",
@@ -367,15 +1671,13 @@ function buildNextTemplateFiles(params) {
             "body {",
             "  margin: 0;",
             "  min-height: 100%;",
-            "  background:",
-            "    radial-gradient(circle at top, #fff8ee 0%, rgba(255, 248, 238, 0.7) 28%, transparent 65%),",
-            "    linear-gradient(180deg, #f7f0e4 0%, var(--bg) 100%);",
+            "  background: var(--bg);",
             "  color: var(--ink);",
-            '  font-family: "Segoe UI", sans-serif;',
+            "  font-family: \"Geist\", \"Aptos\", \"Segoe UI\", sans-serif;",
             "}",
             "",
             "body {",
-            "  min-height: 100vh;",
+            "  min-height: 100dvh;",
             "}",
             "",
             "button,",
@@ -384,242 +1686,360 @@ function buildNextTemplateFiles(params) {
             "}",
             "",
             "main {",
-            "  max-width: 1180px;",
+            "  width: min(1240px, calc(100% - 40px));",
             "  margin: 0 auto;",
-            "  padding: 48px 24px 72px;",
+            "  padding: 44px 0 64px;",
             "}",
             "",
             ".hero {",
             "  display: grid;",
-            "  gap: 18px;",
-            "  max-width: 860px;",
+            "  gap: 14px;",
+            "  max-width: 720px;",
+            "  margin-bottom: 28px;",
             "}",
             "",
             ".eyebrow {",
             "  color: var(--accent);",
-            "  font-size: 12px;",
-            "  font-weight: 700;",
-            "  letter-spacing: 0.2em;",
+            "  font-size: 11px;",
+            "  font-weight: 800;",
+            "  letter-spacing: 0.16em;",
             "  text-transform: uppercase;",
             "}",
             "",
             "h1,",
             "h2 {",
             "  margin: 0;",
-            "  line-height: 0.96;",
+            "  letter-spacing: -0.04em;",
             "}",
             "",
             "h1 {",
-            "  font-size: clamp(2.7rem, 6vw, 5.4rem);",
+            "  max-width: 640px;",
+            "  font-size: clamp(2.4rem, 5.4vw, 4.8rem);",
+            "  line-height: 0.96;",
             "}",
             "",
             "h2 {",
-            "  font-size: 1.4rem;",
+            "  font-size: 1.28rem;",
+            "  line-height: 1.05;",
             "}",
             "",
             "p {",
             "  margin: 0;",
             "  color: var(--muted);",
-            "  line-height: 1.65;",
+            "  line-height: 1.6;",
             "}",
             "",
             ".shell {",
             "  display: grid;",
-            "  gap: 20px;",
-            "  margin-top: 32px;",
+            "  gap: 14px;",
             "}",
             "",
-            ".stat-grid {",
+            ".metrics-strip {",
             "  display: grid;",
-            "  gap: 16px;",
-            "  grid-template-columns: repeat(auto-fit, minmax(170px, 1fr));",
+            "  grid-template-columns: repeat(4, minmax(0, 1fr));",
+            "  border: 1px solid var(--border);",
+            "  background: var(--surface);",
             "}",
             "",
-            ".grid {",
+            ".metrics-strip div {",
             "  display: grid;",
-            "  gap: 20px;",
+            "  gap: 6px;",
+            "  padding: 16px;",
+            "  border-right: 1px solid var(--border);",
             "}",
             "",
-            ".showcase-grid {",
-            "  align-items: start;",
+            ".metrics-strip div:last-child {",
+            "  border-right: 0;",
             "}",
             "",
-            ".panel-tall,",
-            ".panel-wide,",
-            ".stat-card {",
-            "  min-height: 100%;",
+            ".metrics-strip span,",
+            ".manifest-label {",
+            "  color: var(--muted);",
+            "  font-size: 11px;",
+            "  font-weight: 800;",
+            "  letter-spacing: 0.12em;",
+            "  text-transform: uppercase;",
             "}",
             "",
-            ".card {",
-            "  background: linear-gradient(180deg, var(--panel) 0%, var(--panel-strong) 100%);",
+            ".metrics-strip strong {",
+            "  font-size: 1.85rem;",
+            "  letter-spacing: -0.04em;",
+            "  line-height: 1;",
+            "}",
+            "",
+            ".workbench {",
+            "  display: grid;",
+            "  grid-template-columns: 0.8fr 1fr;",
+            "  gap: 14px;",
+            "  align-items: start;",
+            "}",
+            "",
+            ".context-rail,",
+            ".command-panel,",
+            ".graph-panel {",
             "  border: 1px solid var(--border);",
-            "  border-radius: 24px;",
-            "  padding: 22px;",
-            "  box-shadow: 0 18px 45px rgba(23, 23, 23, 0.06);",
+            "  background: var(--surface);",
             "}",
             "",
-            ".stat-card strong {",
-            "  display: block;",
-            "  margin-top: 8px;",
-            "  font-size: 2rem;",
+            ".context-rail,",
+            ".command-panel {",
+            "  padding: 18px;",
+            "}",
+            "",
+            ".graph-panel {",
+            "  grid-column: 1 / -1;",
+            "  padding: 18px;",
             "}",
             "",
             ".panel-head {",
             "  display: flex;",
-            "  align-items: flex-start;",
             "  justify-content: space-between;",
             "  gap: 16px;",
-            "  margin-bottom: 12px;",
+            "  align-items: start;",
+            "  margin-bottom: 16px;",
             "}",
             "",
-            ".manifest-list,",
-            ".action-list,",
-            ".task-list,",
-            ".comment-list {",
+            ".context-list,",
+            ".project-list,",
+            ".task-lines,",
+            ".lane-grid,",
+            ".calls-feed,",
+            ".button-row {",
             "  display: grid;",
-            "  gap: 12px;",
+            "  gap: 10px;",
             "}",
             "",
-            ".manifest-list {",
-            "  margin: 18px 0;",
+            ".context-row {",
+            "  display: grid;",
+            "  grid-template-columns: 0.7fr 1fr;",
+            "  gap: 14px;",
+            "  padding: 12px 0;",
+            "  border-top: 1px solid var(--border);",
+            "  opacity: 0;",
+            "  transform: translateY(8px);",
+            "  animation: lift-in 420ms cubic-bezier(0.16, 1, 0.3, 1) forwards;",
+            "  animation-delay: calc(var(--index) * 70ms);",
             "}",
             "",
-            ".manifest-list > div {",
-            "  display: flex;",
-            "  justify-content: space-between;",
-            "  gap: 16px;",
-            "  border-bottom: 1px dashed var(--border);",
-            "  padding-bottom: 10px;",
+            ".context-row span {",
+            "  font-weight: 800;",
             "}",
             "",
-            ".manifest-label {",
+            ".context-row strong {",
             "  color: var(--muted);",
-            "  font-weight: 600;",
+            "  font-size: 0.92rem;",
+            "  font-weight: 500;",
             "}",
             "",
             ".field {",
             "  display: grid;",
-            "  gap: 8px;",
-            "  margin: 18px 0;",
+            "  gap: 7px;",
+            "  margin: 14px 0;",
             "}",
             "",
             ".field span {",
-            "  font-size: 0.92rem;",
-            "  font-weight: 600;",
+            "  color: var(--muted);",
+            "  font-size: 0.85rem;",
+            "  font-weight: 700;",
             "}",
             "",
             ".input {",
             "  width: 100%;",
             "  border: 1px solid var(--border);",
-            "  border-radius: 16px;",
-            "  padding: 14px 16px;",
-            "  background: #fff;",
+            "  border-radius: 6px;",
+            "  padding: 12px 13px;",
+            "  background: var(--surface-2);",
             "  color: var(--ink);",
+            "  outline: none;",
+            "}",
+            "",
+            ".input:focus {",
+            "  border-color: var(--accent);",
+            "  background: var(--surface);",
             "}",
             "",
             ".button-row {",
-            "  display: flex;",
-            "  flex-wrap: wrap;",
-            "  gap: 12px;",
-            "  margin-bottom: 18px;",
+            "  grid-template-columns: repeat(2, minmax(0, 1fr));",
+            "  margin-top: 16px;",
             "}",
             "",
             ".button {",
             "  appearance: none;",
-            "  border: 0;",
-            "  border-radius: 999px;",
-            "  padding: 12px 18px;",
+            "  border: 1px solid var(--ink);",
+            "  border-radius: 6px;",
+            "  padding: 12px 14px;",
             "  background: var(--ink);",
-            "  color: #fffdf7;",
-            "  display: inline-flex;",
-            "  align-items: center;",
-            "  justify-content: center;",
-            "  gap: 10px;",
+            "  color: #ffffff;",
             "  cursor: pointer;",
-            "  transition: transform 120ms ease, opacity 120ms ease, background 120ms ease;",
+            "  font-weight: 800;",
+            "  transition: transform 160ms cubic-bezier(0.16, 1, 0.3, 1), opacity 160ms ease;",
             "}",
             "",
             ".button:hover:not(:disabled) {",
             "  transform: translateY(-1px);",
             "}",
             "",
+            ".button:active:not(:disabled) {",
+            "  transform: translateY(1px) scale(0.99);",
+            "}",
+            "",
             ".button:disabled {",
             "  cursor: wait;",
-            "  opacity: 0.72;",
+            "  opacity: 0.62;",
             "}",
             "",
             ".button.ghost {",
-            "  background: transparent;",
+            "  border-color: var(--border);",
+            "  background: var(--surface);",
             "  color: var(--ink);",
-            "  border: 1px solid var(--border);",
-            "}",
-            "",
-            ".spinner {",
-            "  width: 14px;",
-            "  height: 14px;",
-            "  border-radius: 999px;",
-            "  border: 2px solid rgba(255, 253, 247, 0.35);",
-            "  border-top-color: currentColor;",
-            "  animation: spin 0.8s linear infinite;",
-            "}",
-            "",
-            ".button.ghost .spinner {",
-            "  border-color: rgba(29, 27, 25, 0.18);",
-            "  border-top-color: currentColor;",
             "}",
             "",
             ".status-pill {",
             "  display: inline-flex;",
             "  align-items: center;",
             "  justify-content: center;",
-            "  padding: 6px 10px;",
-            "  border-radius: 999px;",
+            "  min-width: 86px;",
+            "  padding: 7px 10px;",
+            "  border-radius: 6px;",
             "  background: var(--accent-soft);",
             "  color: var(--accent);",
-            "  font-size: 12px;",
-            "  font-weight: 700;",
-            "  letter-spacing: 0.04em;",
+            "  font-size: 11px;",
+            "  font-weight: 800;",
+            "  letter-spacing: 0.08em;",
             "  text-transform: uppercase;",
             "}",
             "",
-            ".task-card {",
+            ".project-row {",
             "  display: grid;",
-            "  gap: 10px;",
-            "  padding: 16px;",
-            "  border-radius: 18px;",
-            "  border: 1px solid var(--border);",
-            "  background: rgba(255, 255, 255, 0.72);",
+            "  grid-template-columns: 1fr auto;",
+            "  gap: 14px;",
+            "  padding: 16px 0;",
+            "  border-top: 1px solid var(--border);",
+            "}",
+            "",
+            ".project-row:first-child {",
+            "  border-top: 0;",
             "}",
             "",
-            ".task-head {",
+            ".project-row strong {",
+            "  display: block;",
+            "  font-size: 1.05rem;",
+            "}",
+            "",
+            ".project-row span {",
+            "  color: var(--muted);",
+            "}",
+            "",
+            ".project-meta {",
             "  display: flex;",
-            "  align-items: center;",
-            "  justify-content: space-between;",
+            "  flex-wrap: wrap;",
+            "  gap: 8px;",
+            "  justify-content: flex-end;",
+            "}",
+            "",
+            ".project-meta span {",
+            "  border: 1px solid var(--border);",
+            "  border-radius: 6px;",
+            "  padding: 5px 8px;",
+            "  color: var(--ink);",
+            "  font-size: 0.82rem;",
+            "  font-weight: 700;",
+            "}",
+            "",
+            ".task-lines {",
+            "  grid-column: 1 / -1;",
+            "  padding-top: 2px;",
+            "}",
+            "",
+            ".task-lines p {",
+            "  display: grid;",
+            "  grid-template-columns: minmax(180px, 0.8fr) minmax(180px, 1fr);",
             "  gap: 12px;",
+            "  padding-left: 14px;",
+            "  border-left: 2px solid var(--line);",
             "}",
             "",
-            ".comment-item {",
-            "  display: flex;",
-            "  align-items: flex-start;",
-            "  gap: 10px;",
+            ".task-lines b {",
+            "  color: var(--ink);",
+            "}",
+            "",
+            ".task-lines em {",
+            "  grid-column: 1 / -1;",
             "  color: var(--muted);",
+            "  font-style: normal;",
             "}",
             "",
-            ".comment-dot {",
-            "  width: 8px;",
-            "  height: 8px;",
-            "  margin-top: 8px;",
-            "  border-radius: 999px;",
-            "  background: var(--accent);",
-            "  flex: 0 0 auto;",
+            ".raid-summary {",
+            "  display: grid;",
+            "  grid-template-columns: repeat(3, minmax(0, 1fr));",
+            "  border: 1px solid var(--border);",
+            "  margin-bottom: 14px;",
             "}",
             "",
-            ".action-item {",
+            ".raid-summary div {",
             "  display: grid;",
-            "  gap: 4px;",
-            "  padding: 12px 14px;",
-            "  border-radius: 16px;",
-            "  background: rgba(15, 118, 110, 0.06);",
+            "  gap: 6px;",
+            "  padding: 13px;",
+            "  border-right: 1px solid var(--border);",
+            "}",
+            "",
+            ".raid-summary div:last-child {",
+            "  border-right: 0;",
+            "}",
+            "",
+            ".raid-summary span {",
+            "  color: var(--muted);",
+            "  font-size: 11px;",
+            "  font-weight: 800;",
+            "  letter-spacing: 0.12em;",
+            "  text-transform: uppercase;",
+            "}",
+            "",
+            ".raid-summary strong {",
+            "  font-size: 1rem;",
+            "}",
+            "",
+            ".lane-grid {",
+            "  grid-template-columns: repeat(3, minmax(0, 1fr));",
+            "}",
+            "",
+            ".lane {",
+            "  min-height: 180px;",
+            "  border: 1px solid var(--border);",
+            "  padding: 12px;",
+            "  background: var(--surface-2);",
+            "}",
+            "",
+            ".objective {",
+            "  display: grid;",
+            "  gap: 5px;",
+            "  margin-top: 10px;",
+            "  padding: 10px;",
+            "  border: 1px solid var(--border);",
+            "  background: var(--surface);",
+            "}",
+            "",
+            ".objective span,",
+            ".objective em {",
+            "  color: var(--muted);",
+            "  font-size: 0.88rem;",
+            "  font-style: normal;",
+            "}",
+            "",
+            ".calls-feed {",
+            "  margin-top: 14px;",
+            "  padding-top: 14px;",
+            "  border-top: 1px solid var(--border);",
+            "}",
+            "",
+            ".calls-feed p {",
+            "  display: flex;",
+            "  justify-content: space-between;",
+            "  gap: 16px;",
+            "}",
+            "",
+            ".calls-feed b {",
+            "  color: var(--ink);",
             "}",
             "",
             ".muted {",
@@ -628,59 +2048,100 @@ function buildNextTemplateFiles(params) {
             "",
             ".empty-state,",
             ".error-banner {",
-            "  border-radius: 18px;",
-            "  padding: 16px;",
+            "  border: 1px solid var(--border);",
+            "  border-radius: 6px;",
+            "  padding: 14px;",
             "}",
             "",
             ".empty-state {",
-            "  background: rgba(15, 118, 110, 0.06);",
+            "  background: var(--surface-2);",
             "  color: var(--muted);",
             "}",
             "",
             ".error-banner {",
-            "  background: rgba(180, 35, 24, 0.08);",
+            "  background: #fff4f2;",
             "  color: var(--danger);",
-            "  border: 1px solid rgba(180, 35, 24, 0.16);",
+            "  border-color: #efc4bd;",
+            "}",
+            "",
+            ".skeleton-stack {",
+            "  display: grid;",
+            "  gap: 10px;",
+            "}",
+            "",
+            ".skeleton-stack span {",
+            "  display: block;",
+            "  height: 54px;",
+            "  border-radius: 6px;",
+            "  background: linear-gradient(90deg, var(--surface-2), #ffffff, var(--surface-2));",
+            "  background-size: 220% 100%;",
+            "  animation: shimmer 1.2s ease-in-out infinite;",
             "}",
             "",
             "pre {",
             "  overflow: auto;",
-            "  border-radius: 16px;",
-            "  padding: 14px;",
-            "  background: #171717;",
-            "  color: #f6f6f6;",
-            "  font-size: 13px;",
-            "  line-height: 1.5;",
+            "  margin-top: 14px;",
+            "  border-radius: 6px;",
+            "  padding: 12px;",
+            "  background: #1d211f;",
+            "  color: #eef5f1;",
+            "  font-size: 12px;",
+            "  line-height: 1.45;",
             "}",
             "",
             "code {",
-            '  font-family: "Cascadia Code", monospace;',
-            "}",
-            "",
-            "@keyframes spin {",
-            "  to { transform: rotate(360deg); }",
+            "  font-family: \"Geist Mono\", \"Cascadia Code\", monospace;",
             "}",
             "",
-            "@media (min-width: 940px) {",
-            "  .showcase-grid {",
-            "    grid-template-columns: 1.05fr 0.95fr;",
+            "@keyframes lift-in {",
+            "  to {",
+            "    opacity: 1;",
+            "    transform: translateY(0);",
             "  }",
+            "}",
             "",
-            "  .panel-wide {",
-            "    grid-column: 1 / -1;",
+            "@keyframes shimmer {",
+            "  to {",
+            "    background-position: -220% 0;",
             "  }",
             "}",
             "",
-            "@media (max-width: 720px) {",
+            "@media (max-width: 820px) {",
             "  main {",
-            "    padding: 32px 16px 56px;",
+            "    width: min(100% - 28px, 1240px);",
+            "    padding: 32px 0 52px;",
             "  }",
             "",
-            "  .task-head,",
-            "  .manifest-list > div,",
-            "  .panel-head {",
+            "  .metrics-strip,",
+            "  .workbench,",
+            "  .button-row,",
+            "  .raid-summary,",
+            "  .lane-grid,",
+            "  .project-row,",
+            "  .task-lines p {",
             "    grid-template-columns: 1fr;",
-            "    display: grid;",
+            "  }",
+            "",
+            "  .metrics-strip div {",
+            "    border-right: 0;",
+            "    border-bottom: 1px solid var(--border);",
+            "  }",
+            "",
+            "  .metrics-strip div:last-child {",
+            "    border-bottom: 0;",
+            "  }",
+            "",
+            "  .project-meta {",
+            "    justify-content: flex-start;",
+            "  }",
+            "",
+            "  .raid-summary div {",
+            "    border-right: 0;",
+            "    border-bottom: 1px solid var(--border);",
+            "  }",
+            "",
+            "  .raid-summary div:last-child {",
+            "    border-bottom: 0;",
             "  }",
             "}",
         ].join("\n"),
@@ -702,19 +2163,18 @@ function buildNextTemplateFiles(params) {
             "}",
         ].join("\n"),
         "src/app/page.tsx": [
-            'import DomainShowcase from "./domain-showcase";',
+            "import DomainShowcase from \"./domain-showcase\";",
             "",
-            'export const dynamic = "force-dynamic";',
+            "export const dynamic = \"force-dynamic\";",
             "",
             "export default function HomePage() {",
             "  return (",
             "    <main>",
-            '      <section className="hero">',
-            '        <div className="eyebrow">Ekairos Domain Scaffold</div>',
-            "        <h1>See your domain. Query it. Trigger an action.</h1>",
+            "      <section className=\"hero\">",
+            "        <div className=\"eyebrow\">Ekairos Domain Scaffold</div>",
+            "        <h1>Supply chain control tower.</h1>",
             "        <p>",
-            "          This template turns the app itself into a live domain showroom: it reads the manifest,",
-            "          queries nested data, and lets you execute actions from the UI with direct API calls.",
+            "          Open an order, track stock, shipment, supplier risk, and quality status in one live view.",
             "        </p>",
             "      </section>",
             "",
@@ -724,352 +2184,472 @@ function buildNextTemplateFiles(params) {
             "}",
         ].join("\n"),
         "src/app/domain-showcase.tsx": [
-            '"use client";',
+            "\"use client\";",
             "",
-            'import { useEffect, useMemo, useState } from "react";',
+            "import { useMemo, useState } from \"react\";",
+            "import { init } from \"@instantdb/react\";",
             "",
-            "type ManifestAction = {",
-            "  name: string;",
-            "  key?: string | null;",
-            "  description?: string | null;",
+            "type SupplierRow = {",
+            "  id?: string;",
+            "  name?: string;",
+            "  region?: string;",
+            "  risk?: string;",
+            "  score?: number;",
             "};",
             "",
-            "type DomainManifest = {",
-            "  ok?: boolean;",
-            "  instant?: { appId?: string | null };",
-            "  auth?: { required?: boolean };",
-            "  contextString?: string | null;",
-            "  domain?: { entities?: string[]; links?: string[]; rooms?: string[] };",
-            "  actions?: ManifestAction[];",
+            "type StockItemRow = {",
+            "  id?: string;",
+            "  sku?: string;",
+            "  warehouse?: string;",
+            "  available?: number;",
+            "  safetyStock?: number;",
             "};",
             "",
-            "type TaskComment = {",
+            "type InspectionRow = {",
             "  id?: string;",
-            "  body?: string;",
-            "  createdAt?: number;",
+            "  result?: string;",
+            "  severity?: string;",
+            "  note?: string;",
             "};",
             "",
-            "type TaskRow = {",
+            "type ShipmentRow = {",
             "  id?: string;",
-            "  title?: string;",
+            "  carrier?: string;",
+            "  lane?: string;",
             "  status?: string;",
-            "  createdAt?: number;",
-            "  comments?: TaskComment[] | TaskComment;",
+            "  etaHours?: number;",
+            "  inspections?: InspectionRow[] | InspectionRow;",
             "};",
             "",
-            "async function requestJson<T>(input: RequestInfo, init?: RequestInit): Promise<T> {",
-            "  const response = await fetch(input, {",
-            "    ...init,",
-            "    headers: {",
-            '      "content-type": "application/json",',
-            "      ...(init?.headers ?? {}),",
-            "    },",
-            "    cache: 'no-store',",
-            "  });",
-            "  const text = await response.text();",
-            "  if (!response.ok) {",
-            "    throw new Error(text || `request_failed:${response.status}`);",
-            "  }",
-            "  return (text ? JSON.parse(text) : null) as T;",
-            "}",
+            "type OrderRow = {",
+            "  id?: string;",
+            "  reference?: string;",
+            "  status?: string;",
+            "  spend?: number;",
+            "  supplier?: SupplierRow | SupplierRow[];",
+            "  stockItems?: StockItemRow[] | StockItemRow;",
+            "  shipments?: ShipmentRow[] | ShipmentRow;",
+            "};",
+            "",
+            "const db = init({",
+            "  appId: process.env.NEXT_PUBLIC_INSTANT_APP_ID || \"\",",
+            "});",
             "",
             "function asArray<T>(value: T | T[] | null | undefined): T[] {",
             "  if (!value) return [];",
             "  return Array.isArray(value) ? value : [value];",
             "}",
             "",
-            "function formatTime(value?: number) {",
-            "  if (!value) return 'now';",
-            "  try {",
-            "    return new Intl.DateTimeFormat(undefined, { dateStyle: 'medium', timeStyle: 'short' }).format(new Date(value));",
-            "  } catch {",
-            "    return String(value);",
-            "  }",
+            "function first<T>(value: T | T[] | null | undefined): T | null {",
+            "  return asArray(value)[0] ?? null;",
+            "}",
+            "",
+            "function money(value?: number) {",
+            "  return new Intl.NumberFormat(undefined, {",
+            "    currency: \"USD\",",
+            "    maximumFractionDigits: 0,",
+            "    style: \"currency\",",
+            "  }).format(value ?? 0);",
+            "}",
+            "",
+            "async function runAction(action: string, input: Record<string, unknown>) {",
+            "  const response = await fetch(\"/api/ekairos/domain\", {",
+            "    method: \"POST\",",
+            "    headers: { \"content-type\": \"application/json\" },",
+            "    body: JSON.stringify({ op: \"action\", action, input }),",
+            "  });",
+            "  const text = await response.text();",
+            "  if (!response.ok) throw new Error(text || `request_failed:${response.status}`);",
+            "  return text ? JSON.parse(text) : null;",
             "}",
             "",
             "export default function DomainShowcase() {",
-            "  const [manifest, setManifest] = useState<DomainManifest | null>(null);",
-            "  const [tasks, setTasks] = useState<TaskRow[]>([]);",
-            "  const [draftTitle, setDraftTitle] = useState('Ship a polished domain demo');",
+            "  const [reference, setReference] = useState(\"PO-7842\");",
+            "  const [supplierName, setSupplierName] = useState(\"Marula Components\");",
+            "  const [sku, setSku] = useState(\"DRV-2048\");",
             "  const [loadingAction, setLoadingAction] = useState<string | null>(null);",
-            "  const [loadingData, setLoadingData] = useState(true);",
-            "  const [error, setError] = useState<string | null>(null);",
-            "  const [lastResult, setLastResult] = useState<unknown>(null);",
-            "",
-            "  const counts = useMemo(() => ({",
-            "    entities: manifest?.domain?.entities?.length ?? 0,",
-            "    links: manifest?.domain?.links?.length ?? 0,",
-            "    actions: manifest?.actions?.length ?? 0,",
-            "    tasks: tasks.length,",
-            "  }), [manifest, tasks]);",
-            "",
-            "  async function refresh() {",
-            "    setLoadingData(true);",
-            "    setError(null);",
-            "    try {",
-            "      const manifestData = await requestJson<DomainManifest>('/api/ekairos/domain', { method: 'GET' });",
-            "      setManifest(manifestData);",
-            "",
-            "      const queryData = await requestJson<{ data?: { app_tasks?: TaskRow[] } }>('/api/ekairos/domain', {",
-            "        method: 'POST',",
-            "        body: JSON.stringify({",
-            "          op: 'query',",
-            "          query: {",
-            "            app_tasks: {",
-            "              $: { order: { createdAt: 'desc' }, limit: 20 },",
-            "              comments: {},",
-            "            },",
-            "          },",
-            "        }),",
-            "      });",
-            "",
-            "      setTasks(Array.isArray(queryData?.data?.app_tasks) ? queryData.data.app_tasks : []);",
-            "    } catch (nextError) {",
-            "      setError(nextError instanceof Error ? nextError.message : String(nextError));",
-            "    } finally {",
-            "      setLoadingData(false);",
-            "    }",
-            "  }",
-            "",
-            "  useEffect(() => {",
-            "    void refresh();",
-            "  }, []);",
+            "  const [actionError, setActionError] = useState<string | null>(null);",
+            "",
+            "  const query = db.useQuery({",
+            "    procurement_order: {",
+            "      $: { order: { createdAt: \"desc\" }, limit: 8 },",
+            "      supplier: {},",
+            "      stockItems: {},",
+            "      shipments: {",
+            "        inspections: {},",
+            "      },",
+            "    },",
+            "  }) as {",
+            "    data?: { procurement_order?: OrderRow[] };",
+            "    error?: unknown;",
+            "    isLoading: boolean;",
+            "  };",
             "",
-            "  async function runAction(action: string, input: Record<string, unknown>) {",
+            "  const orders = query.data?.procurement_order ?? [];",
+            "  const activeOrder = orders[0] ?? null;",
+            "  const supplier = first(activeOrder?.supplier);",
+            "  const stockItems = asArray(activeOrder?.stockItems);",
+            "  const shipments = asArray(activeOrder?.shipments);",
+            "  const shipment = shipments[0] ?? null;",
+            "  const inspections = shipments.flatMap((entry) => asArray(entry.inspections));",
+            "  const inspection = inspections[0] ?? null;",
+            "",
+            "  const metrics = useMemo(() => ({",
+            "    orders: orders.length,",
+            "    stock: stockItems.reduce((total, item) => total + (item.available ?? 0), 0),",
+            "    eta: shipment?.etaHours ?? 0,",
+            "    risk: supplier?.risk ?? \"none\",",
+            "  }), [orders.length, shipment?.etaHours, stockItems, supplier?.risk]);",
+            "",
+            "  async function submitAction(action: string, input: Record<string, unknown>) {",
             "    setLoadingAction(action);",
-            "    setError(null);",
+            "    setActionError(null);",
             "    try {",
-            "      const result = await requestJson('/api/ekairos/domain', {",
-            "        method: 'POST',",
-            "        body: JSON.stringify({ op: 'action', action, input }),",
-            "      });",
-            "      setLastResult(result);",
-            "      await refresh();",
-            "    } catch (nextError) {",
-            "      setError(nextError instanceof Error ? nextError.message : String(nextError));",
+            "      await runAction(action, input);",
+            "    } catch (error) {",
+            "      setActionError(error instanceof Error ? error.message : String(error));",
             "    } finally {",
             "      setLoadingAction(null);",
             "    }",
             "  }",
             "",
             "  return (",
-            '    <section className="shell">',
-            '      <div className="stat-grid">',
-            '        <article className="card stat-card"><span className="eyebrow">Entities</span><strong>{counts.entities}</strong></article>',
-            '        <article className="card stat-card"><span className="eyebrow">Links</span><strong>{counts.links}</strong></article>',
-            '        <article className="card stat-card"><span className="eyebrow">Actions</span><strong>{counts.actions}</strong></article>',
-            '        <article className="card stat-card"><span className="eyebrow">Tasks</span><strong>{counts.tasks}</strong></article>',
+            "    <section className=\"shell\">",
+            "      <div className=\"metrics-strip\">",
+            "        <div><span>open orders</span><strong>{metrics.orders}</strong></div>",
+            "        <div><span>available stock</span><strong>{metrics.stock}</strong></div>",
+            "        <div><span>shipment eta</span><strong>{metrics.eta}h</strong></div>",
+            "        <div><span>supplier risk</span><strong>{metrics.risk}</strong></div>",
             "      </div>",
             "",
-            '      <div className="grid showcase-grid">',
-            '        <article className="card panel-tall">',
-            '          <div className="panel-head">',
-            '            <div>',
-            '              <span className="eyebrow">Domain Manifest</span>',
-            '              <h2>Live contract</h2>',
-            "            </div>",
-            "            <button className=\"button ghost\" onClick={() => void refresh()} disabled={loadingData}>",
-            '              {loadingData ? <span className="spinner" aria-hidden="true" /> : null}',
-            "              Refresh",
-            "            </button>",
-            "          </div>",
-            '          <p className="muted">The UI calls the same Ekairos runtime route your CLI uses.</p>',
-            '          <div className="manifest-list">',
-            '            <div><span className="manifest-label">App ID</span><span>{manifest?.instant?.appId ?? "not configured yet"}</span></div>',
-            '            <div><span className="manifest-label">Auth</span><span>{manifest?.auth?.required ? "required" : "open"}</span></div>',
-            '            <div><span className="manifest-label">Entities</span><span>{(manifest?.domain?.entities ?? []).join(", ") || "none"}</span></div>',
-            '            <div><span className="manifest-label">Links</span><span>{(manifest?.domain?.links ?? []).join(", ") || "none"}</span></div>',
-            "          </div>",
-            '          <pre><code>{manifest?.contextString ?? "Context string will appear here after the first fetch."}</code></pre>',
-            "        </article>",
-            "",
-            '        <article className="card panel-tall">',
-            '          <div className="panel-head">',
-            '            <div>',
-            '              <span className="eyebrow">Action Demo</span>',
-            '              <h2>Trigger the domain</h2>',
-            "            </div>",
-            "          </div>",
-            '          <p className="muted">Use the API directly. Click one action and watch the data refresh below.</p>',
-            '          <label className="field">',
-            '            <span>Task title</span>',
-            '            <input',
-            '              className="input"',
-            '              value={draftTitle}',
-            '              onChange={(event) => setDraftTitle(event.target.value)}',
-            '              placeholder="Name your first task"',
-            "            />",
+            "      <div className=\"workbench\">",
+            "        <section className=\"command-panel\">",
+            "          <span className=\"eyebrow\">Release</span>",
+            "          <h2>Open a purchase order</h2>",
+            "          <label className=\"field\">",
+            "            <span>PO reference</span>",
+            "            <input className=\"input\" value={reference} onChange={(event) => setReference(event.target.value)} />",
             "          </label>",
-            '          <div className="button-row">',
+            "          <label className=\"field\">",
+            "            <span>Supplier</span>",
+            "            <input className=\"input\" value={supplierName} onChange={(event) => setSupplierName(event.target.value)} />",
+            "          </label>",
+            "          <label className=\"field\">",
+            "            <span>SKU</span>",
+            "            <input className=\"input\" value={sku} onChange={(event) => setSku(event.target.value)} />",
+            "          </label>",
+            "          <div className=\"button-row\">",
             "            <button",
-            '              className="button"',
+            "              className=\"button\"",
             "              disabled={loadingAction !== null}",
-            "              onClick={() => void runAction('app.task.create', { title: draftTitle, status: 'manual' })}",
+            "              onClick={() => void submitAction(\"supplyChain.order.launch\", { reference, sku, supplierName })}",
             "            >",
-            '              {loadingAction === "app.task.create" ? <span className="spinner" aria-hidden="true" /> : null}',
-            "              Create Task",
+            "              {loadingAction === \"supplyChain.order.launch\" ? \"Opening\" : \"Open order\"}",
             "            </button>",
             "            <button",
-            '              className="button ghost"',
-            "              disabled={loadingAction !== null}",
-            "              onClick={() => void runAction('app.demo.seed', {})}",
+            "              className=\"button ghost\"",
+            "              disabled={loadingAction !== null || !shipment?.id}",
+            "              onClick={() => void submitAction(\"supplyChain.shipment.expedite\", { shipmentId: shipment?.id })}",
             "            >",
-            '              {loadingAction === "app.demo.seed" ? <span className="spinner" aria-hidden="true" /> : null}',
-            "              Seed Demo",
+            "              Expedite shipment",
             "            </button>",
             "          </div>",
-            '          <div className="action-list">',
-            '            {(manifest?.actions ?? []).map((action) => (',
-            '              <div className="action-item" key={action.name}>',
-            '                <strong>{action.key ?? action.name}</strong>',
-            '                <span>{action.description ?? action.name}</span>',
-            "              </div>",
-            "            ))}",
+            "        </section>",
+            "",
+            "        <section className=\"context-rail\" aria-label=\"Operational path\">",
+            "          <div className=\"panel-head\">",
+            "            <div>",
+            "              <span className=\"eyebrow\">Path</span>",
+            "              <h2>What gets linked</h2>",
+            "            </div>",
+            "          </div>",
+            "          <div className=\"context-list\">",
+            "            <div className=\"context-row\"><span>Supplier</span><strong>Risk and commercial owner</strong></div>",
+            "            <div className=\"context-row\"><span>Order</span><strong>Spend and release state</strong></div>",
+            "            <div className=\"context-row\"><span>Inventory</span><strong>SKU and stock position</strong></div>",
+            "            <div className=\"context-row\"><span>Transport</span><strong>Carrier lane and ETA</strong></div>",
+            "            <div className=\"context-row\"><span>Quality</span><strong>Arrival inspection</strong></div>",
             "          </div>",
-            '          <pre><code>{lastResult ? JSON.stringify(lastResult, null, 2) : "Action results will appear here."}</code></pre>',
-            "        </article>",
-            "",
-            '        <article className="card panel-wide">',
-            '          <div className="panel-head">',
-            '            <div>',
-            '              <span className="eyebrow">Query Result</span>',
-            '              <h2>Nested task data</h2>',
+            "        </section>",
+            "",
+            "        <section className=\"graph-panel\">",
+            "          <div className=\"panel-head\">",
+            "            <div>",
+            "              <span className=\"eyebrow\">Live order</span>",
+            "              <h2>{activeOrder?.reference ?? \"No order active\"}</h2>",
             "            </div>",
-            '            <span className="status-pill">{loadingData ? "syncing" : `${tasks.length} rows`}</span>',
+            "            <span className=\"status-pill\">{query.isLoading ? \"loading\" : activeOrder?.status ?? \"idle\"}</span>",
             "          </div>",
-            '          <p className="muted">This list comes from a direct `op: "query"` call to the domain API.</p>',
-            '          {tasks.length === 0 ? <div className="empty-state">No tasks yet. Click <strong>Seed Demo</strong> to populate the canvas.</div> : null}',
-            '          <div className="task-list">',
-            '            {tasks.map((task, index) => (',
-            '              <article className="task-card" key={task.id ?? `${task.title ?? "task"}-${index}`}>',
-            '                <div className="task-head">',
-            '                  <strong>{task.title ?? "Untitled task"}</strong>',
-            '                  <span className="status-pill">{task.status ?? "draft"}</span>',
+            "",
+            "          {query.isLoading ? (",
+            "            <div className=\"skeleton-stack\" aria-label=\"Loading order\">",
+            "              <span />",
+            "              <span />",
+            "              <span />",
+            "            </div>",
+            "          ) : query.error ? (",
+            "            <div className=\"error-banner\">{String(query.error)}</div>",
+            "          ) : !activeOrder ? (",
+            "            <div className=\"empty-state\">Open an order to create the first control tower view.</div>",
+            "          ) : (",
+            "            <>",
+            "              <div className=\"raid-summary\">",
+            "                <div>",
+            "                  <span>supplier</span>",
+            "                  <strong>{supplier?.name ?? \"unassigned\"}</strong>",
             "                </div>",
-            '                <span className="muted">{formatTime(task.createdAt)}</span>',
-            '                <div className="comment-list">',
-            '                  {asArray(task.comments).map((comment, commentIndex) => (',
-            '                    <div className="comment-item" key={comment.id ?? `${index}-${commentIndex}`}>',
-            '                      <span className="comment-dot" />',
-            '                      <span>{comment.body ?? "Empty comment"}</span>',
-            "                    </div>",
+            "                <div>",
+            "                  <span>region</span>",
+            "                  <strong>{supplier?.region ?? \"unknown\"}</strong>",
+            "                </div>",
+            "                <div>",
+            "                  <span>spend</span>",
+            "                  <strong>{money(activeOrder.spend)}</strong>",
+            "                </div>",
+            "              </div>",
+            "",
+            "              <div className=\"lane-grid\">",
+            "                <div className=\"lane\">",
+            "                  <span className=\"manifest-label\">Inventory</span>",
+            "                  {stockItems.map((item) => (",
+            "                    <article className=\"objective\" key={item.id}>",
+            "                      <strong>{item.sku}</strong>",
+            "                      <span>{item.warehouse}</span>",
+            "                      <em>{item.available} units / {item.safetyStock} safety</em>",
+            "                    </article>",
             "                  ))}",
             "                </div>",
-            "              </article>",
-            "            ))}",
-            "          </div>",
-            "        </article>",
+            "                <div className=\"lane\">",
+            "                  <span className=\"manifest-label\">Transport</span>",
+            "                  {shipments.map((entry) => (",
+            "                    <article className=\"objective\" key={entry.id}>",
+            "                      <strong>{entry.carrier}</strong>",
+            "                      <span>{entry.lane}</span>",
+            "                      <em>{entry.status} / {entry.etaHours}h ETA</em>",
+            "                    </article>",
+            "                  ))}",
+            "                </div>",
+            "                <div className=\"lane\">",
+            "                  <span className=\"manifest-label\">Quality</span>",
+            "                  {inspections.map((entry) => (",
+            "                    <article className=\"objective\" key={entry.id}>",
+            "                      <strong>{entry.result}</strong>",
+            "                      <span>{entry.severity}</span>",
+            "                      <em>{entry.note}</em>",
+            "                    </article>",
+            "                  ))}",
+            "                </div>",
+            "              </div>",
+            "            </>",
+            "          )}",
+            "        </section>",
             "      </div>",
             "",
-            '      {error ? <div className="error-banner">{error}</div> : null}',
+            "      {actionError ? <div className=\"error-banner\">{actionError}</div> : null}",
             "    </section>",
             "  );",
             "}",
         ].join("\n"),
         "src/domain.ts": [
-            'import { defineDomainAction, domain } from "@ekairos/domain";',
-            'import { i } from "@instantdb/core";',
+            "import { defineAction, domain } from \"@ekairos/domain\";",
+            "import { i } from \"@instantdb/core\";",
+            "import { z } from \"zod\";",
+            "",
+            "export const supplierNetworkDomain = domain(\"supplierNetwork\").withSchema({",
+            "  entities: {",
+            "    supplierNetwork_supplier: i.entity({",
+            "      name: i.string().indexed(),",
+            "      region: i.string().indexed(),",
+            "      risk: i.string().indexed(),",
+            "      score: i.number().indexed(),",
+            "      createdAt: i.number().indexed(),",
+            "    }),",
+            "  },",
+            "  links: {},",
+            "  rooms: {},",
+            "});",
             "",
-            "const baseDomain = domain(\"ekairos.app\")",
-            "  .schema({",
+            "export const procurementDomain = domain(\"procurement\")",
+            "  .includes(supplierNetworkDomain)",
+            "  .withSchema({",
             "    entities: {",
-            "      app_tasks: i.entity({",
-            "        title: i.string().indexed(),",
+            "      procurement_order: i.entity({",
+            "        reference: i.string().indexed(),",
             "        status: i.string().indexed(),",
+            "        spend: i.number().indexed(),",
             "        createdAt: i.number().indexed(),",
             "      }),",
-            "      app_task_comments: i.entity({",
-            "        body: i.string(),",
+            "    },",
+            "    links: {",
+            "      procurement_orderSupplier: {",
+            "        forward: { on: \"procurement_order\", has: \"one\", label: \"supplier\" },",
+            "        reverse: { on: \"supplierNetwork_supplier\", has: \"many\", label: \"orders\" },",
+            "      },",
+            "    },",
+            "    rooms: {},",
+            "  });",
+            "",
+            "export const inventoryDomain = domain(\"inventory\")",
+            "  .includes(procurementDomain)",
+            "  .withSchema({",
+            "    entities: {",
+            "      inventory_stockItem: i.entity({",
+            "        sku: i.string().indexed(),",
+            "        warehouse: i.string().indexed(),",
+            "        available: i.number().indexed(),",
+            "        safetyStock: i.number().indexed(),",
             "        createdAt: i.number().indexed(),",
             "      }),",
             "    },",
             "    links: {",
-            "      taskComments: {",
-            '        forward: { on: "app_tasks", has: "many", label: "comments" },',
-            '        reverse: { on: "app_task_comments", has: "one", label: "task" },',
+            "      inventory_stockItemOrder: {",
+            "        forward: { on: \"inventory_stockItem\", has: \"one\", label: \"order\" },",
+            "        reverse: { on: \"procurement_order\", has: \"many\", label: \"stockItems\" },",
             "      },",
             "    },",
             "    rooms: {},",
             "  });",
             "",
-            "export const createTaskAction = defineDomainAction<",
-            "  Record<string, unknown>,",
-            "  { title?: string; status?: string },",
-            "  { taskId: string },",
-            "  any",
-            ">({",
-            '  name: "app.task.create",',
-            "  async execute({ runtime, input }): Promise<{ taskId: string }> {",
-            '    "use step";',
-            "    const scoped = await runtime.use(appDomain);",
-            "    const taskId = globalThis.crypto.randomUUID();",
-            "    await scoped.db.transact([",
-            "      scoped.db.tx.app_tasks[taskId].update({",
-            '        title: String((input as any)?.title ?? "").trim() || "Untitled task",',
-            '        status: String((input as any)?.status ?? "").trim() || "draft",',
-            "        createdAt: Date.now(),",
+            "export const transportationDomain = domain(\"transportation\")",
+            "  .includes(procurementDomain)",
+            "  .withSchema({",
+            "    entities: {",
+            "      transportation_shipment: i.entity({",
+            "        carrier: i.string().indexed(),",
+            "        lane: i.string().indexed(),",
+            "        status: i.string().indexed(),",
+            "        etaHours: i.number().indexed(),",
+            "        createdAt: i.number().indexed(),",
             "      }),",
-            "    ]);",
-            "    return { taskId };",
-            "  },",
-            "});",
+            "    },",
+            "    links: {",
+            "      transportation_shipmentOrder: {",
+            "        forward: { on: \"transportation_shipment\", has: \"one\", label: \"order\" },",
+            "        reverse: { on: \"procurement_order\", has: \"many\", label: \"shipments\" },",
+            "      },",
+            "    },",
+            "    rooms: {},",
+            "  });",
+            "",
+            "export const qualityControlDomain = domain(\"qualityControl\")",
+            "  .includes(transportationDomain)",
+            "  .withSchema({",
+            "    entities: {",
+            "      qualityControl_inspection: i.entity({",
+            "        result: i.string().indexed(),",
+            "        severity: i.string().indexed(),",
+            "        note: i.string(),",
+            "        createdAt: i.number().indexed(),",
+            "      }),",
+            "    },",
+            "    links: {",
+            "      qualityControl_inspectionShipment: {",
+            "        forward: { on: \"qualityControl_inspection\", has: \"one\", label: \"shipment\" },",
+            "        reverse: { on: \"transportation_shipment\", has: \"many\", label: \"inspections\" },",
+            "      },",
+            "    },",
+            "    rooms: {},",
+            "  });",
             "",
-            "export const addTaskCommentAction = defineDomainAction<",
-            "  Record<string, unknown>,",
-            "  { taskId?: string; body?: string },",
-            "  { commentId: string; taskId: string },",
-            "  any",
-            ">({",
-            '  name: "app.task.comment.add",',
-            "  async execute({ runtime, input }): Promise<{ commentId: string; taskId: string }> {",
-            '    "use step";',
-            "    const scoped = await runtime.use(appDomain);",
-            "    const commentId = globalThis.crypto.randomUUID();",
-            '    const taskId = String((input as any)?.taskId ?? "").trim();',
-            "    if (!taskId) throw new Error(\"taskId is required\");",
-            "    await scoped.db.transact([",
-            "      scoped.db.tx.app_task_comments[commentId].update({",
-            '        body: String((input as any)?.body ?? "").trim() || "Empty comment",',
-            "        createdAt: Date.now(),",
+            "const baseDomain = domain(\"supplyChain\")",
+            "  .includes(inventoryDomain)",
+            "  .includes(qualityControlDomain)",
+            "  .withSchema({ entities: {}, links: {}, rooms: {} });",
+            "",
+            "export const launchOrderAction = defineAction({",
+            "  name: \"supplyChain.order.launch\",",
+            "  input: z.object({",
+            "    reference: z.string().optional(),",
+            "    supplierName: z.string().optional(),",
+            "    sku: z.string().optional(),",
+            "  }),",
+            "  output: z.object({",
+            "    supplierId: z.string(),",
+            "    orderId: z.string(),",
+            "    stockItemId: z.string(),",
+            "    shipmentId: z.string(),",
+            "    inspectionId: z.string(),",
+            "  }),",
+            "  async execute({ runtime, input }): Promise<{",
+            "    supplierId: string;",
+            "    orderId: string;",
+            "    stockItemId: string;",
+            "    shipmentId: string;",
+            "    inspectionId: string;",
+            "  }> {",
+            "    const now = Date.now();",
+            "    const supplierId = globalThis.crypto.randomUUID();",
+            "    const orderId = globalThis.crypto.randomUUID();",
+            "    const stockItemId = globalThis.crypto.randomUUID();",
+            "    const shipmentId = globalThis.crypto.randomUUID();",
+            "    const inspectionId = globalThis.crypto.randomUUID();",
+            "",
+            "    await runtime.db.transact([",
+            "      runtime.db.tx.supplierNetwork_supplier[supplierId].update({",
+            "        name: String(input?.supplierName ?? \"\").trim() || \"Marula Components\",",
+            "        region: \"Pacific North\",",
+            "        risk: \"watch\",",
+            "        score: 82,",
+            "        createdAt: now,",
             "      }),",
-            "      scoped.db.tx.app_task_comments[commentId].link({ task: taskId }),",
+            "      runtime.db.tx.procurement_order[orderId].update({",
+            "        reference: String(input?.reference ?? \"\").trim() || \"PO-7842\",",
+            "        status: \"released\",",
+            "        spend: 184700,",
+            "        createdAt: now + 1,",
+            "      }),",
+            "      runtime.db.tx.procurement_order[orderId].link({ supplier: supplierId }),",
+            "      runtime.db.tx.inventory_stockItem[stockItemId].update({",
+            "        sku: String(input?.sku ?? \"\").trim() || \"DRV-2048\",",
+            "        warehouse: \"Reno DC\",",
+            "        available: 320,",
+            "        safetyStock: 140,",
+            "        createdAt: now + 2,",
+            "      }),",
+            "      runtime.db.tx.inventory_stockItem[stockItemId].link({ order: orderId }),",
+            "      runtime.db.tx.transportation_shipment[shipmentId].update({",
+            "        carrier: \"Northstar Freight\",",
+            "        lane: \"Reno -> Austin\",",
+            "        status: \"in-transit\",",
+            "        etaHours: 38,",
+            "        createdAt: now + 3,",
+            "      }),",
+            "      runtime.db.tx.transportation_shipment[shipmentId].link({ order: orderId }),",
+            "      runtime.db.tx.qualityControl_inspection[inspectionId].update({",
+            "        result: \"pending\",",
+            "        severity: \"medium\",",
+            "        note: \"Inspect seal integrity on arrival.\",",
+            "        createdAt: now + 4,",
+            "      }),",
+            "      runtime.db.tx.qualityControl_inspection[inspectionId].link({ shipment: shipmentId }),",
             "    ]);",
-            "    return { commentId, taskId };",
+            "",
+            "    return { supplierId, orderId, stockItemId, shipmentId, inspectionId };",
             "  },",
             "});",
             "",
-            "export const seedDemoAction = defineDomainAction<",
-            "  Record<string, unknown>,",
-            "  Record<string, never>,",
-            "  { taskId: string },",
-            "  any",
-            ">({",
-            '  name: "app.demo.seed",',
-            "  async execute({ runtime }): Promise<{ taskId: string }> {",
-            '    "use step";',
-            "    const scoped = await runtime.use(appDomain);",
-            "    const taskId = globalThis.crypto.randomUUID();",
-            "    const commentId = globalThis.crypto.randomUUID();",
-            "    await scoped.db.transact([",
-            "      scoped.db.tx.app_tasks[taskId].update({",
-            '        title: "Ship the first Ekairos loop",',
-            '        status: "ready",',
-            "        createdAt: Date.now(),",
-            "      }),",
-            "      scoped.db.tx.app_task_comments[commentId].update({",
-            '        body: "Query me with app_tasks -> comments to validate the full CLI path.",',
-            "        createdAt: Date.now(),",
+            "export const expediteShipmentAction = defineAction({",
+            "  name: \"supplyChain.shipment.expedite\",",
+            "  input: z.object({ shipmentId: z.string().optional() }),",
+            "  output: z.object({ shipmentId: z.string() }),",
+            "  async execute({ runtime, input }): Promise<{ shipmentId: string }> {",
+            "    const shipmentId = String(input?.shipmentId ?? \"\").trim();",
+            "    if (!shipmentId) throw new Error(\"shipmentId is required\");",
+            "",
+            "    await runtime.db.transact([",
+            "      runtime.db.tx.transportation_shipment[shipmentId].update({",
+            "        status: \"expedited\",",
+            "        etaHours: 16,",
             "      }),",
-            "      scoped.db.tx.app_task_comments[commentId].link({ task: taskId }),",
             "    ]);",
-            "    return { taskId };",
+            "",
+            "    return { shipmentId };",
             "  },",
             "});",
             "",
-            "export const appDomain = baseDomain.actions({",
-            "  addTaskComment: addTaskCommentAction,",
-            "  createTask: createTaskAction,",
-            "  seedDemo: seedDemoAction,",
+            "export const appDomain = baseDomain.withActions({",
+            "  expediteShipment: expediteShipmentAction,",
+            "  launchOrder: launchOrderAction,",
             "});",
             "",
             "export default appDomain;",
@@ -1131,29 +2711,30 @@ function buildNextTemplateFiles(params) {
             "});",
         ].join("\n"),
         "src/workflows/demo.workflow.ts": [
-            'import { executeRuntimeAction } from "@ekairos/domain/runtime";',
-            'import { createRuntime } from "../runtime";',
+            "import type { ActiveDomain } from \"@ekairos/domain\";",
+            "import appDomain from \"../domain\";",
+            "import { createRuntime } from \"../runtime\";",
             "",
             "export type DemoWorkflowInput = {",
-            "  title: string;",
-            "  comment?: string;",
+            "  expedite?: boolean;",
+            "  reference?: string;",
+            "  sku?: string;",
+            "  supplierName?: string;",
             "};",
             "",
             "export async function runDemoWorkflow(input: DemoWorkflowInput) {",
-            '  "use workflow";',
+            "  \"use workflow\";",
             "  const runtime = createRuntime();",
-            "  const created = (await executeRuntimeAction({",
-            "    runtime,",
-            '    action: "app.task.create",',
-            "    input: { title: input.title, status: \"workflow\" },",
-            "  })) as { taskId: string };",
-            "",
-            '  const comment = String(input.comment ?? "").trim();',
-            "  if (comment) {",
-            "    await executeRuntimeAction({",
-            "      runtime,",
-            '      action: "app.task.comment.add",',
-            "      input: { taskId: created.taskId, body: comment },",
+            "  const scoped = (await runtime.use(appDomain)) as ActiveDomain<typeof appDomain>;",
+            "  const created = await scoped.actions.launchOrder({",
+            "    reference: input.reference,",
+            "    sku: input.sku,",
+            "    supplierName: input.supplierName,",
+            "  });",
+            "",
+            "  if (input.expedite) {",
+            "    await scoped.actions.expediteShipment({",
+            "      shipmentId: created.shipmentId,",
             "    });",
             "  }",
             "",
@@ -1166,6 +2747,13 @@ export async function createDomainApp(params) {
     if (params.framework !== "next") {
         throw new Error("Only --next is supported right now.");
     }
+    const template = resolveCreateAppTemplate(params);
+    if (params.smoke && !params.install) {
+        throw new Error("--smoke requires dependencies. Remove --no-install or run smoke after installing.");
+    }
+    if (params.demo && !params.smoke) {
+        throw new Error("--demo runs the full app cycle and requires smoke validation.");
+    }
     const targetDir = resolve(params.directory || ".");
     await emitProgress(params.onProgress, {
         stage: "prepare-target",
@@ -1220,6 +2808,7 @@ export async function createDomainApp(params) {
         });
         provisioned = await provisionInstantApp({
             directory: targetDir,
+            template,
             instantToken: trimOrEmpty(params.instantToken),
             orgId: params.orgId,
         });
@@ -1232,6 +2821,11 @@ export async function createDomainApp(params) {
     }
     const appId = explicitAppId || provisioned?.appId || null;
     const adminToken = explicitAdminToken || provisioned?.adminToken || null;
+    if (params.smoke && (!appId || !adminToken)) {
+        throw new Error(params.demo
+            ? "--demo requires Instant provisioning. Set INSTANT_PERSONAL_ACCESS_TOKEN or pass --instantToken."
+            : "--smoke requires a configured Instant app. Pass --instantToken or --appId with --adminToken.");
+    }
     await emitProgress(params.onProgress, {
         stage: "write-files",
         status: "running",
@@ -1240,6 +2834,7 @@ export async function createDomainApp(params) {
     });
     const files = buildNextTemplateFiles({
         targetDir,
+        template,
         domainVersion,
         packageManager,
         workspacePath: params.workspacePath,
@@ -1251,14 +2846,15 @@ export async function createDomainApp(params) {
         message: "Scaffold files written",
         progress: 72,
     });
-    if (appId && adminToken) {
+    const envFile = appId && adminToken ? join(targetDir, ".env.local") : null;
+    if (appId && adminToken && envFile) {
         await emitProgress(params.onProgress, {
             stage: "write-env",
             status: "running",
             message: "Writing .env.local",
             progress: 78,
         });
-        await writeFile(join(targetDir, ".env.local"), [
+        await writeFile(envFile, [
             `NEXT_PUBLIC_INSTANT_APP_ID=${appId}`,
             `INSTANT_ADMIN_TOKEN=${adminToken}`,
             "",
@@ -1285,25 +2881,60 @@ export async function createDomainApp(params) {
             progress: 96,
         });
     }
-    const nextSteps = [
-        `cd ${targetDir}`,
-        params.install
+    const smoke = params.smoke
+        ? await runSmoke({
+            demo: template === "supply-chain",
+            targetDir,
+            packageManager,
+            keepServer: Boolean(params.keepServer),
+            onKeepServer: params.onKeepServer,
+            onProgress: params.onProgress,
+        })
+        : null;
+    const cliCommand = packageBinCommandFor(packageManager, "domain");
+    const reviewUrl = smoke?.baseUrl ?? "http://localhost:3000";
+    const startStep = smoke?.keepServer
+        ? `Open ${reviewUrl} for review`
+        : params.install
             ? runScriptCommandFor(packageManager, "dev")
-            : `${installCommandFor(packageManager)} && ${runScriptCommandFor(packageManager, "dev")}`,
-        "Open http://localhost:3000 and click Seed Demo in the showcase UI",
-        "npx @ekairos/domain inspect --baseUrl=http://localhost:3000 --admin --pretty",
-        "npx @ekairos/domain seedDemo --baseUrl=http://localhost:3000 --admin --pretty",
-        "npx @ekairos/domain query \"{ app_tasks: { comments: {} } }\" --baseUrl=http://localhost:3000 --admin --pretty",
-    ];
+            : `${installCommandFor(packageManager)} && ${runScriptCommandFor(packageManager, "dev")}`;
+    const nextSteps = template === "supply-chain"
+        ? [
+            `cd ${targetDir}`,
+            startStep,
+            `Open ${reviewUrl} and launch a purchase order from the control tower UI`,
+            `${cliCommand} inspect --baseUrl=${reviewUrl} --admin --pretty`,
+            `${cliCommand} "supplyChain.order.launch" "{ reference: 'PO-7842', supplierName: 'Marula Components', sku: 'DRV-2048' }" --baseUrl=${reviewUrl} --admin --pretty`,
+            `${cliCommand} query "{ procurement_order: { supplier: {}, stockItems: {}, shipments: { inspections: {} } } }" --baseUrl=${reviewUrl} --admin --pretty`,
+        ]
+        : template === "agent"
+            ? [
+                `cd ${targetDir}`,
+                startStep,
+                `Open ${reviewUrl} and start a context through /api/agent/react`,
+                `Inspect the returned context id in Workbench v2 for app ${appId || "<instant-app-id>"}`,
+                `Iterate on src/agent.ts`,
+            ]
+            : [
+                `cd ${targetDir}`,
+                startStep,
+                `Open ${reviewUrl} and add your first domain in src/domain.ts`,
+                `${cliCommand} inspect --baseUrl=${reviewUrl} --admin --pretty`,
+            ];
     const result = {
         ok: true,
         directory: targetDir,
         framework: params.framework,
+        template,
         installed: params.install,
         packageManager,
         provisioned: Boolean(provisioned),
         appId,
         adminToken,
+        adminTokenWritten: Boolean(envFile),
+        envFile,
+        smoke,
+        demo: Boolean(params.demo),
         nextSteps,
     };
     await emitProgress(params.onProgress, {