hypervibes 0.0.0-stage → 0.4.0

package/dist/db/migrations/20261018061531_memories_and_insights/migration.sql

@@ -0,0 +1,162 @@
+CREATE TABLE `hv_memories` (
+	`agent_id` text NOT NULL,
+	`number` integer NOT NULL,
+	`kind` text NOT NULL,
+	`topic` text NOT NULL,
+	`instrument` text,
+	`interval` text,
+	`summary` text NOT NULL,
+	`content` text NOT NULL,
+	`payload` text NOT NULL,
+	`created_at` integer NOT NULL,
+	`evidence_as_of` integer,
+	`valid_until` integer,
+	`producer_subagent_id` text,
+	`source_run_id` text,
+	`conversation_id` integer,
+	`tool_task_id` integer,
+	`retracted_at` integer,
+	`retraction_reason` text,
+	CONSTRAINT `hv_memories_pk` PRIMARY KEY(`agent_id`, `number`),
+	CONSTRAINT `fk_hv_memories_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE,
+	CONSTRAINT `fk_hv_memories_agent_id_producer_subagent_id_hv_subagents_agent_id_id_fk` FOREIGN KEY (`agent_id`,`producer_subagent_id`) REFERENCES `hv_subagents`(`agent_id`,`id`),
+	CONSTRAINT `fk_hv_memories_agent_id_source_run_id_producer_subagent_id_hv_subagent_runs_agent_id_id_subagent_id_fk` FOREIGN KEY (`agent_id`,`source_run_id`,`producer_subagent_id`) REFERENCES `hv_subagent_runs`(`agent_id`,`id`,`subagent_id`),
+	CONSTRAINT "hv_memory_number_positive" CHECK("number" BETWEEN 1 AND 9007199254740990),
+	CONSTRAINT "hv_memory_kind" CHECK("kind" IN ('research','decision','review')),
+	CONSTRAINT "hv_memory_text_bounds" CHECK(length("summary") BETWEEN 1 AND 500 AND length("content") BETWEEN 1 AND 16000 AND length(CAST("payload" AS BLOB)) <= 16384 AND json_valid("payload")),
+	CONSTRAINT "hv_memory_research_deadline" CHECK("kind" != 'research' OR ("evidence_as_of" IS NOT NULL AND "valid_until" IS NOT NULL AND "valid_until" > "evidence_as_of" AND "instrument" IS NOT NULL AND "interval" IS NOT NULL)),
+	CONSTRAINT "hv_memory_run_producer" CHECK("source_run_id" IS NULL OR "producer_subagent_id" IS NOT NULL),
+	CONSTRAINT "hv_memory_retraction" CHECK(("retracted_at" IS NULL) = ("retraction_reason" IS NULL))
+);
+--> statement-breakpoint
+CREATE TABLE `hv_memory_artifacts` (
+	`agent_id` text NOT NULL,
+	`memory_number` integer NOT NULL,
+	`artifact_id` text NOT NULL,
+	CONSTRAINT `hv_memory_artifacts_pk` PRIMARY KEY(`agent_id`, `memory_number`, `artifact_id`),
+	CONSTRAINT `fk_hv_memory_artifacts_agent_id_memory_number_hv_memories_agent_id_number_fk` FOREIGN KEY (`agent_id`,`memory_number`) REFERENCES `hv_memories`(`agent_id`,`number`) ON DELETE CASCADE,
+	CONSTRAINT `fk_hv_memory_artifacts_agent_id_artifact_id_hv_artifacts_agent_id_id_fk` FOREIGN KEY (`agent_id`,`artifact_id`) REFERENCES `hv_artifacts`(`agent_id`,`id`)
+);
+--> statement-breakpoint
+CREATE TABLE `hv_memory_counters` (
+	`agent_id` text PRIMARY KEY,
+	`next_number` integer DEFAULT 1 NOT NULL,
+	CONSTRAINT `fk_hv_memory_counters_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE,
+	CONSTRAINT "hv_memory_counter_positive" CHECK("next_number" BETWEEN 1 AND 9007199254740991)
+);
+--> statement-breakpoint
+CREATE TABLE `hv_memory_links` (
+	`agent_id` text NOT NULL,
+	`source_number` integer NOT NULL,
+	`target_number` integer NOT NULL,
+	`relation` text NOT NULL,
+	CONSTRAINT `hv_memory_links_pk` PRIMARY KEY(`agent_id`, `source_number`, `target_number`, `relation`),
+	CONSTRAINT `fk_hv_memory_links_agent_id_source_number_hv_memories_agent_id_number_fk` FOREIGN KEY (`agent_id`,`source_number`) REFERENCES `hv_memories`(`agent_id`,`number`) ON DELETE CASCADE,
+	CONSTRAINT `fk_hv_memory_links_agent_id_target_number_hv_memories_agent_id_number_fk` FOREIGN KEY (`agent_id`,`target_number`) REFERENCES `hv_memories`(`agent_id`,`number`),
+	CONSTRAINT "hv_memory_link_backward" CHECK("target_number" < "source_number"),
+	CONSTRAINT "hv_memory_link_relation" CHECK("relation" IN ('based_on','corrects','supersedes','reviews'))
+);
+--> statement-breakpoint
+CREATE TABLE `hv_memory_operations` (
+	`agent_id` text NOT NULL,
+	`operation_key` text NOT NULL,
+	`operation_kind` text NOT NULL,
+	`request_hash` text NOT NULL,
+	`result` text NOT NULL,
+	`created_at` integer NOT NULL,
+	CONSTRAINT `hv_memory_operations_pk` PRIMARY KEY(`agent_id`, `operation_key`),
+	CONSTRAINT `fk_hv_memory_operations_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE TABLE `hv_insight_revision_memories` (
+	`agent_id` text NOT NULL,
+	`set_id` text NOT NULL,
+	`version` integer NOT NULL,
+	`memory_number` integer NOT NULL,
+	CONSTRAINT `hv_insight_revision_memories_pk` PRIMARY KEY(`agent_id`, `set_id`, `version`, `memory_number`),
+	CONSTRAINT `fk_hv_insight_revision_memories_agent_id_set_id_version_hv_insight_revisions_agent_id_set_id_version_fk` FOREIGN KEY (`agent_id`,`set_id`,`version`) REFERENCES `hv_insight_revisions`(`agent_id`,`set_id`,`version`) ON DELETE CASCADE,
+	CONSTRAINT `fk_hv_insight_revision_memories_agent_id_memory_number_hv_memories_agent_id_number_fk` FOREIGN KEY (`agent_id`,`memory_number`) REFERENCES `hv_memories`(`agent_id`,`number`)
+);
+--> statement-breakpoint
+CREATE TABLE `hv_insight_revisions` (
+	`agent_id` text NOT NULL,
+	`set_id` text NOT NULL,
+	`version` integer NOT NULL,
+	`content` text NOT NULL,
+	`operation` text NOT NULL,
+	`reason` text NOT NULL,
+	`created_at` integer NOT NULL,
+	`actor_user_id` text,
+	`producer_subagent_id` text,
+	`source_run_id` text,
+	`conversation_id` integer,
+	`tool_task_id` integer,
+	CONSTRAINT `hv_insight_revisions_pk` PRIMARY KEY(`set_id`, `version`),
+	CONSTRAINT `fk_hv_insight_revisions_agent_id_set_id_hv_insight_sets_agent_id_id_fk` FOREIGN KEY (`agent_id`,`set_id`) REFERENCES `hv_insight_sets`(`agent_id`,`id`) ON DELETE CASCADE,
+	CONSTRAINT `fk_hv_insight_revisions_agent_id_producer_subagent_id_hv_subagents_agent_id_id_fk` FOREIGN KEY (`agent_id`,`producer_subagent_id`) REFERENCES `hv_subagents`(`agent_id`,`id`),
+	CONSTRAINT `fk_hv_insight_revisions_agent_id_source_run_id_producer_subagent_id_hv_subagent_runs_agent_id_id_subagent_id_fk` FOREIGN KEY (`agent_id`,`source_run_id`,`producer_subagent_id`) REFERENCES `hv_subagent_runs`(`agent_id`,`id`,`subagent_id`),
+	CONSTRAINT "hv_insight_revision_version" CHECK("version" BETWEEN 1 AND 9007199254740990),
+	CONSTRAINT "hv_insight_content_bound" CHECK(length("content") <= 8000),
+	CONSTRAINT "hv_insight_operation" CHECK("operation" IN ('append','replace')),
+	CONSTRAINT "hv_insight_revision_actor" CHECK(("actor_user_id" IS NOT NULL AND "source_run_id" IS NULL) OR ("actor_user_id" IS NULL AND "producer_subagent_id" IS NOT NULL))
+);
+--> statement-breakpoint
+CREATE TABLE `hv_insight_sets` (
+	`id` text PRIMARY KEY,
+	`agent_id` text NOT NULL,
+	`scope_kind` text NOT NULL,
+	`subagent_id` text,
+	`current_version` integer DEFAULT 0 NOT NULL,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_insight_sets_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE,
+	CONSTRAINT `fk_hv_insight_sets_agent_id_subagent_id_hv_subagents_agent_id_id_fk` FOREIGN KEY (`agent_id`,`subagent_id`) REFERENCES `hv_subagents`(`agent_id`,`id`),
+	CONSTRAINT "hv_insight_scope" CHECK(("scope_kind" = 'agent' AND "subagent_id" IS NULL) OR ("scope_kind" = 'worker' AND "subagent_id" IS NOT NULL)),
+	CONSTRAINT "hv_insight_head" CHECK("current_version" BETWEEN 0 AND 9007199254740990)
+);
+--> statement-breakpoint
+CREATE TABLE `hv_subagent_run_contexts` (
+	`agent_id` text NOT NULL,
+	`run_id` text PRIMARY KEY,
+	`context` text NOT NULL,
+	CONSTRAINT `fk_hv_subagent_run_contexts_agent_id_run_id_hv_subagent_runs_agent_id_id_fk` FOREIGN KEY (`agent_id`,`run_id`) REFERENCES `hv_subagent_runs`(`agent_id`,`id`) ON DELETE CASCADE,
+	CONSTRAINT "hv_run_context_bound" CHECK(length("context") <= 120000)
+);
+--> statement-breakpoint
+CREATE TABLE `hv_risk_settings` (
+	`agent_id` text PRIMARY KEY,
+	`trading_enabled` integer DEFAULT false NOT NULL,
+	`allowed_instruments` text,
+	`max_order_notional` text,
+	`max_total_notional` text,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT `fk_hv_risk_settings_agent_id_hv_agents_id_fk` FOREIGN KEY (`agent_id`) REFERENCES `hv_agents`(`id`) ON DELETE CASCADE,
+	CONSTRAINT "hv_risk_instruments_bound" CHECK(length(coalesce("allowed_instruments", '[]')) <= 4000 AND json_valid(coalesce("allowed_instruments", '[]')))
+);
+--> statement-breakpoint
+ALTER TABLE `hv_subagents` ADD `template_origin` text;--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_order_request_identity` ON `hv_order_requests` (`agent_id`,`id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_subagent_runs_producer_idx` ON `hv_subagent_runs` (`agent_id`,`id`,`subagent_id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_subagent_runs_identity_idx` ON `hv_subagent_runs` (`agent_id`,`id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_subagents_identity_idx` ON `hv_subagents` (`agent_id`,`id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_artifacts_identity_idx` ON `hv_artifacts` (`agent_id`,`id`);--> statement-breakpoint
+CREATE INDEX `hv_memories_history_idx` ON `hv_memories` (`agent_id`,`created_at`,`number`);--> statement-breakpoint
+CREATE INDEX `hv_memories_stream_idx` ON `hv_memories` (`agent_id`,`kind`,`instrument`,`topic`,`interval`,`producer_subagent_id`,`number`);--> statement-breakpoint
+CREATE INDEX `hv_memories_run_idx` ON `hv_memories` (`agent_id`,`source_run_id`);--> statement-breakpoint
+CREATE INDEX `hv_memory_artifacts_evidence_idx` ON `hv_memory_artifacts` (`agent_id`,`artifact_id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_insight_revision_identity_idx` ON `hv_insight_revisions` (`agent_id`,`set_id`,`version`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_insight_sets_identity_idx` ON `hv_insight_sets` (`agent_id`,`id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_insight_sets_agent_idx` ON `hv_insight_sets` (`agent_id`) WHERE "hv_insight_sets"."scope_kind" = 'agent';--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_insight_sets_worker_idx` ON `hv_insight_sets` (`agent_id`,`subagent_id`) WHERE "hv_insight_sets"."scope_kind" = 'worker';--> statement-breakpoint
+CREATE TABLE `hv_order_request_provenance` (
+	`request_id` text PRIMARY KEY,
+	`agent_id` text NOT NULL,
+	`producer_subagent_id` text NOT NULL,
+	`source_run_id` text,
+	`conversation_id` integer NOT NULL,
+	`tool_task_id` integer NOT NULL,
+	CONSTRAINT `fk_hv_order_request_provenance_agent_id_request_id_hv_order_requests_agent_id_id_fk` FOREIGN KEY (`agent_id`,`request_id`) REFERENCES `hv_order_requests`(`agent_id`,`id`) ON DELETE CASCADE,
+	CONSTRAINT `fk_hv_order_request_provenance_agent_id_producer_subagent_id_hv_subagents_agent_id_id_fk` FOREIGN KEY (`agent_id`,`producer_subagent_id`) REFERENCES `hv_subagents`(`agent_id`,`id`),
+	CONSTRAINT `fk_hv_order_request_provenance_agent_id_source_run_id_producer_subagent_id_hv_subagent_runs_agent_id_id_subagent_id_fk` FOREIGN KEY (`agent_id`,`source_run_id`,`producer_subagent_id`) REFERENCES `hv_subagent_runs`(`agent_id`,`id`,`subagent_id`)
+);
+--> statement-breakpoint
+CREATE INDEX `hv_order_provenance_run_idx` ON `hv_order_request_provenance` (`agent_id`,`source_run_id`);

package/dist/db/migrations/20261020091156_worker_event_inbox/migration.sql

@@ -0,0 +1,54 @@
+ALTER TABLE `hv_subagents` ADD `triggers` text DEFAULT '{"inboxEnabled":false,"workerDelegates":[],"researchSources":[],"fills":false,"orderChanges":false}' NOT NULL;
+--> statement-breakpoint
+CREATE TABLE `hv_worker_requests` (
+  `id` text PRIMARY KEY,
+  `agent_id` text NOT NULL REFERENCES `hv_agents` (`id`) ON DELETE CASCADE,
+  `subagent_id` text NOT NULL,
+  `event_key` text NOT NULL,
+  `payload` text NOT NULL,
+  `created_at` integer NOT NULL,
+  `run_id` text,
+  `discarded_reason` text,
+  FOREIGN KEY (`agent_id`, `subagent_id`) REFERENCES `hv_subagents` (`agent_id`, `id`),
+  FOREIGN KEY (`agent_id`, `run_id`, `subagent_id`) REFERENCES `hv_subagent_runs` (`agent_id`, `id`, `subagent_id`)
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `hv_worker_requests_event_idx` ON `hv_worker_requests` (`agent_id`, `subagent_id`, `event_key`);
+--> statement-breakpoint
+CREATE INDEX `hv_worker_requests_pending_idx` ON `hv_worker_requests` (`subagent_id`, `created_at`) WHERE `run_id` IS NULL AND `discarded_reason` IS NULL;
+
+--> statement-breakpoint
+CREATE TABLE hv_worker_subscriptions (
+  subagent_id text NOT NULL REFERENCES hv_subagents(id) ON DELETE CASCADE,
+  event_type text NOT NULL,
+  source_id text NOT NULL,
+  activated_at integer NOT NULL,
+  PRIMARY KEY (subagent_id, event_type, source_id)
+);
+--> statement-breakpoint
+CREATE VIEW hv_enabled_worker_subscriptions AS
+  SELECT s.id AS subagent_id, 'research' AS event_type, j.value AS source_id, s.updated_at AS activated_at
+  FROM hv_subagents s, json_each(s.triggers, '$.researchSources') j
+  WHERE s.enabled=1 AND s.archived=0 AND json_extract(s.triggers,'$.inboxEnabled')=1
+  UNION ALL
+  SELECT id, 'fill', '', updated_at FROM hv_subagents
+  WHERE enabled=1 AND archived=0 AND json_extract(triggers,'$.inboxEnabled')=1 AND json_extract(triggers,'$.fills')=1
+  UNION ALL
+  SELECT id, 'order_status', '', updated_at FROM hv_subagents
+  WHERE enabled=1 AND archived=0 AND json_extract(triggers,'$.inboxEnabled')=1 AND json_extract(triggers,'$.orderChanges')=1;
+--> statement-breakpoint
+INSERT INTO hv_worker_subscriptions SELECT * FROM hv_enabled_worker_subscriptions;
+--> statement-breakpoint
+CREATE TRIGGER hv_worker_subscriptions_insert AFTER INSERT ON hv_subagents BEGIN
+  INSERT INTO hv_worker_subscriptions SELECT * FROM hv_enabled_worker_subscriptions WHERE subagent_id=NEW.id;
+END;
+--> statement-breakpoint
+CREATE TRIGGER hv_worker_subscriptions_update AFTER UPDATE OF triggers, enabled, archived ON hv_subagents BEGIN
+  DELETE FROM hv_worker_subscriptions WHERE subagent_id=NEW.id AND NOT EXISTS (
+    SELECT 1 FROM hv_enabled_worker_subscriptions v WHERE v.subagent_id=NEW.id
+      AND v.event_type=hv_worker_subscriptions.event_type AND v.source_id=hv_worker_subscriptions.source_id
+  );
+  INSERT INTO hv_worker_subscriptions SELECT * FROM hv_enabled_worker_subscriptions WHERE subagent_id=NEW.id
+    AND NOT EXISTS (SELECT 1 FROM hv_worker_subscriptions old WHERE old.subagent_id=NEW.id
+      AND old.event_type=hv_enabled_worker_subscriptions.event_type AND old.source_id=hv_enabled_worker_subscriptions.source_id);
+END;

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));
+}