hypervibes 0.0.0-stage → 0.4.0-beta

package/dist/db/migrations/20261021051229_chart_workspace/migration.sql

@@ -0,0 +1,33 @@
+CREATE TABLE `hv_chart_layouts` (
+  `id` text PRIMARY KEY,
+  `agent_id` text NOT NULL,
+  `document` text NOT NULL,
+  `revision` integer DEFAULT 0 NOT NULL,
+  `history` text NOT NULL,
+  `updated_at` integer NOT NULL,
+  CONSTRAINT `fk_hv_chart_layouts_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_chart_operations` (
+  `agent_id` text NOT NULL,
+  `key` text NOT NULL,
+  `hash` text NOT NULL,
+  `result` text NOT NULL,
+  CONSTRAINT `hv_chart_operations_pk` PRIMARY KEY (`agent_id`, `key`),
+  CONSTRAINT `fk_hv_chart_operations_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_chart_snapshots` (
+  `id` text NOT NULL,
+  `agent_id` text NOT NULL,
+  `request_hash` text NOT NULL,
+  `context` text NOT NULL,
+  `image` text,
+  `created_at` integer NOT NULL,
+  CONSTRAINT `hv_chart_snapshots_pk` PRIMARY KEY (`agent_id`, `id`),
+  CONSTRAINT `fk_hv_chart_snapshots_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE INDEX `hv_chart_layouts_agent_idx` ON `hv_chart_layouts` (`agent_id`, `updated_at`);
+--> statement-breakpoint
+CREATE INDEX `hv_chart_snapshots_agent_idx` ON `hv_chart_snapshots` (`agent_id`, `created_at`);

package/dist/db/migrations/20261021222116_gateways/migration.sql

@@ -0,0 +1,15 @@
+CREATE TABLE `hv_gateways` (
+	`agent_id` text NOT NULL,
+	`type` text NOT NULL,
+	`bot_token_ciphertext` blob NOT NULL,
+	`bot_token_hash` text NOT NULL,
+	`key_id` text NOT NULL,
+	`bot_username` text NOT NULL,
+	`chat_id` integer,
+	`chat_username` text,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT `hv_gateways_agent_id_type_pk` PRIMARY KEY (`agent_id`,`type`),
+	CONSTRAINT `fk_hv_gateways_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_gateways_token_hash_idx` ON `hv_gateways` (`bot_token_hash`);

package/dist/db/migrations/20261022015813_pine_indicators/migration.sql

@@ -0,0 +1,43 @@
+CREATE TABLE `hv_indicator_operations` (
+	`agent_id` text NOT NULL,
+	`key` text NOT NULL,
+	`hash` text NOT NULL,
+	`result` text NOT NULL,
+	CONSTRAINT `hv_indicator_operations_pk` PRIMARY KEY(`agent_id`, `key`),
+	CONSTRAINT `fk_hv_indicator_operations_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_indicator_versions` (
+	`indicator_id` text NOT NULL,
+	`version` integer NOT NULL,
+	`source` text NOT NULL,
+	`source_hash` text NOT NULL,
+	`metadata` text NOT NULL,
+	`engine_version` text NOT NULL,
+	`wrapper_version` integer NOT NULL,
+	`created_at` integer NOT NULL,
+	`actor_kind` text NOT NULL,
+	`user_id` text,
+	`subagent_id` text,
+	`run_id` text,
+	`conversation_id` text,
+	`task_id` text,
+	CONSTRAINT `hv_indicator_versions_pk` PRIMARY KEY(`indicator_id`, `version`),
+	CONSTRAINT `fk_hv_indicator_versions_indicator_id_hv_indicators_id_fk` FOREIGN KEY (`indicator_id`) REFERENCES `hv_indicators`(`id`) ON DELETE CASCADE,
+	CONSTRAINT "hv_indicator_versions_positive" CHECK("version" > 0)
+);
+--> statement-breakpoint
+CREATE TABLE `hv_indicators` (
+	`id` text PRIMARY KEY,
+	`agent_id` text NOT NULL,
+	`name` text NOT NULL,
+	`description` text NOT NULL,
+	`interpretation` text NOT NULL,
+	`current_version` integer NOT NULL,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_indicators_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE,
+	CONSTRAINT "hv_indicators_version_positive" CHECK("current_version" > 0)
+);
+--> statement-breakpoint
+CREATE INDEX `hv_indicators_agent_idx` ON `hv_indicators` (`agent_id`,`updated_at`);

package/dist/db/migrations/20261022101559_notifications/migration.sql

@@ -0,0 +1,51 @@
+CREATE TABLE `hv_notification_operations` (
+	`agent_id` text NOT NULL,
+	`operation_key` text NOT NULL,
+	`request_hash` text NOT NULL,
+	`result` text NOT NULL,
+	CONSTRAINT `fk_hv_notification_operations_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_notification_settings` (
+	`agent_id` text PRIMARY KEY,
+	`enabled` integer DEFAULT true NOT NULL,
+	`submissions` integer DEFAULT true NOT NULL,
+	`fills` integer DEFAULT true NOT NULL,
+	`enabled_since` integer NOT NULL,
+	`fills_since` integer NOT NULL,
+	CONSTRAINT `fk_hv_notification_settings_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_notifications` (
+	`id` text PRIMARY KEY,
+	`agent_id` text NOT NULL,
+	`event_key` text NOT NULL,
+	`category` text NOT NULL,
+	`title` text NOT NULL,
+	`body` text NOT NULL,
+	`severity` text NOT NULL,
+	`source` text NOT NULL,
+	`subagent_id` text,
+	`run_id` text,
+	`conversation_id` integer,
+	`order_request_id` text,
+	`created_at` integer NOT NULL,
+	`delivery` text NOT NULL,
+	`chat_id` integer,
+	`bot_token_hash` text,
+	`message_ids` text DEFAULT '[]' NOT NULL,
+	`attempts` integer DEFAULT 0 NOT NULL,
+	`next_attempt_at` integer NOT NULL,
+	`sent_at` integer,
+	`error` text,
+	CONSTRAINT `fk_hv_notifications_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_notification_operations_key_idx` ON `hv_notification_operations` (`agent_id`,`operation_key`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_notifications_event_idx` ON `hv_notifications` (`agent_id`,`event_key`);--> statement-breakpoint
+CREATE INDEX `hv_notifications_history_idx` ON `hv_notifications` (`agent_id`,`created_at`,`id`);--> statement-breakpoint
+CREATE INDEX `hv_notifications_delivery_idx` ON `hv_notifications` (`delivery`,`next_attempt_at`);
+--> statement-breakpoint
+-- Existing accounts start observing now, never announcing historical imports.
+INSERT INTO hv_notification_settings(agent_id,enabled_since,fills_since)
+SELECT id, CAST(unixepoch('subsec') * 1000 AS INTEGER), CAST(unixepoch('subsec') * 1000 AS INTEGER) FROM hv_agents;

package/dist/db/migrations.js

@@ -0,0 +1,12 @@
+import { drizzle } from "drizzle-orm/node-sqlite";
+import { migrate } from "drizzle-orm/node-sqlite/migrator";
+import { fileURLToPath } from "node:url";
+/** Startup-only native access, before the application's shared SQL queue is used. */
+export function migrateApplication(connection, migrationsFolder = fileURLToPath(new URL("./migrations/", import.meta.url))) {
+    const hasHistory = connection.prepare("SELECT 1 FROM sqlite_schema WHERE type = 'table' AND name = 'hv_schema_migrations'").get();
+    const migrationCount = () => Number(connection.prepare("SELECT count(*) AS count FROM hv_schema_migrations").get()?.count);
+    const before = hasHistory ? migrationCount() : 0;
+    migrate(drizzle({ client: connection }), { migrationsFolder, migrationsTable: "hv_schema_migrations" });
+    const total = migrationCount();
+    return { applied: total - before, total };
+}

package/dist/db/order-provenance-schema.js

@@ -0,0 +1,17 @@
+import { foreignKey, index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { hvOrderRequests } from "./order-schema.js";
+import { hvSubagents, hvSubagentRuns } from "./subagent-schema.js";
+/** Host-captured origin, independent of the optional model-authored decision ref. */
+export const hvOrderRequestProvenance = sqliteTable("hv_order_request_provenance", {
+    requestId: text("request_id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    producerSubagentId: text("producer_subagent_id").notNull(),
+    sourceRunId: text("source_run_id"),
+    conversationId: integer("conversation_id").notNull(),
+    toolTaskId: integer("tool_task_id").notNull(),
+}, (t) => [
+    foreignKey({ columns: [t.agentId, t.requestId], foreignColumns: [hvOrderRequests.agentId, hvOrderRequests.id] }).onDelete("cascade"),
+    foreignKey({ columns: [t.agentId, t.producerSubagentId], foreignColumns: [hvSubagents.agentId, hvSubagents.id] }),
+    foreignKey({ columns: [t.agentId, t.sourceRunId, t.producerSubagentId], foreignColumns: [hvSubagentRuns.agentId, hvSubagentRuns.id, hvSubagentRuns.subagentId] }),
+    index("hv_order_provenance_run_idx").on(t.agentId, t.sourceRunId),
+]);

package/dist/db/order-schema.js

@@ -0,0 +1,32 @@
+import { sql } from "drizzle-orm";
+import { check, index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { hvAgents } from "./agent-schema.js";
+// Public application storage, never Pi's private tables. Request identity and
+// prepared wire payloads are immutable. Amounts remain strings inside JSON TEXT.
+export const hvOrderRequests = sqliteTable("hv_order_requests", {
+    id: text("id").primaryKey(), agentId: text("agent_id").notNull().references(() => hvAgents.id, { onDelete: "cascade" }),
+    account: text("account").notNull(), requestKey: text("request_key").notNull(), kind: text("kind").notNull(),
+    input: text("input").notNull(), createdAt: integer("created_at").notNull(),
+}, (t) => [uniqueIndex("hv_order_request_identity").on(t.agentId, t.id), uniqueIndex("hv_order_request_key").on(t.agentId, t.requestKey), index("hv_order_requests_agent").on(t.agentId, t.createdAt),
+    check("hv_order_request_kind", sql `${t.kind} IN ('submit', 'cancel', 'cancel_all', 'close_position')`)]);
+export const hvOrderActions = sqliteTable("hv_order_actions", {
+    id: text("id").primaryKey(), requestId: text("request_id").notNull().references(() => hvOrderRequests.id, { onDelete: "cascade" }),
+    ordinal: integer("ordinal").notNull(), payload: text("payload").notNull(),
+    state: text("state").notNull(), nonce: integer("nonce"), expiresAt: integer("expires_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+}, (t) => [uniqueIndex("hv_order_action_ordinal").on(t.requestId, t.ordinal), index("hv_order_actions_state").on(t.state, t.updatedAt),
+    check("hv_order_action_state", sql `${t.state} IN ('prepared', 'submitting', 'unknown', 'done', 'not_sent')`)]);
+export const hvOrderItems = sqliteTable("hv_order_items", {
+    id: text("id").primaryKey(), actionId: text("action_id").notNull().references(() => hvOrderActions.id, { onDelete: "cascade" }),
+    ordinal: integer("ordinal").notNull(), symbol: text("symbol").notNull(), cloid: text("cloid"), oid: text("oid"),
+    active: integer("active").notNull(), view: text("view").notNull(), updatedAt: integer("updated_at").notNull(),
+}, (t) => [uniqueIndex("hv_order_item_ordinal").on(t.actionId, t.ordinal), uniqueIndex("hv_order_item_cloid").on(t.cloid),
+    index("hv_order_items_active").on(t.active, t.updatedAt), index("hv_order_items_oid").on(t.oid),
+    check("hv_order_item_active", sql `${t.active} IN (0, 1)`)]);
+export const hvOrderEvents = sqliteTable("hv_order_events", {
+    id: integer("id").primaryKey({ autoIncrement: true }), itemId: text("item_id").notNull().references(() => hvOrderItems.id, { onDelete: "cascade" }),
+    source: text("source").notNull(), time: integer("time").notNull(), data: text("data").notNull(),
+}, (t) => [index("hv_order_events_item").on(t.itemId, t.id)]);
+export const hvExchangeNonces = sqliteTable("hv_exchange_nonces", {
+    signer: text("signer").primaryKey(), nonce: integer("nonce").notNull(),
+});

package/dist/db/profile-lock.js

@@ -0,0 +1,12 @@
+import { realpath } from "node:fs/promises";
+import lockfile from "proper-lockfile";
+/** Heartbeat-backed exclusive ownership; stale locks from crashed hosts expire. */
+export async function lockProfile(path, onCompromised) {
+    return lockfile.lock(await realpath(path), {
+        realpath: false,
+        stale: 30_000,
+        update: 5_000,
+        retries: 0,
+        onCompromised,
+    });
+}

package/dist/db/provider-schema.js

@@ -0,0 +1,16 @@
+import { blob, integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { hvUsers } from "./auth-schema.js";
+export const hvProviderConnections = sqliteTable("hv_provider_connections", {
+    userId: text("user_id").notNull().references(() => hvUsers.id, { onDelete: "cascade" }),
+    providerId: text("provider_id").notNull(),
+    authType: text("auth_type", { enum: ["api_key", "oauth"] }).notNull(),
+    ciphertext: blob("ciphertext", { mode: "buffer" }).notNull(),
+    keyId: text("key_id").notNull(),
+    catalog: text("catalog"),
+    updatedAt: integer("updated_at").notNull(),
+}, (table) => [primaryKey({ columns: [table.userId, table.providerId] })]);
+/** Stable installation identity required by the OpenAI OAuth registration flow. */
+export const hvInstallation = sqliteTable("hv_installation", {
+    id: integer("id").primaryKey(),
+    deviceId: text("device_id").notNull(),
+});

package/dist/db/shared-database.js

@@ -0,0 +1,128 @@
+import { drizzle } from "drizzle-orm/sqlite-proxy";
+class Executor {
+    connection;
+    active = true;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    statement(sql) {
+        if (!this.active)
+            throw new Error("SQLite executor is closed");
+        return this.connection.prepare(sql);
+    }
+    async exec(sql) {
+        if (!this.active)
+            throw new Error("SQLite executor is closed");
+        this.connection.exec(sql);
+    }
+    async run(sql, ...params) { this.statement(sql).run(...params); }
+    async get(sql, ...params) {
+        return this.statement(sql).get(...params);
+    }
+    async all(sql, ...params) {
+        return this.statement(sql).all(...params);
+    }
+    async query(sql, params, method) {
+        // Transactions must reserve the queue through SharedDatabase.transaction(),
+        // never through the proxy driver's separate BEGIN/query/COMMIT operations.
+        if (/^\s*(BEGIN|COMMIT|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(sql)) {
+            throw new Error("Use the shared database transaction boundary");
+        }
+        const statement = this.statement(sql);
+        if (method === "run") {
+            statement.run(...params);
+            return { rows: [] };
+        }
+        statement.setReturnArrays(true);
+        // node:sqlite's declarations retain object return types after this setting.
+        // Drizzle's callback declares rows as an array even for `get`, but its
+        // runtime requires undefined for a missing row (an empty array maps to a
+        // phantom record). Preserve undefined through this driver type boundary.
+        if (method === "get")
+            return { rows: statement.get(...params) };
+        return { rows: statement.all(...params) };
+    }
+}
+/** One queue for app SQL and every harness, held across the entire transaction. */
+export class SharedDatabase {
+    connection;
+    tail = Promise.resolve();
+    closed = false;
+    failure;
+    executor;
+    constructor(connection) {
+        this.connection = connection;
+        this.executor = new Executor(connection);
+    }
+    get available() { return !this.closed && !this.failure; }
+    enqueue(operation) {
+        if (this.closed)
+            return Promise.reject(new Error("Database is closed"));
+        if (this.failure)
+            return Promise.reject(this.failure);
+        const result = this.tail.then(() => {
+            if (this.failure)
+                throw this.failure;
+            return operation();
+        });
+        this.tail = result.catch(() => { });
+        return result;
+    }
+    exec(sql) { return this.enqueue(() => this.executor.exec(sql)); }
+    run(sql, ...params) { return this.enqueue(() => this.executor.run(sql, ...params)); }
+    get(sql, ...params) { return this.enqueue(() => this.executor.get(sql, ...params)); }
+    all(sql, ...params) { return this.enqueue(() => this.executor.all(sql, ...params)); }
+    query(sql, params, method) {
+        return this.enqueue(() => this.executor.query(sql, params, method));
+    }
+    transaction(callback) {
+        return this.enqueue(async () => {
+            const transaction = new Executor(this.connection);
+            this.connection.exec("BEGIN IMMEDIATE");
+            try {
+                const result = await callback(transaction);
+                this.connection.exec("COMMIT");
+                return result;
+            }
+            catch (error) {
+                try {
+                    this.connection.exec("ROLLBACK");
+                }
+                catch (rollback) {
+                    // Transaction ownership is now uncertain. Never let another owner
+                    // accidentally join it; shutdown may still close the raw connection.
+                    this.failure = new AggregateError([error, rollback], "SQLite rollback failed", { cause: rollback });
+                    throw this.failure;
+                }
+                throw error;
+            }
+            finally {
+                transaction.active = false;
+            }
+        });
+    }
+    appTransaction(callback) {
+        return this.transaction((transaction) => callback(drizzle((sql, params, method) => transaction.query(sql, params, method)), transaction));
+    }
+    /** Each harness borrows the facade; only the application owns the connection. */
+    borrow() {
+        return {
+            exec: this.exec.bind(this), run: this.run.bind(this), get: this.get.bind(this), all: this.all.bind(this),
+            transaction: this.transaction.bind(this),
+            // Storage close drains already-admitted SQL without closing other owners.
+            close: () => this.enqueue(async () => { }),
+        };
+    }
+    async close() {
+        if (this.closed)
+            return this.tail.then(() => { });
+        this.closed = true;
+        await this.tail;
+        this.executor.active = false;
+        if (this.connection.isOpen)
+            this.connection.close();
+    }
+}
+export function applicationDatabase(database) {
+    return drizzle((sql, params, method) => database.query(sql, params, method));
+}

package/dist/db/subagent-schema.js

@@ -0,0 +1,79 @@
+import { sql } from "drizzle-orm";
+import { check, foreignKey, index, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { hvAgents } from "./agent-schema.js";
+export const hvSubagents = sqliteTable("hv_subagents", {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull().references(() => hvAgents.id, { onDelete: "cascade" }),
+    kind: text("kind", { enum: ["orchestrator", "worker"] }).notNull(),
+    name: text("name").notNull(),
+    description: text("description").notNull().default(""),
+    instructions: text("instructions").notNull(),
+    provider: text("provider").notNull(),
+    modelId: text("model_id").notNull(),
+    thinkingLevel: text("thinking_level").notNull().default(""),
+    tools: text("tools", { mode: "json" }).$type().notNull(),
+    triggers: text("triggers", { mode: "json" }).$type().notNull().default({ inboxEnabled: false, workerDelegates: [], researchSources: [], fills: false, orderChanges: false }),
+    templateOrigin: text("template_origin", { mode: "json" }).$type(),
+    enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+    archived: integer("archived", { mode: "boolean" }).notNull().default(false),
+    delegatable: integer("delegatable", { mode: "boolean" }).notNull().default(true),
+    persistent: integer("persistent", { mode: "boolean" }).notNull().default(false),
+    conversationId: integer("conversation_id"),
+    schedule: text("schedule").notNull().default(""),
+    delaySeconds: integer("delay_seconds").notNull().default(1),
+    nextRunAt: integer("next_run_at"),
+    completion: text("completion", { enum: ["save", "notify", "wake"] }).notNull().default("wake"),
+    timeoutSeconds: integer("timeout_seconds").notNull().default(900),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+}, (t) => [
+    index("hv_subagents_agent_idx").on(t.agentId),
+    uniqueIndex("hv_subagents_identity_idx").on(t.agentId, t.id),
+    uniqueIndex("hv_subagents_main_idx").on(t.agentId).where(sql `${t.kind} = 'orchestrator'`),
+    check("hv_subagents_main_protected", sql `${t.kind} != 'orchestrator' OR (${t.enabled} = 1 AND ${t.archived} = 0 AND ${t.schedule} = '')`),
+]);
+export const hvSubagentRuns = sqliteTable("hv_subagent_runs", {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull().references(() => hvAgents.id, { onDelete: "cascade" }),
+    subagentId: text("subagent_id").notNull().references(() => hvSubagents.id, { onDelete: "cascade" }),
+    requestId: text("request_id").notNull(),
+    source: text("source", { enum: ["manual", "schedule", "delegation", "event"] }).notNull(),
+    task: text("task").notNull(),
+    config: text("config", { mode: "json" }).$type().notNull(),
+    status: text("status", { enum: ["queued", "running", "completed", "failed", "cancelled", "skipped"] }).notNull().default("queued"),
+    taskId: integer("task_id"),
+    conversationId: integer("conversation_id"),
+    result: text("result").notNull().default(""),
+    createdAt: integer("created_at").notNull(),
+    finishedAt: integer("finished_at"),
+    reportedAt: integer("reported_at"),
+}, (t) => [
+    uniqueIndex("hv_subagent_runs_request_idx").on(t.agentId, t.requestId),
+    uniqueIndex("hv_subagent_runs_producer_idx").on(t.agentId, t.id, t.subagentId),
+    uniqueIndex("hv_subagent_runs_identity_idx").on(t.agentId, t.id),
+    uniqueIndex("hv_subagent_runs_active_idx").on(t.subagentId).where(sql `${t.status} IN ('queued', 'running')`),
+    index("hv_subagent_runs_history_idx").on(t.subagentId, t.createdAt),
+]);
+/** Activation windows are maintained atomically by the inbox migration's SQLite triggers. */
+export const hvWorkerSubscriptions = sqliteTable("hv_worker_subscriptions", {
+    subagentId: text("subagent_id").notNull().references(() => hvSubagents.id, { onDelete: "cascade" }),
+    eventType: text("event_type").notNull(),
+    sourceId: text("source_id").notNull(),
+    activatedAt: integer("activated_at").notNull(),
+}, (t) => [primaryKey({ columns: [t.subagentId, t.eventType, t.sourceId] })]);
+/** Application-owned inbox and request provenance; admission atomically links requests to runs. */
+export const hvWorkerRequests = sqliteTable("hv_worker_requests", {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull().references(() => hvAgents.id, { onDelete: "cascade" }),
+    subagentId: text("subagent_id").notNull(),
+    eventKey: text("event_key").notNull(),
+    payload: text("payload", { mode: "json" }).$type().notNull(),
+    createdAt: integer("created_at").notNull(),
+    runId: text("run_id"),
+    discardedReason: text("discarded_reason"),
+}, (t) => [
+    foreignKey({ columns: [t.agentId, t.subagentId], foreignColumns: [hvSubagents.agentId, hvSubagents.id] }),
+    foreignKey({ columns: [t.agentId, t.runId, t.subagentId], foreignColumns: [hvSubagentRuns.agentId, hvSubagentRuns.id, hvSubagentRuns.subagentId] }),
+    uniqueIndex("hv_worker_requests_event_idx").on(t.agentId, t.subagentId, t.eventKey),
+    index("hv_worker_requests_pending_idx").on(t.subagentId, t.createdAt).where(sql `${t.runId} IS NULL AND ${t.discardedReason} IS NULL`),
+]);