hypervibes 0.0.0-stage → 0.4.0

package/dist/config.js

@@ -0,0 +1,85 @@
+import { isAbsolute, join, resolve, win32 } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+/** OS-appropriate per-user data directory, so packaged hosts reuse one profile. */
+export function defaultDatabasePath(env, platform = process.platform, home = homedir()) {
+    if (platform === "win32") {
+        const appData = env.APPDATA?.trim();
+        return win32.join(appData && win32.isAbsolute(appData) ? appData : win32.join(home, "AppData", "Roaming"), "HyperVibes", "hypervibes.sqlite");
+    }
+    if (platform === "darwin")
+        return join(home, "Library", "Application Support", "HyperVibes", "hypervibes.sqlite");
+    const dataHome = env.XDG_DATA_HOME?.trim();
+    return join(dataHome && isAbsolute(dataHome) ? dataHome : join(home, ".local", "share"), "hypervibes", "hypervibes.sqlite");
+}
+/** OS-appropriate per-user storage for disposable cached assets. */
+export function defaultCacheDirectory(env, platform = process.platform, home = homedir()) {
+    if (platform === "win32") {
+        const localAppData = env.LOCALAPPDATA?.trim();
+        return win32.join(localAppData && win32.isAbsolute(localAppData) ? localAppData : win32.join(home, "AppData", "Local"), "HyperVibes", "Cache");
+    }
+    if (platform === "darwin")
+        return join(home, "Library", "Caches", "HyperVibes");
+    const cacheHome = env.XDG_CACHE_HOME?.trim();
+    return join(cacheHome && isAbsolute(cacheHome) ? cacheHome : join(home, ".cache"), "hypervibes");
+}
+function setting(env, name, fallback) {
+    const value = (env[name] ?? fallback).trim();
+    if (!value)
+        throw new Error(`${name} must not be empty`);
+    return value;
+}
+export function loadConfig(env = process.env) {
+    const port = setting(env, "APP_PORT", "3003");
+    if (!/^\d+$/.test(port) || Number(port) < 1 || Number(port) > 65535) {
+        throw new Error("APP_PORT must be an integer between 1 and 65535");
+    }
+    let origin;
+    try {
+        origin = new URL(setting(env, "APP_ORIGIN", `http://localhost:${port}`));
+    }
+    catch {
+        throw new Error("APP_ORIGIN must be a valid HTTP(S) origin");
+    }
+    if (origin.username || origin.password || origin.pathname !== "/" || origin.search || origin.hash
+        || !["http:", "https:"].includes(origin.protocol)) {
+        throw new Error("APP_ORIGIN must be an HTTP(S) origin without credentials, path, query or fragment");
+    }
+    const allowInsecureHttp = env.APP_ALLOW_INSECURE_HTTP?.trim() ?? "false";
+    if (!["true", "false"].includes(allowInsecureHttp)) {
+        throw new Error("APP_ALLOW_INSECURE_HTTP must be true or false");
+    }
+    if (origin.protocol !== "https:" && !["localhost", "127.0.0.1", "[::1]"].includes(origin.hostname)
+        && allowInsecureHttp !== "true") {
+        throw new Error("APP_ORIGIN requires HTTPS except on loopback; private LAN HTTP requires APP_ALLOW_INSECURE_HTTP=true");
+    }
+    const authSecret = setting(env, "BETTER_AUTH_SECRET", "");
+    if (authSecret.length < 32)
+        throw new Error("BETTER_AUTH_SECRET must contain at least 32 random characters");
+    const encryptionKey = encryptionKeySetting(env);
+    return {
+        authOrigin: origin.origin,
+        authSecret,
+        host: setting(env, "APP_HOST", "127.0.0.1"),
+        port: Number(port),
+        databasePath: resolve(setting(env, "APP_SQLITE_PATH", defaultDatabasePath(env))),
+        buildDir: resolve(setting(env, "APP_BUILD_DIR", fileURLToPath(new URL("../.build/", import.meta.url)))),
+        staticDir: resolve(setting(env, "APP_STATIC_DIR", fileURLToPath(new URL("../static/", import.meta.url)))),
+        cacheDir: resolve(setting(env, "APP_CACHE_DIR", defaultCacheDirectory(env))),
+        encryptionKey,
+    };
+}
+/** Parses the optional AGENTS_ENCRYPTION_KEY secret for stored credentials. */
+function encryptionKeySetting(env) {
+    const keyHex = (env.AGENTS_ENCRYPTION_KEY ?? "").trim();
+    if (!keyHex)
+        return undefined;
+    if (!/^(?:[0-9a-fA-F]{2})+$/.test(keyHex))
+        throw new Error("AGENTS_ENCRYPTION_KEY must be a valid hexadecimal string");
+    const bytes = Buffer.from(keyHex, "hex");
+    if (bytes.length !== 32)
+        throw new Error(`AGENTS_ENCRYPTION_KEY must decode to exactly 32 bytes, got ${bytes.length}`);
+    // Rows record the ID that encrypted them, so a future key-rotation scheme can
+    // distinguish versions. Today there is exactly one version.
+    return { id: "primary", bytes: new Uint8Array(bytes) };
+}

package/dist/db/agent-schema.js

@@ -0,0 +1,26 @@
+import { sql } from "drizzle-orm";
+import { check, index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { hvUsers } from "./auth-schema.js";
+export const hvAgents = sqliteTable("hv_agents", {
+    id: text("id").primaryKey(),
+    userId: text("user_id").notNull().references(() => hvUsers.id, { onDelete: "restrict" }),
+    name: text("name").notNull(),
+    creationRequestId: text("creation_request_id").notNull(),
+    state: text("state", { enum: ["provisioning", "ready", "failed", "stopping", "stopped"] }).notNull().default("provisioning"),
+    enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+    conversationId: integer("conversation_id"),
+    /** Creation intent only; current selection is owned by Durable's pi.agent. */
+    initialProvider: text("initial_provider"),
+    initialModelId: text("initial_model_id"),
+    error: text("error"),
+    /** Required for new agents by AgentService; nullable only for legacy development rows. */
+    tradingAccountAddress: text("trading_account_address"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+}, (table) => [
+    index("hv_agents_owner_idx").on(table.userId),
+    uniqueIndex("hv_agents_creation_request_idx").on(table.userId, table.creationRequestId),
+    uniqueIndex("hv_agents_trading_account_idx").on(table.tradingAccountAddress),
+    check("hv_agents_name_check", sql `length(trim(${table.name})) BETWEEN 1 AND 80`),
+    check("hv_agents_state_check", sql `${table.state} IN ('provisioning', 'ready', 'failed', 'stopping', 'stopped')`),
+]);

package/dist/db/auth-schema.js

@@ -0,0 +1,122 @@
+import { defineRelationsPart, sql } from "drizzle-orm";
+import { sqliteTable, text, integer, index } from "drizzle-orm/sqlite-core";
+export const hvUsers = sqliteTable("hv_users", {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    email: text("email").notNull().unique(),
+    emailVerified: integer("email_verified", { mode: "boolean" })
+        .default(false)
+        .notNull(),
+    image: text("image"),
+    createdAt: integer("created_at", { mode: "timestamp_ms" })
+        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
+        .notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
+        .$onUpdate(() => /* @__PURE__ */ new Date())
+        .notNull(),
+});
+export const hvSessions = sqliteTable("hv_sessions", {
+    id: text("id").primaryKey(),
+    expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+    token: text("token").notNull().unique(),
+    createdAt: integer("created_at", { mode: "timestamp_ms" })
+        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
+        .notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+        .$onUpdate(() => /* @__PURE__ */ new Date())
+        .notNull(),
+    ipAddress: text("ip_address"),
+    userAgent: text("user_agent"),
+    userId: text("user_id")
+        .notNull()
+        .references(() => hvUsers.id, { onDelete: "cascade" }),
+}, (table) => [index("hvSessions_userId_idx").on(table.userId)]);
+export const hvAuthAccounts = sqliteTable("hv_auth_accounts", {
+    id: text("id").primaryKey(),
+    accountId: text("account_id").notNull(),
+    providerId: text("provider_id").notNull(),
+    userId: text("user_id")
+        .notNull()
+        .references(() => hvUsers.id, { onDelete: "cascade" }),
+    accessToken: text("access_token"),
+    refreshToken: text("refresh_token"),
+    idToken: text("id_token"),
+    accessTokenExpiresAt: integer("access_token_expires_at", {
+        mode: "timestamp_ms",
+    }),
+    refreshTokenExpiresAt: integer("refresh_token_expires_at", {
+        mode: "timestamp_ms",
+    }),
+    scope: text("scope"),
+    password: text("password"),
+    createdAt: integer("created_at", { mode: "timestamp_ms" })
+        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
+        .notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+        .$onUpdate(() => /* @__PURE__ */ new Date())
+        .notNull(),
+}, (table) => [index("hvAuthAccounts_userId_idx").on(table.userId)]);
+export const hvAuthVerifications = sqliteTable("hv_auth_verifications", {
+    id: text("id").primaryKey(),
+    identifier: text("identifier").notNull(),
+    value: text("value").notNull(),
+    expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+    createdAt: integer("created_at", { mode: "timestamp_ms" })
+        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
+        .notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
+        .$onUpdate(() => /* @__PURE__ */ new Date())
+        .notNull(),
+}, (table) => [index("hvAuthVerifications_identifier_idx").on(table.identifier)]);
+export const hvWalletAddresses = sqliteTable("hv_wallet_addresses", {
+    id: text("id").primaryKey(),
+    userId: text("user_id")
+        .notNull()
+        .references(() => hvUsers.id, { onDelete: "cascade" }),
+    address: text("address").notNull(),
+    chainId: integer("chain_id").notNull(),
+    isPrimary: integer("is_primary", { mode: "boolean" }).default(false),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+}, (table) => [index("hvWalletAddresses_userId_idx").on(table.userId)]);
+export const authRelations = defineRelationsPart({
+    hvUsers,
+    hvSessions,
+    hvAuthAccounts,
+    hvAuthVerifications,
+    hvWalletAddresses,
+}, (r) => ({
+    hvUsers: {
+        hvSessions: r.many.hvSessions({
+            from: r.hvUsers.id,
+            to: r.hvSessions.userId,
+        }),
+        hvAuthAccounts: r.many.hvAuthAccounts({
+            from: r.hvUsers.id,
+            to: r.hvAuthAccounts.userId,
+        }),
+        hvWalletAddresses: r.many.hvWalletAddresses({
+            from: r.hvUsers.id,
+            to: r.hvWalletAddresses.userId,
+        }),
+    },
+    hvSessions: {
+        hvUsers: r.one.hvUsers({
+            from: r.hvSessions.userId,
+            to: r.hvUsers.id,
+        }),
+    },
+    hvAuthAccounts: {
+        hvUsers: r.one.hvUsers({
+            from: r.hvAuthAccounts.userId,
+            to: r.hvUsers.id,
+        }),
+    },
+    hvWalletAddresses: {
+        hvUsers: r.one.hvUsers({
+            from: r.hvWalletAddresses.userId,
+            to: r.hvUsers.id,
+        }),
+    },
+}));

package/dist/db/database.js

@@ -0,0 +1,31 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+/** Owns a fresh-app SQLite connection; does not create domain or Durable tables. */
+export function openDatabase(path) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const database = new DatabaseSync(path);
+    try {
+        // Set pointer-map support only for fresh profiles. Existing NONE profiles
+        // require an explicitly planned VACUUM conversion, never a startup rebuild.
+        const schema = database.prepare("SELECT count(*) AS total FROM sqlite_schema WHERE type='table'").get();
+        if (schema?.total === 0)
+            database.exec("PRAGMA auto_vacuum = INCREMENTAL");
+        // Connection-local settings must also be applied to any future connections.
+        database.exec("PRAGMA busy_timeout = 5000");
+        const mode = database.prepare("PRAGMA journal_mode = WAL").get();
+        if (mode?.journal_mode !== "wal") {
+            throw new Error("The application database requires file-backed SQLite WAL mode");
+        }
+        database.exec(`
+      PRAGMA synchronous = FULL;
+      PRAGMA foreign_keys = ON;
+      PRAGMA wal_autocheckpoint = 1000;
+    `);
+        return database;
+    }
+    catch (error) {
+        database.close();
+        throw error;
+    }
+}

package/dist/db/exchange-schema.js

@@ -0,0 +1,23 @@
+import { check, integer, sqliteTable, text, blob } from "drizzle-orm/sqlite-core";
+import { sql } from "drizzle-orm";
+import { hvUsers } from "./auth-schema.js";
+/**
+ * Per-user Hyperliquid settings: the single trading signer (API wallet) and
+ * builder-fee approval state. The private key is encrypted at rest and is
+ * loaded only by exchange-signing code.
+ */
+export const hvHyperliquidSettings = sqliteTable("hv_hyperliquid_settings", {
+    userId: text("user_id").primaryKey().references(() => hvUsers.id, { onDelete: "restrict" }),
+    apiWalletAddress: text("api_wallet_address"),
+    privateKeyCiphertext: blob("private_key_ciphertext", { mode: "buffer" }),
+    privateKeyKeyId: text("private_key_key_id"),
+    apiWalletApprovedAt: integer("api_wallet_approved_at"),
+    apiWalletExpiresAt: integer("api_wallet_expires_at"),
+    apiWalletExpiryCheckedAt: integer("api_wallet_expiry_checked_at"),
+    builderFeeTenthsOfBp: integer("builder_fee_tenths_of_bp").notNull().default(0),
+    builderFeeApprovedAt: integer("builder_fee_approved_at"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+}, (table) => [
+    check("hv_hyperliquid_settings_builder_fee_check", sql `${table.builderFeeTenthsOfBp} BETWEEN 0 AND 100`),
+]);

package/dist/db/gateway-schema.js

@@ -0,0 +1,24 @@
+import { blob, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { hvAgents } from "./agent-schema.js";
+/** The gateway kinds the application understands; each is owned by its connector module. */
+export const GATEWAY_TYPES = ["telegram"];
+/** One external gateway per Agent and type: bridges a bound chat with the Agent's persistent main conversation. */
+export const hvGateways = sqliteTable("hv_gateways", {
+    agentId: text("agent_id").notNull().references(() => hvAgents.id, { onDelete: "cascade" }),
+    type: text("type", { enum: GATEWAY_TYPES }).notNull(),
+    /** AES-256-GCM sealed bot token; never rendered, logged, or returned to clients. */
+    botTokenCiphertext: blob("bot_token_ciphertext", { mode: "buffer" }).notNull(),
+    /** SHA-256 of the plaintext token; a unique index stops two Agents sharing one bot. */
+    botTokenHash: text("bot_token_hash").notNull(),
+    /** Encryption key id that sealed the token, for future key rotation. */
+    keyId: text("key_id").notNull(),
+    /** The bot's own username on the gateway platform. */
+    botUsername: text("bot_username").notNull(),
+    /** The external chat that completed the link flow; null until linked. */
+    chatId: integer("chat_id"),
+    chatUsername: text("chat_username"),
+    updatedAt: integer("updated_at").notNull(),
+}, (table) => [
+    primaryKey({ columns: [table.agentId, table.type] }),
+    uniqueIndex("hv_gateways_token_hash_idx").on(table.botTokenHash),
+]);

package/dist/db/indicator-schema.js

@@ -0,0 +1,19 @@
+import { sql } from "drizzle-orm";
+import { check, index, integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { hvAgents } from "./agent-schema.js";
+export const hvIndicators = sqliteTable("hv_indicators", {
+    id: text("id").primaryKey(), agentId: text("agent_id").notNull().references(() => hvAgents.id, { onDelete: "cascade" }),
+    name: text("name").notNull(), description: text("description").notNull(), interpretation: text("interpretation").notNull(),
+    currentVersion: integer("current_version").notNull(), createdAt: integer("created_at").notNull(), updatedAt: integer("updated_at").notNull(),
+}, (t) => [index("hv_indicators_agent_idx").on(t.agentId, t.updatedAt), check("hv_indicators_version_positive", sql `${t.currentVersion} > 0`)]);
+export const hvIndicatorVersions = sqliteTable("hv_indicator_versions", {
+    indicatorId: text("indicator_id").notNull().references(() => hvIndicators.id, { onDelete: "cascade" }), version: integer("version").notNull(),
+    source: text("source").notNull(), sourceHash: text("source_hash").notNull(), metadata: text("metadata").notNull(),
+    engineVersion: text("engine_version").notNull(), wrapperVersion: integer("wrapper_version").notNull(),
+    createdAt: integer("created_at").notNull(), actorKind: text("actor_kind", { enum: ["user", "agent"] }).notNull(),
+    userId: text("user_id"), subagentId: text("subagent_id"), runId: text("run_id"), conversationId: text("conversation_id"), taskId: text("task_id"),
+}, (t) => [primaryKey({ columns: [t.indicatorId, t.version] }), check("hv_indicator_versions_positive", sql `${t.version} > 0`)]);
+export const hvIndicatorOperations = sqliteTable("hv_indicator_operations", {
+    agentId: text("agent_id").notNull().references(() => hvAgents.id, { onDelete: "cascade" }),
+    key: text("key").notNull(), hash: text("hash").notNull(), result: text("result").notNull(),
+}, (t) => [primaryKey({ columns: [t.agentId, t.key] })]);

package/dist/db/migrations/20261015221717_auth/migration.sql

@@ -0,0 +1,62 @@
+CREATE TABLE `hv_auth_accounts` (
+	`id` text PRIMARY KEY,
+	`account_id` text NOT NULL,
+	`provider_id` text NOT NULL,
+	`user_id` text NOT NULL,
+	`access_token` text,
+	`refresh_token` text,
+	`id_token` text,
+	`access_token_expires_at` integer,
+	`refresh_token_expires_at` integer,
+	`scope` text,
+	`password` text,
+	`created_at` integer DEFAULT (cast(unixepoch('subsecond') * 1000 as integer)) NOT NULL,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_auth_accounts_user_id_hv_users_id_fk` FOREIGN KEY (`user_id`) REFERENCES `hv_users`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_auth_verifications` (
+	`id` text PRIMARY KEY,
+	`identifier` text NOT NULL,
+	`value` text NOT NULL,
+	`expires_at` integer NOT NULL,
+	`created_at` integer DEFAULT (cast(unixepoch('subsecond') * 1000 as integer)) NOT NULL,
+	`updated_at` integer DEFAULT (cast(unixepoch('subsecond') * 1000 as integer)) NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `hv_sessions` (
+	`id` text PRIMARY KEY,
+	`expires_at` integer NOT NULL,
+	`token` text NOT NULL UNIQUE,
+	`created_at` integer DEFAULT (cast(unixepoch('subsecond') * 1000 as integer)) NOT NULL,
+	`updated_at` integer NOT NULL,
+	`ip_address` text,
+	`user_agent` text,
+	`user_id` text NOT NULL,
+	CONSTRAINT `fk_hv_sessions_user_id_hv_users_id_fk` FOREIGN KEY (`user_id`) REFERENCES `hv_users`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_users` (
+	`id` text PRIMARY KEY,
+	`name` text NOT NULL,
+	`email` text NOT NULL UNIQUE,
+	`email_verified` integer DEFAULT false NOT NULL,
+	`image` text,
+	`created_at` integer DEFAULT (cast(unixepoch('subsecond') * 1000 as integer)) NOT NULL,
+	`updated_at` integer DEFAULT (cast(unixepoch('subsecond') * 1000 as integer)) NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `hv_wallet_addresses` (
+	`id` text PRIMARY KEY,
+	`user_id` text NOT NULL,
+	`address` text NOT NULL,
+	`chain_id` integer NOT NULL,
+	`is_primary` integer DEFAULT false,
+	`created_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_wallet_addresses_user_id_hv_users_id_fk` FOREIGN KEY (`user_id`) REFERENCES `hv_users`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE INDEX `hvAuthAccounts_userId_idx` ON `hv_auth_accounts` (`user_id`);--> statement-breakpoint
+CREATE INDEX `hvAuthVerifications_identifier_idx` ON `hv_auth_verifications` (`identifier`);--> statement-breakpoint
+CREATE INDEX `hvSessions_userId_idx` ON `hv_sessions` (`user_id`);--> statement-breakpoint
+CREATE INDEX `hvWalletAddresses_userId_idx` ON `hv_wallet_addresses` (`user_id`);

package/dist/db/migrations/20261015231224_agents/migration.sql

@@ -0,0 +1,35 @@
+CREATE TABLE `hv_agents` (
+	`id` text PRIMARY KEY,
+	`user_id` text NOT NULL,
+	`name` text NOT NULL,
+	`creation_request_id` text NOT NULL,
+	`state` text DEFAULT 'provisioning' NOT NULL,
+	`enabled` integer DEFAULT true NOT NULL,
+	`conversation_id` integer,
+	`error` text,
+	`trading_account_address` text,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_agents_user_id_hv_users_id_fk` FOREIGN KEY (`user_id`) REFERENCES `hv_users`(`id`) ON DELETE RESTRICT,
+	CONSTRAINT "hv_agents_name_check" CHECK(length(trim("name")) BETWEEN 1 AND 80),
+	CONSTRAINT "hv_agents_state_check" CHECK("state" IN ('provisioning', 'ready', 'failed', 'stopping', 'stopped'))
+);
+--> statement-breakpoint
+CREATE INDEX `hv_agents_owner_idx` ON `hv_agents` (`user_id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_agents_creation_request_idx` ON `hv_agents` (`user_id`,`creation_request_id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_agents_trading_account_idx` ON `hv_agents` (`trading_account_address`);--> statement-breakpoint
+CREATE TABLE `hv_hyperliquid_settings` (
+	`user_id` text PRIMARY KEY,
+	`api_wallet_address` text,
+	`private_key_ciphertext` blob,
+	`private_key_key_id` text,
+	`api_wallet_approved_at` integer,
+	`api_wallet_expires_at` integer,
+	`api_wallet_expiry_checked_at` integer,
+	`builder_fee_tenths_of_bp` integer DEFAULT 0 NOT NULL,
+	`builder_fee_approved_at` integer,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_hyperliquid_settings_user_id_hv_users_id_fk` FOREIGN KEY (`user_id`) REFERENCES `hv_users`(`id`) ON DELETE RESTRICT,
+	CONSTRAINT "hv_hyperliquid_settings_builder_fee_check" CHECK("builder_fee_tenths_of_bp" BETWEEN 0 AND 100)
+);

package/dist/db/migrations/20261016040641_provider_connections/migration.sql

@@ -0,0 +1,19 @@
+CREATE TABLE `hv_installation` (
+	`id` integer PRIMARY KEY,
+	`device_id` text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `hv_provider_connections` (
+	`user_id` text NOT NULL,
+	`provider_id` text NOT NULL,
+	`auth_type` text NOT NULL,
+	`ciphertext` blob NOT NULL,
+	`key_id` text NOT NULL,
+	`catalog` text,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT `hv_provider_connections_pk` PRIMARY KEY(`user_id`, `provider_id`),
+	CONSTRAINT `fk_hv_provider_connections_user_id_hv_users_id_fk` FOREIGN KEY (`user_id`) REFERENCES `hv_users`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+ALTER TABLE `hv_agents` ADD `initial_provider` text;--> statement-breakpoint
+ALTER TABLE `hv_agents` ADD `initial_model_id` text;

package/dist/db/migrations/20261016061831_trade_journal/migration.sql

@@ -0,0 +1,48 @@
+CREATE TABLE `hv_journal_accounts` (
+	`account` text PRIMARY KEY,
+	`revision` integer DEFAULT 0 NOT NULL,
+	`projected_revision` integer DEFAULT -1 NOT NULL,
+	`history_limited` integer DEFAULT 0 NOT NULL,
+	CONSTRAINT "hv_journal_history_limited" CHECK("history_limited" IN (0, 1))
+);
+--> statement-breakpoint
+CREATE TABLE `hv_journal_entries` (
+	`account` text NOT NULL,
+	`id` text NOT NULL,
+	`kind` text NOT NULL,
+	`time` integer NOT NULL,
+	`data` text NOT NULL,
+	`balance` text,
+	`active` integer DEFAULT 1 NOT NULL,
+	CONSTRAINT `hv_journal_entries_pk` PRIMARY KEY(`account`, `id`),
+	CONSTRAINT `fk_hv_journal_entries_account_hv_journal_accounts_account_fk` FOREIGN KEY (`account`) REFERENCES `hv_journal_accounts`(`account`),
+	CONSTRAINT "hv_journal_entry_kind" CHECK("kind" IN ('fill', 'funding', 'ledger', 'trade')),
+	CONSTRAINT "hv_journal_entry_active" CHECK("active" IN (0, 1))
+);
+--> statement-breakpoint
+CREATE TABLE `hv_journal_notes` (
+	`id` text PRIMARY KEY,
+	`account` text NOT NULL,
+	`target` text NOT NULL,
+	`author_id` text NOT NULL,
+	`body` text NOT NULL,
+	`created_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_journal_notes_author_id_hv_users_id_fk` FOREIGN KEY (`author_id`) REFERENCES `hv_users`(`id`),
+	CONSTRAINT `fk_hv_journal_notes_account_target_hv_journal_entries_account_id_fk` FOREIGN KEY (`account`,`target`) REFERENCES `hv_journal_entries`(`account`,`id`),
+	CONSTRAINT "hv_journal_note_body" CHECK(length(trim("body")) > 0 AND length("body") <= 4000)
+);
+--> statement-breakpoint
+CREATE TABLE `hv_journal_sync` (
+	`account` text NOT NULL,
+	`stream` text NOT NULL,
+	`cursor` integer DEFAULT 0 NOT NULL,
+	`updated_at` integer,
+	`error` text,
+	CONSTRAINT `hv_journal_sync_pk` PRIMARY KEY(`account`, `stream`),
+	CONSTRAINT `fk_hv_journal_sync_account_hv_journal_accounts_account_fk` FOREIGN KEY (`account`) REFERENCES `hv_journal_accounts`(`account`),
+	CONSTRAINT "hv_journal_sync_stream" CHECK("stream" IN ('fill', 'funding', 'ledger'))
+);
+--> statement-breakpoint
+CREATE INDEX `hv_journal_entries_page` ON `hv_journal_entries` (`account`,`kind`,`active`,`time`,`id`);--> statement-breakpoint
+CREATE INDEX `hv_journal_entries_timeline` ON `hv_journal_entries` (`account`,`time`,`id`);--> statement-breakpoint
+CREATE INDEX `hv_journal_notes_target` ON `hv_journal_notes` (`account`,`target`,`created_at`,`id`);

package/dist/db/migrations/20261016080320_order_execution/migration.sql

@@ -0,0 +1,62 @@
+CREATE TABLE `hv_exchange_nonces` (
+	`signer` text PRIMARY KEY,
+	`nonce` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `hv_order_actions` (
+	`id` text PRIMARY KEY,
+	`request_id` text NOT NULL,
+	`ordinal` integer NOT NULL,
+	`payload` text NOT NULL,
+	`state` text NOT NULL,
+	`nonce` integer,
+	`expires_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_order_actions_request_id_hv_order_requests_id_fk` FOREIGN KEY (`request_id`) REFERENCES `hv_order_requests`(`id`) ON DELETE CASCADE,
+	CONSTRAINT "hv_order_action_state" CHECK("state" IN ('prepared', 'submitting', 'unknown', 'done', 'not_sent'))
+);
+--> statement-breakpoint
+CREATE TABLE `hv_order_events` (
+	`id` integer PRIMARY KEY AUTOINCREMENT,
+	`item_id` text NOT NULL,
+	`source` text NOT NULL,
+	`time` integer NOT NULL,
+	`data` text NOT NULL,
+	CONSTRAINT `fk_hv_order_events_item_id_hv_order_items_id_fk` FOREIGN KEY (`item_id`) REFERENCES `hv_order_items`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_order_items` (
+	`id` text PRIMARY KEY,
+	`action_id` text NOT NULL,
+	`ordinal` integer NOT NULL,
+	`symbol` text NOT NULL,
+	`cloid` text,
+	`oid` text,
+	`active` integer NOT NULL,
+	`view` text NOT NULL,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_order_items_action_id_hv_order_actions_id_fk` FOREIGN KEY (`action_id`) REFERENCES `hv_order_actions`(`id`) ON DELETE CASCADE,
+	CONSTRAINT "hv_order_item_active" CHECK("active" IN (0, 1))
+);
+--> statement-breakpoint
+CREATE TABLE `hv_order_requests` (
+	`id` text PRIMARY KEY,
+	`agent_id` text NOT NULL,
+	`account` text NOT NULL,
+	`request_key` text NOT NULL,
+	`kind` text NOT NULL,
+	`input` text NOT NULL,
+	`created_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_order_requests_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE,
+	CONSTRAINT "hv_order_request_kind" CHECK("kind" IN ('submit', 'cancel', 'cancel_all', 'close_position'))
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_order_action_ordinal` ON `hv_order_actions` (`request_id`,`ordinal`);--> statement-breakpoint
+CREATE INDEX `hv_order_actions_state` ON `hv_order_actions` (`state`,`updated_at`);--> statement-breakpoint
+CREATE INDEX `hv_order_events_item` ON `hv_order_events` (`item_id`,`id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_order_item_ordinal` ON `hv_order_items` (`action_id`,`ordinal`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_order_item_cloid` ON `hv_order_items` (`cloid`);--> statement-breakpoint
+CREATE INDEX `hv_order_items_active` ON `hv_order_items` (`active`,`updated_at`);--> statement-breakpoint
+CREATE INDEX `hv_order_items_oid` ON `hv_order_items` (`oid`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_order_request_key` ON `hv_order_requests` (`agent_id`,`request_key`);--> statement-breakpoint
+CREATE INDEX `hv_order_requests_agent` ON `hv_order_requests` (`agent_id`,`created_at`);

package/dist/db/migrations/20261016181110_subagents/migration.sql

@@ -0,0 +1,51 @@
+CREATE TABLE `hv_subagent_runs` (
+	`id` text PRIMARY KEY,
+	`agent_id` text NOT NULL,
+	`subagent_id` text NOT NULL,
+	`request_id` text NOT NULL,
+	`source` text NOT NULL,
+	`task` text NOT NULL,
+	`config` text NOT NULL,
+	`status` text DEFAULT 'queued' NOT NULL,
+	`task_id` integer,
+	`conversation_id` integer,
+	`result` text DEFAULT '' NOT NULL,
+	`created_at` integer NOT NULL,
+	`finished_at` integer,
+	`reported_at` integer,
+	CONSTRAINT `fk_hv_subagent_runs_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE,
+	CONSTRAINT `fk_hv_subagent_runs_subagent_id_hv_subagents_id_fk` FOREIGN KEY (`subagent_id`) REFERENCES `hv_subagents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_subagents` (
+	`id` text PRIMARY KEY,
+	`agent_id` text NOT NULL,
+	`kind` text NOT NULL,
+	`name` text NOT NULL,
+	`description` text DEFAULT '' NOT NULL,
+	`instructions` text NOT NULL,
+	`provider` text NOT NULL,
+	`model_id` text NOT NULL,
+	`thinking_level` text DEFAULT '' NOT NULL,
+	`tools` text NOT NULL,
+	`enabled` integer DEFAULT true NOT NULL,
+	`archived` integer DEFAULT false NOT NULL,
+	`delegatable` integer DEFAULT true NOT NULL,
+	`persistent` integer DEFAULT false NOT NULL,
+	`conversation_id` integer,
+	`schedule` text DEFAULT '' NOT NULL,
+	`delay_seconds` integer DEFAULT 30 NOT NULL,
+	`next_run_at` integer,
+	`completion` text DEFAULT 'wake' NOT NULL,
+	`timeout_seconds` integer DEFAULT 900 NOT NULL,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_subagents_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE,
+	CONSTRAINT "hv_subagents_main_protected" CHECK("kind" != 'orchestrator' OR ("enabled" = 1 AND "archived" = 0 AND "schedule" = ''))
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_subagent_runs_request_idx` ON `hv_subagent_runs` (`agent_id`,`request_id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_subagent_runs_active_idx` ON `hv_subagent_runs` (`subagent_id`) WHERE "hv_subagent_runs"."status" IN ('queued', 'running');--> statement-breakpoint
+CREATE INDEX `hv_subagent_runs_history_idx` ON `hv_subagent_runs` (`subagent_id`,`created_at`);--> statement-breakpoint
+CREATE INDEX `hv_subagents_agent_idx` ON `hv_subagents` (`agent_id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_subagents_main_idx` ON `hv_subagents` (`agent_id`) WHERE "hv_subagents"."kind" = 'orchestrator';

package/dist/db/migrations/20261017222959_research_artifacts/migration.sql

@@ -0,0 +1,37 @@
+CREATE TABLE `hv_artifact_links` (
+	`parent` text NOT NULL,
+	`child` text NOT NULL,
+	CONSTRAINT `fk_hv_artifact_links_parent_hv_artifacts_id_fk` FOREIGN KEY (`parent`) REFERENCES `hv_artifacts`(`id`) ON DELETE CASCADE,
+	CONSTRAINT `fk_hv_artifact_links_child_hv_artifacts_id_fk` FOREIGN KEY (`child`) REFERENCES `hv_artifacts`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_artifact_receipts` (
+	`agent_id` text NOT NULL,
+	`operation_key` text NOT NULL,
+	`request_hash` text NOT NULL,
+	`artifact_id` text NOT NULL,
+	CONSTRAINT `fk_hv_artifact_receipts_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_artifacts` (
+	`id` text PRIMARY KEY,
+	`agent_id` text NOT NULL,
+	`title` text NOT NULL,
+	`description` text NOT NULL,
+	`media_type` text NOT NULL,
+	`payload` blob NOT NULL,
+	`size` integer NOT NULL,
+	`tags` text NOT NULL,
+	`instrument` text NOT NULL,
+	`interval` text NOT NULL,
+	`conversation_id` integer,
+	`task_id` integer,
+	`created_at` integer NOT NULL,
+	`expires_at` integer,
+	CONSTRAINT `fk_hv_artifacts_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_artifact_links_pair_idx` ON `hv_artifact_links` (`parent`,`child`);--> statement-breakpoint
+CREATE INDEX `hv_artifact_links_child_idx` ON `hv_artifact_links` (`child`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_artifact_receipts_operation_idx` ON `hv_artifact_receipts` (`agent_id`,`operation_key`);--> statement-breakpoint
+CREATE INDEX `hv_artifacts_agent_idx` ON `hv_artifacts` (`agent_id`,`created_at`);