@agentic-surfaces/core 0.1.0

package/dist/cache.d.ts

@@ -0,0 +1,11 @@
+import type { Cache } from "./types.js";
+export declare class SqliteCache implements Cache {
+    private db;
+    constructor(path?: string);
+    getCursor(k: string): string | undefined;
+    setCursor(k: string, v: string): void;
+    isSeen(k: string): boolean;
+    markSeen(k: string): void;
+    wipe(): void;
+    close(): void;
+}

package/dist/cache.js

@@ -0,0 +1,30 @@
+import Database from "better-sqlite3";
+export class SqliteCache {
+    db;
+    constructor(path = ":memory:") {
+        this.db = new Database(path);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS cursors (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS seen (key TEXT PRIMARY KEY);
+    `);
+    }
+    getCursor(k) {
+        const row = this.db.prepare("SELECT value FROM cursors WHERE key = ?").get(k);
+        return row?.value;
+    }
+    setCursor(k, v) {
+        this.db.prepare("INSERT INTO cursors(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value").run(k, v);
+    }
+    isSeen(k) {
+        return !!this.db.prepare("SELECT 1 FROM seen WHERE key = ?").get(k);
+    }
+    markSeen(k) {
+        this.db.prepare("INSERT OR IGNORE INTO seen(key) VALUES(?)").run(k);
+    }
+    wipe() {
+        this.db.exec("DELETE FROM cursors; DELETE FROM seen;");
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/executor.d.ts

@@ -0,0 +1,10 @@
+import type { HandlerRegistry } from "./registry.js";
+import type { Services, Workflow, RunObserver } from "./types.js";
+export declare function runWorkflow(opts: {
+    workflow: Workflow;
+    triggerNodeId: string;
+    registry: HandlerRegistry;
+    services: Services;
+    payload?: unknown;
+    observer?: RunObserver;
+}): Promise<Map<string, unknown>>;

package/dist/executor.js

@@ -0,0 +1,57 @@
+import { withRetry } from "./policy.js";
+export async function runWorkflow(opts) {
+    const { workflow, triggerNodeId, registry, services, payload, observer } = opts;
+    const byId = new Map(workflow.nodes.map(n => [n.id, n]));
+    const ctx = {
+        workflow,
+        outputs: new Map(),
+        triggerNodeId,
+        triggerPayload: payload,
+        services,
+    };
+    const queue = [triggerNodeId];
+    const visited = new Set();
+    observer?.onRunStart?.(workflow.name);
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (visited.has(id))
+            continue;
+        visited.add(id);
+        const node = byId.get(id);
+        if (!node)
+            throw new Error(`workflow references missing node: ${id}`);
+        const handler = registry.get(node.type);
+        observer?.onNodeStart?.(id);
+        let result;
+        let nodeErrored = false;
+        try {
+            result = await withRetry(node, () => handler.execute(node, ctx));
+        }
+        catch (err) {
+            nodeErrored = true;
+            const message = err instanceof Error ? err.message : String(err);
+            services.logger?.error?.(`node ${node.id} failed`, { workflow: workflow.name, error: message });
+            observer?.onNodeFinish?.(id, "failed", { error: message });
+            if (node.onError === "continue") {
+                result = { output: { error: message } };
+            }
+            else {
+                observer?.onRunFinish?.(workflow.name, "failed");
+                throw err;
+            }
+        }
+        ctx.outputs.set(id, result.output);
+        if (!nodeErrored)
+            observer?.onNodeFinish?.(id, "success");
+        const branches = result.branches;
+        for (const edge of workflow.edges) {
+            if (edge.from !== id)
+                continue;
+            if (edge.when === undefined || (branches && branches.includes(edge.when))) {
+                queue.push(edge.to);
+            }
+        }
+    }
+    observer?.onRunFinish?.(workflow.name, "success");
+    return ctx.outputs;
+}

package/dist/handlers/agent.d.ts

@@ -0,0 +1,2 @@
+import type { NodeHandler } from "../types.js";
+export declare const agentHandler: NodeHandler;

package/dist/handlers/agent.js

@@ -0,0 +1,16 @@
+export const agentHandler = {
+    type: "agent.run",
+    async execute(node, ctx) {
+        const cfg = node.config;
+        const defaults = ctx.services.agentDefaults ?? {};
+        const model = cfg.model ?? defaults.model;
+        const mcpServers = cfg.mcpServers ?? defaults.mcpServers;
+        const result = await ctx.services.agent.run({
+            prompt: cfg.prompt,
+            model,
+            mcpServers,
+            context: Object.fromEntries(ctx.outputs),
+        });
+        return { output: result };
+    },
+};

package/dist/handlers/branch.d.ts

@@ -0,0 +1,2 @@
+import type { NodeHandler } from "../types.js";
+export declare const branchHandler: NodeHandler;

package/dist/handlers/branch.js

@@ -0,0 +1,19 @@
+import jsonata from "jsonata";
+import { buildJsonataScope } from "./transform.js";
+function toBranches(value) {
+    if (typeof value === "boolean")
+        return [value ? "true" : "false"];
+    if (typeof value === "string")
+        return [value];
+    if (Array.isArray(value))
+        return value.map(String);
+    return [];
+}
+export const branchHandler = {
+    type: "task.branch",
+    async execute(node, ctx) {
+        const expr = String(node.config.expression ?? "");
+        const value = await jsonata(expr).evaluate(buildJsonataScope(ctx));
+        return { output: value, branches: toBranches(value) };
+    },
+};

package/dist/handlers/http.d.ts

@@ -0,0 +1,2 @@
+import type { NodeHandler } from "../types.js";
+export declare const httpHandler: NodeHandler;

package/dist/handlers/http.js

@@ -0,0 +1,47 @@
+import jsonata from "jsonata";
+import { buildJsonataScope } from "./transform.js";
+import { resolveSecrets } from "../secrets.js";
+function resolveObj(obj) {
+    const out = {};
+    for (const [k, v] of Object.entries(obj ?? {}))
+        out[k] = resolveSecrets(v);
+    return out;
+}
+// NOTE: engine dry-run gates deterministic task.http writes only.
+// Agent-initiated MCP writes are NOT gated here. Safe pattern: agents draft
+// content via read-only MCP, then a task.http node posts (gated by dryRun).
+export const httpHandler = {
+    type: "task.http",
+    async execute(node, ctx) {
+        const cfg = node.config;
+        const method = (cfg.method ?? "GET").toUpperCase();
+        const url = new URL(resolveSecrets(cfg.url));
+        for (const [k, v] of Object.entries(resolveObj(cfg.query)))
+            url.searchParams.set(k, v);
+        if (ctx.services.dryRun && method !== "GET" && method !== "HEAD") {
+            ctx.services.logger?.info?.(`DRY-RUN: would ${method} ${url}`);
+            return { output: { dryRun: true, method, url: url.toString() } };
+        }
+        const headers = resolveObj(cfg.headers);
+        let body;
+        if (cfg.bodyExpression) {
+            const data = await jsonata(cfg.bodyExpression).evaluate(buildJsonataScope(ctx));
+            body = JSON.stringify(data);
+            headers["content-type"] ??= "application/json";
+        }
+        const res = await ctx.services.fetch(url, {
+            method,
+            headers,
+            body,
+        });
+        if (!res.ok)
+            throw new Error(`http ${res.status} from ${url.pathname}`);
+        const text = await res.text();
+        try {
+            return { output: JSON.parse(text) };
+        }
+        catch {
+            return { output: text };
+        }
+    },
+};

package/dist/handlers/transform.d.ts

@@ -0,0 +1,3 @@
+import type { NodeHandler, RunContext } from "../types.js";
+export declare function buildJsonataScope(ctx: RunContext): Record<string, unknown>;
+export declare const transformHandler: NodeHandler;

package/dist/handlers/transform.js

@@ -0,0 +1,21 @@
+import jsonata from "jsonata";
+export function buildJsonataScope(ctx) {
+    const scope = {};
+    for (const [id, out] of ctx.outputs)
+        scope[id] = out;
+    scope.trigger = ctx.triggerPayload;
+    return scope;
+}
+export const transformHandler = {
+    type: "task.transform",
+    async execute(node, ctx) {
+        const expr = String(node.config.expression ?? "");
+        const compiled = jsonata(expr);
+        let output = await compiled.evaluate(buildJsonataScope(ctx));
+        // jsonata may return a sequence object with array-like properties; convert to plain array/value
+        if (output && typeof output === 'object' && 'sequence' in output && Array.isArray(output)) {
+            output = Array.from(output);
+        }
+        return { output };
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export declare const version = "0.0.0";
+export * from "./types.js";
+export * from "./schema.js";
+export * from "./executor.js";
+export * from "./scheduler.js";
+export * from "./cache.js";
+export * from "./observer.js";
+export * from "./secrets.js";
+export * from "./project-config.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export const version = "0.0.0";
+export * from "./types.js";
+export * from "./schema.js";
+export * from "./executor.js";
+export * from "./scheduler.js";
+export * from "./cache.js";
+export * from "./observer.js";
+export * from "./secrets.js";
+export * from "./project-config.js";

package/dist/observer.d.ts

@@ -0,0 +1,7 @@
+import type { RunObserver } from "./types.js";
+export declare class ConsoleObserver implements RunObserver {
+    onRunStart(workflow: string): void;
+    onNodeStart(nodeId: string): void;
+    onNodeFinish(nodeId: string, status: "success" | "failed"): void;
+    onRunFinish(workflow: string, status: "success" | "failed"): void;
+}

package/dist/observer.js

@@ -0,0 +1,6 @@
+export class ConsoleObserver {
+    onRunStart(workflow) { console.log(`▶ run ${workflow}`); }
+    onNodeStart(nodeId) { console.log(`  · ${nodeId}…`); }
+    onNodeFinish(nodeId, status) { console.log(`  ${status === "success" ? "✓" : "✗"} ${nodeId}`); }
+    onRunFinish(workflow, status) { console.log(`■ ${workflow}: ${status}`); }
+}

package/dist/policy.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowNode } from "./types.js";
+export declare function withRetry<T>(node: WorkflowNode, fn: () => Promise<T>, sleep?: (ms: number) => Promise<void>): Promise<T>;

package/dist/policy.js

@@ -0,0 +1,17 @@
+const defaultSleep = (ms) => new Promise(r => setTimeout(r, ms));
+export async function withRetry(node, fn, sleep = defaultSleep) {
+    const maxAttempts = node.retry?.maxAttempts ?? 1;
+    const backoffMs = node.retry?.backoffMs ?? 0;
+    let lastErr;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt < maxAttempts && backoffMs > 0)
+                await sleep(backoffMs * attempt);
+        }
+    }
+    throw lastErr;
+}

package/dist/project-config.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+declare const ProjectConfigSchema: z.ZodObject<{
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+    agent: z.ZodDefault<z.ZodObject<{
+        runner: z.ZodDefault<z.ZodString>;
+        model: z.ZodDefault<z.ZodString>;
+        mcpServers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            name: z.ZodString;
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>]>>>;
+    }, z.core.$strip>>;
+    workflows: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
+/**
+ * Load and validate `agentic-surfaces.config.yaml` from the given directory.
+ *
+ * Returns `undefined` if the file does not exist.
+ * Throws a descriptive error if the file exists but is invalid YAML or fails schema validation.
+ */
+export declare function loadProjectConfig(dir: string): ProjectConfig | undefined;
+export {};

package/dist/project-config.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+// Mirror the McpServerRef interface from @agentic-surfaces/agent as a Zod schema.
+// We do NOT import a zod schema from agent (that package has no zod dep).
+const McpServerRefSchema = z.union([
+    z.object({ name: z.string(), url: z.string() }),
+    z.object({ name: z.string(), command: z.string(), args: z.array(z.string()).optional() }),
+]);
+const ProjectConfigSchema = z.object({
+    dryRun: z.boolean().default(false),
+    agent: z
+        .object({
+        runner: z.string().default("claude"),
+        model: z.string().default("claude-opus-4-8"),
+        mcpServers: z.array(McpServerRefSchema).optional(),
+    })
+        .default({ runner: "claude", model: "claude-opus-4-8" }),
+    workflows: z.string().optional(), // relative subdir; omitted = use dir itself
+});
+const CONFIG_FILENAME = "agentic-surfaces.config.yaml";
+/**
+ * Load and validate `agentic-surfaces.config.yaml` from the given directory.
+ *
+ * Returns `undefined` if the file does not exist.
+ * Throws a descriptive error if the file exists but is invalid YAML or fails schema validation.
+ */
+export function loadProjectConfig(dir) {
+    const filePath = join(dir, CONFIG_FILENAME);
+    let raw;
+    try {
+        raw = readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw new Error(`Failed to read ${CONFIG_FILENAME}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let parsed;
+    try {
+        parsed = parseYaml(raw);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse ${CONFIG_FILENAME} as YAML: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const result = ProjectConfigSchema.safeParse(parsed);
+    if (!result.success) {
+        const issues = result.error.issues.map(i => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+        throw new Error(`Invalid ${CONFIG_FILENAME}:\n${issues}`);
+    }
+    return result.data;
+}

package/dist/registry.d.ts

@@ -0,0 +1,6 @@
+import type { NodeHandler, NodeType } from "./types.js";
+export declare class HandlerRegistry {
+    private handlers;
+    register(h: NodeHandler): void;
+    get(type: NodeType): NodeHandler;
+}

package/dist/registry.js

@@ -0,0 +1,10 @@
+export class HandlerRegistry {
+    handlers = new Map();
+    register(h) { this.handlers.set(h.type, h); }
+    get(type) {
+        const h = this.handlers.get(type);
+        if (!h)
+            throw new Error(`no handler registered for node type: ${type}`);
+        return h;
+    }
+}

package/dist/scheduler.d.ts

@@ -0,0 +1,25 @@
+import { HandlerRegistry } from "./registry.js";
+import type { RunObserver, Services, Workflow } from "./types.js";
+export declare function defaultRegistry(): HandlerRegistry;
+export declare function runWorkflowOnce(workflow: Workflow, opts: {
+    registry?: HandlerRegistry;
+    services: Services;
+    triggerNodeId?: string;
+    payload?: unknown;
+    observer?: RunObserver;
+}): Promise<Map<string, unknown>>;
+export declare class Scheduler {
+    private services;
+    private registry;
+    private observer;
+    private crons;
+    private active;
+    private pending;
+    private workflows;
+    constructor(services: Services, registry?: HandlerRegistry, observer?: RunObserver);
+    add(workflow: Workflow): void;
+    start(): void;
+    private enqueue;
+    private drain;
+    stop(): void;
+}

package/dist/scheduler.js

@@ -0,0 +1,72 @@
+import { Cron } from "croner";
+import { HandlerRegistry } from "./registry.js";
+import { runWorkflow } from "./executor.js";
+import { transformHandler } from "./handlers/transform.js";
+import { branchHandler } from "./handlers/branch.js";
+import { httpHandler } from "./handlers/http.js";
+import { agentHandler } from "./handlers/agent.js";
+import { ConsoleObserver } from "./observer.js";
+const passthrough = (type) => ({
+    type,
+    async execute(_n, ctx) {
+        return { output: ctx.triggerPayload ?? null };
+    },
+});
+export function defaultRegistry() {
+    const r = new HandlerRegistry();
+    r.register(transformHandler);
+    r.register(branchHandler);
+    r.register(httpHandler);
+    r.register(agentHandler);
+    r.register(passthrough("trigger.cron"));
+    r.register(passthrough("trigger.webhook"));
+    return r;
+}
+export async function runWorkflowOnce(workflow, opts) {
+    const registry = opts.registry ?? defaultRegistry();
+    const triggerNodeId = opts.triggerNodeId
+        ?? workflow.nodes.find(n => n.type.startsWith("trigger."))?.id;
+    if (!triggerNodeId)
+        throw new Error(`workflow ${workflow.name} has no trigger node`);
+    return runWorkflow({ workflow, triggerNodeId, registry, services: opts.services, payload: opts.payload, observer: opts.observer });
+}
+export class Scheduler {
+    services;
+    registry;
+    observer;
+    crons = [];
+    active = 0;
+    pending = [];
+    workflows = [];
+    constructor(services, registry = defaultRegistry(), observer = new ConsoleObserver()) {
+        this.services = services;
+        this.registry = registry;
+        this.observer = observer;
+    }
+    add(workflow) { this.workflows.push(workflow); }
+    start() {
+        for (const wf of this.workflows) {
+            for (const node of wf.nodes) {
+                if (node.type !== "trigger.cron")
+                    continue;
+                const pattern = String(node.config.cron);
+                this.crons.push(new Cron(pattern, () => this.enqueue(() => runWorkflowOnce(wf, { registry: this.registry, services: this.services, triggerNodeId: node.id, observer: this.observer })
+                    .then(() => { }))));
+            }
+        }
+    }
+    enqueue(run) {
+        this.pending.push(run);
+        this.drain();
+    }
+    drain() {
+        while (this.active < 4 && this.pending.length > 0) {
+            const run = this.pending.shift();
+            this.active++;
+            run().catch(e => this.services.logger.error("scheduled run failed", { error: String(e) }))
+                .finally(() => { this.active--; this.drain(); });
+        }
+    }
+    stop() { for (const c of this.crons)
+        c.stop(); this.crons = []; }
+}

package/dist/schema.d.ts

@@ -0,0 +1,2 @@
+import type { Workflow } from "./types.js";
+export declare function loadWorkflow(yamlText: string): Workflow;

package/dist/schema.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { parse as parseYaml } from "yaml";
+const nodeType = z.enum([
+    "trigger.cron", "trigger.webhook",
+    "task.http", "task.transform", "task.branch",
+    "agent.run",
+]);
+const retry = z.object({ maxAttempts: z.number().int().min(1), backoffMs: z.number().int().min(0) });
+const NODE_ID_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const node = z.object({
+    id: z.string().min(1).superRefine((v, ctx) => {
+        if (!NODE_ID_RE.test(v)) {
+            ctx.addIssue({ code: "custom", message: `node id "${v}" is not a valid identifier (must match /^[A-Za-z_][A-Za-z0-9_]*$/)` });
+        }
+    }),
+    type: nodeType,
+    config: z.record(z.string(), z.unknown()).default({}),
+    retry: retry.optional(),
+    onError: z.enum(["fail", "continue"]).optional(),
+});
+const edge = z.object({ from: z.string().min(1), to: z.string().min(1), when: z.string().optional() });
+const workflow = z.object({
+    name: z.string().min(1),
+    nodes: z.array(node).min(1),
+    edges: z.array(edge).default([]),
+}).superRefine((wf, ctx) => {
+    const ids = new Set(wf.nodes.map(n => n.id));
+    for (const e of wf.edges) {
+        if (!ids.has(e.from))
+            ctx.addIssue({ code: "custom", message: `edge.from references missing node: ${e.from}` });
+        if (!ids.has(e.to))
+            ctx.addIssue({ code: "custom", message: `edge.to references missing node: ${e.to}` });
+    }
+    for (const n of wf.nodes) {
+        if (n.type === "trigger.cron") {
+            const cron = n.config.cron;
+            if (typeof cron !== "string" || cron.trim() === "") {
+                ctx.addIssue({ code: "custom", message: `node "${n.id}" (trigger.cron) requires a non-empty config.cron string` });
+            }
+        }
+    }
+});
+export function loadWorkflow(yamlText) {
+    const raw = parseYaml(yamlText);
+    return workflow.parse(raw);
+}

package/dist/secrets.d.ts

@@ -0,0 +1,9 @@
+export interface SecretProvider {
+    get(name: string): string | undefined;
+}
+export declare class EnvSecretProvider implements SecretProvider {
+    private env;
+    constructor(env?: NodeJS.ProcessEnv);
+    get(name: string): string | undefined;
+}
+export declare function resolveSecrets(input: string, provider?: SecretProvider): string;

package/dist/secrets.js

@@ -0,0 +1,18 @@
+export class EnvSecretProvider {
+    env;
+    constructor(env = process.env) {
+        this.env = env;
+    }
+    get(name) {
+        return this.env[name];
+    }
+}
+const defaultProvider = new EnvSecretProvider();
+export function resolveSecrets(input, provider = defaultProvider) {
+    return input.replace(/\$\{([A-Z0-9_]+)\}/g, (_, name) => {
+        const v = provider.get(name);
+        if (v === undefined)
+            throw new Error(`missing required secret: ${name}`);
+        return v;
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,68 @@
+import type { AgentRunner, McpServerRef } from "@agentic-surfaces/agent";
+export type { AgentRunner, McpServerRef };
+export type NodeType = "trigger.cron" | "trigger.webhook" | "task.http" | "task.transform" | "task.branch" | "agent.run";
+export interface RetryPolicy {
+    maxAttempts: number;
+    backoffMs: number;
+}
+export interface WorkflowNode {
+    id: string;
+    type: NodeType;
+    config: Record<string, unknown>;
+    retry?: RetryPolicy;
+    onError?: "fail" | "continue";
+}
+export interface WorkflowEdge {
+    from: string;
+    to: string;
+    when?: string;
+}
+export interface Workflow {
+    name: string;
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+}
+export interface Logger {
+    info(msg: string, meta?: unknown): void;
+    error(msg: string, meta?: unknown): void;
+}
+export interface Cache {
+    getCursor(k: string): string | undefined;
+    setCursor(k: string, v: string): void;
+    isSeen(k: string): boolean;
+    markSeen(k: string): void;
+    wipe(): void;
+}
+export interface Services {
+    agent: AgentRunner;
+    cache: Cache;
+    logger: Logger;
+    fetch: typeof fetch;
+    dryRun?: boolean;
+    agentDefaults?: {
+        model?: string;
+        runner?: string;
+        mcpServers?: McpServerRef[];
+    };
+}
+export interface RunContext {
+    workflow: Workflow;
+    outputs: Map<string, unknown>;
+    triggerNodeId: string;
+    triggerPayload?: unknown;
+    services: Services;
+}
+export interface NodeResult {
+    output: unknown;
+    branches?: string[];
+}
+export interface NodeHandler {
+    type: NodeType;
+    execute(node: WorkflowNode, ctx: RunContext): Promise<NodeResult>;
+}
+export interface RunObserver {
+    onRunStart?(workflow: string): void;
+    onNodeStart?(nodeId: string): void;
+    onNodeFinish?(nodeId: string, status: "success" | "failed", meta?: unknown): void;
+    onRunFinish?(workflow: string, status: "success" | "failed"): void;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@agentic-surfaces/core",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "better-sqlite3": "^12.11.1",
+    "croner": "^10.0.1",
+    "jsonata": "^2.2.1",
+    "yaml": "^2.9.0",
+    "zod": "^4.4.3",
+    "@agentic-surfaces/agent": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "msw": "^2.14.6"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "test": "vitest run --root ../.."
+  }
+}