@runuai/host 0.9.148 → 0.9.150

package/db/migrations/0024_task_env_mode.sql

@@ -0,0 +1,9 @@
+-- ADR-153: durable rollout fence for per-command project env delivery.
+-- Existing/null rows are interpreted as `baked`; new task-up writes `loader`
+-- before creating runtime resources, so recovery never launches a binary that
+-- is absent from an older container image.
+ALTER TABLE `uai_host_tasks` ADD `env_mode` text;
+--> statement-breakpoint
+-- Value-free declaration/literal metadata needed to rebuild the resolver
+-- after runner restart, before the cloud re-sends task-up.
+ALTER TABLE `uai_host_tasks` ADD `project_env_spec` text;

package/db/migrations/0025_project_env_authority.sql

@@ -0,0 +1,147 @@
+-- ADR-153: the owned runner's durable, value-free project-env authority.
+--
+-- This migration deliberately does not backfill host_project_env. An older
+-- runtime may keep writing that table after the migration lands but before
+-- the first bindings-v1 reconciliation. After its caller takes the capability
+-- floor, the first begin transaction snapshots the then-current rows and
+-- activates the permanent legacy-write journal below.
+CREATE TABLE `host_project_env_records` (
+	`project_id` text NOT NULL,
+	`key` text NOT NULL,
+	`revision` integer NOT NULL,
+	`generation` integer NOT NULL,
+	`tombstone` integer NOT NULL,
+	`binding_json` text,
+	`policy_epoch` integer,
+	`listing_generation` integer NOT NULL,
+	`updated_at` integer NOT NULL DEFAULT (unixepoch() * 1000),
+	PRIMARY KEY(`project_id`, `key`),
+	CONSTRAINT `host_project_env_records_head` CHECK (
+		(`tombstone` = 0 AND `revision` >= 1 AND `generation` >= 1) OR
+		(`tombstone` = 1 AND `revision` = 1 AND `generation` = 0) OR
+		(`tombstone` = 1 AND `revision` >= 2 AND `generation` >= 2)
+	),
+	CONSTRAINT `host_project_env_records_binding` CHECK (
+		(`generation` = 0 AND `binding_json` IS NULL AND `policy_epoch` IS NULL
+			AND `listing_generation` >= 2 AND (`listing_generation` % 2) = 0) OR
+		(`generation` > 0 AND `policy_epoch` >= 1)
+	),
+	CONSTRAINT `host_project_env_records_listing` CHECK (`listing_generation` >= 0),
+	CONSTRAINT `host_project_env_records_boolean` CHECK (`tombstone` IN (0, 1))
+);
+--> statement-breakpoint
+CREATE TABLE `host_project_env_projects` (
+	`project_id` text PRIMARY KEY NOT NULL,
+	`record_version` integer NOT NULL DEFAULT 0,
+	CONSTRAINT `host_project_env_projects_version` CHECK (`record_version` >= 0)
+);
+--> statement-breakpoint
+CREATE TABLE `host_project_env_authority` (
+	`id` text PRIMARY KEY NOT NULL DEFAULT 'host',
+	`activated` integer NOT NULL DEFAULT 0,
+	`gate_open` integer NOT NULL DEFAULT 1,
+	`stream_id` text,
+	`applied_sequence` integer NOT NULL DEFAULT 0,
+	`attempt_id` text,
+	`attempt_legacy_version` integer,
+	`legacy_version` integer NOT NULL DEFAULT 0,
+	`policy_epochs_json` text NOT NULL DEFAULT '[1]',
+	`modern_write` integer NOT NULL DEFAULT 0,
+	`updated_at` integer NOT NULL DEFAULT (unixepoch() * 1000),
+	CONSTRAINT `host_project_env_authority_singleton` CHECK (`id` = 'host'),
+	CONSTRAINT `host_project_env_authority_booleans` CHECK (
+		`activated` IN (0, 1) AND `gate_open` IN (0, 1) AND `modern_write` IN (0, 1)
+	),
+	CONSTRAINT `host_project_env_authority_cursor` CHECK (
+		`applied_sequence` >= 0 AND `legacy_version` >= 0 AND
+		(`attempt_legacy_version` IS NULL OR `attempt_legacy_version` >= 0)
+	),
+	CONSTRAINT `host_project_env_authority_stream` CHECK (
+		(`activated` = 0 AND `stream_id` IS NULL AND `applied_sequence` = 0 AND `attempt_id` IS NULL) OR
+		(`activated` = 1 AND `stream_id` IS NOT NULL)
+	),
+	CONSTRAINT `host_project_env_authority_attempt` CHECK (
+		(`attempt_id` IS NULL AND `attempt_legacy_version` IS NULL) OR
+		(`attempt_id` IS NOT NULL AND `attempt_legacy_version` IS NOT NULL AND `gate_open` = 0)
+	),
+	CONSTRAINT `host_project_env_authority_open` CHECK (`gate_open` = 0 OR `attempt_id` IS NULL)
+);
+--> statement-breakpoint
+INSERT INTO `host_project_env_authority` (`id`) VALUES ('host');
+--> statement-breakpoint
+CREATE TABLE `host_project_env_delivery_receipts` (
+	`stream_id` text NOT NULL,
+	`sequence` integer NOT NULL,
+	`request_kind` text NOT NULL,
+	`request_mac` text NOT NULL,
+	`ok` integer NOT NULL,
+	`state_json` text,
+	`record_version` integer,
+	`code` text,
+	`created_at` integer NOT NULL DEFAULT (unixepoch() * 1000),
+	PRIMARY KEY(`stream_id`, `sequence`),
+	CONSTRAINT `host_project_env_delivery_receipts_sequence` CHECK (`sequence` >= 1),
+	CONSTRAINT `host_project_env_delivery_receipts_boolean` CHECK (`ok` IN (0, 1)),
+	CONSTRAINT `host_project_env_delivery_receipts_outcome` CHECK (
+		(`ok` = 1 AND `code` IS NULL) OR (`ok` = 0 AND `code` IS NOT NULL)
+	),
+	CONSTRAINT `host_project_env_delivery_receipts_version` CHECK (
+		`record_version` IS NULL OR `record_version` >= 0
+	)
+);
+--> statement-breakpoint
+CREATE TABLE `host_project_env_legacy_journal` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`project_id` text NOT NULL,
+	`key` text NOT NULL,
+	`mutation` text NOT NULL,
+	`created_at` integer NOT NULL DEFAULT (unixepoch() * 1000),
+	CONSTRAINT `host_project_env_legacy_journal_mutation` CHECK (`mutation` IN ('set', 'delete'))
+);
+--> statement-breakpoint
+CREATE INDEX `host_project_env_legacy_journal_key_idx`
+	ON `host_project_env_legacy_journal` (`project_id`, `key`);
+--> statement-breakpoint
+-- These triggers are inert until the first modern reconciliation activates
+-- the authority. Afterwards, any old process that changes plaintext storage
+-- leaves durable evidence and closes the serving gate. Metadata-only updates
+-- do neither. Modern writes raise modern_write in their enclosing transaction.
+CREATE TRIGGER `host_project_env_legacy_insert`
+AFTER INSERT ON `host_project_env`
+WHEN (SELECT `activated` = 1 AND `modern_write` = 0
+	FROM `host_project_env_authority` WHERE `id` = 'host')
+BEGIN
+	INSERT INTO `host_project_env_legacy_journal` (`project_id`, `key`, `mutation`)
+	VALUES (NEW.`project_id`, NEW.`key`, 'set');
+	UPDATE `host_project_env_authority`
+	SET `gate_open` = 0, `legacy_version` = `legacy_version` + 1,
+		`updated_at` = unixepoch() * 1000
+	WHERE `id` = 'host';
+END;
+--> statement-breakpoint
+CREATE TRIGGER `host_project_env_legacy_update`
+AFTER UPDATE OF `value_enc` ON `host_project_env`
+WHEN OLD.`value_enc` IS NOT NEW.`value_enc`
+	AND (SELECT `activated` = 1 AND `modern_write` = 0
+		FROM `host_project_env_authority` WHERE `id` = 'host')
+BEGIN
+	INSERT INTO `host_project_env_legacy_journal` (`project_id`, `key`, `mutation`)
+	VALUES (NEW.`project_id`, NEW.`key`, 'set');
+	UPDATE `host_project_env_authority`
+	SET `gate_open` = 0, `legacy_version` = `legacy_version` + 1,
+		`updated_at` = unixepoch() * 1000
+	WHERE `id` = 'host';
+END;
+--> statement-breakpoint
+CREATE TRIGGER `host_project_env_legacy_delete`
+AFTER DELETE ON `host_project_env`
+WHEN (SELECT `activated` = 1 AND `modern_write` = 0
+	FROM `host_project_env_authority` WHERE `id` = 'host')
+BEGIN
+	INSERT INTO `host_project_env_legacy_journal` (`project_id`, `key`, `mutation`)
+	VALUES (OLD.`project_id`, OLD.`key`, 'delete');
+	UPDATE `host_project_env_authority`
+	SET `gate_open` = 0, `legacy_version` = `legacy_version` + 1,
+		`updated_at` = unixepoch() * 1000
+	WHERE `id` = 'host';
+END;

package/db/migrations/0026_project_env_replica.sql

@@ -0,0 +1,150 @@
+-- ADR-153: durable Uai Cloud task-machine project-env replica.
+--
+-- The live and staged views are separate from both one another and the owned
+-- runner authority. A page can therefore materialise values without making
+-- them visible, and commit can replace the complete task view atomically.
+CREATE TABLE `host_project_env_replica_authority` (
+	`id` text PRIMARY KEY NOT NULL DEFAULT 'replica',
+	`activated` integer NOT NULL DEFAULT 0,
+	`gate_open` integer NOT NULL DEFAULT 0,
+	`stream_id` text,
+	`applied_sequence` integer NOT NULL DEFAULT 0,
+	`attempt_id` text,
+	`org_id` text,
+	`policy_epochs_json` text NOT NULL DEFAULT '[1]',
+	`updated_at` integer NOT NULL DEFAULT (unixepoch() * 1000),
+	CONSTRAINT `host_project_env_replica_authority_singleton` CHECK (`id` = 'replica'),
+	CONSTRAINT `host_project_env_replica_authority_booleans` CHECK (`activated` IN (0, 1) AND `gate_open` IN (0, 1)),
+	CONSTRAINT `host_project_env_replica_authority_cursor` CHECK (`applied_sequence` >= 0),
+	CONSTRAINT `host_project_env_replica_authority_stream` CHECK (
+		(`activated` = 0 AND `stream_id` IS NULL AND `applied_sequence` = 0 AND `attempt_id` IS NULL AND `org_id` IS NULL AND `gate_open` = 0) OR
+		(`activated` = 1 AND `stream_id` IS NOT NULL AND `org_id` IS NOT NULL)
+	),
+	CONSTRAINT `host_project_env_replica_authority_gate` CHECK (`gate_open` = 0 OR `attempt_id` IS NULL)
+);
+--> statement-breakpoint
+INSERT INTO `host_project_env_replica_authority` (`id`) VALUES ('replica');
+--> statement-breakpoint
+CREATE TABLE `host_project_env_replica_projects` (
+	`project_id` text PRIMARY KEY NOT NULL,
+	`record_version` integer NOT NULL,
+	CONSTRAINT `host_project_env_replica_projects_version` CHECK (`record_version` >= 0)
+);
+--> statement-breakpoint
+CREATE TABLE `host_project_env_replica_records` (
+	`project_id` text NOT NULL,
+	`key` text NOT NULL,
+	`revision` integer NOT NULL,
+	`generation` integer NOT NULL,
+	`tombstone` integer NOT NULL,
+	`value_ref_json` text,
+	`binding_json` text,
+	`policy_epoch` integer,
+	`listing_generation` integer NOT NULL,
+	`materialization` text NOT NULL,
+	`materialization_reason` text,
+	`updated_at` integer NOT NULL DEFAULT (unixepoch() * 1000),
+	PRIMARY KEY(`project_id`, `key`),
+	CONSTRAINT `host_project_env_replica_records_head` CHECK (
+		(`tombstone` = 0 AND `revision` >= 1 AND `generation` >= 1 AND `value_ref_json` IS NOT NULL) OR
+		(`tombstone` = 1 AND `revision` = 1 AND `generation` = 0 AND `value_ref_json` IS NULL) OR
+		(`tombstone` = 1 AND `revision` >= 2 AND `generation` >= 2 AND `value_ref_json` IS NULL)
+	),
+	CONSTRAINT `host_project_env_replica_records_binding` CHECK (
+		(`generation` = 0 AND `binding_json` IS NULL AND `policy_epoch` IS NULL AND `listing_generation` >= 2 AND (`listing_generation` % 2) = 0) OR
+		(`generation` > 0 AND `policy_epoch` >= 1)
+	),
+	CONSTRAINT `host_project_env_replica_records_listing` CHECK (`listing_generation` >= 0),
+	CONSTRAINT `host_project_env_replica_records_boolean` CHECK (`tombstone` IN (0, 1)),
+	CONSTRAINT `host_project_env_replica_records_materialization` CHECK (
+		(`materialization` = 'installed' AND `tombstone` = 0 AND `materialization_reason` IS NULL) OR
+		(`materialization` IN ('withheld', 'unavailable') AND `materialization_reason` IS NOT NULL)
+	)
+);
+--> statement-breakpoint
+CREATE TABLE `host_project_env_replica_values` (
+	`project_id` text NOT NULL,
+	`key` text NOT NULL,
+	`revision` integer NOT NULL,
+	`generation` integer NOT NULL,
+	`value_ref_json` text NOT NULL,
+	`value_enc` text NOT NULL,
+	`updated_at` integer NOT NULL DEFAULT (unixepoch() * 1000),
+	PRIMARY KEY(`project_id`, `key`),
+	CONSTRAINT `host_project_env_replica_values_head` CHECK (`revision` >= 1 AND `generation` >= 1)
+);
+--> statement-breakpoint
+CREATE TABLE `host_project_env_replica_stage_projects` (
+	`attempt_id` text NOT NULL,
+	`project_id` text NOT NULL,
+	`record_version` integer,
+	`last_key` text,
+	`complete` integer NOT NULL DEFAULT 0,
+	PRIMARY KEY(`attempt_id`, `project_id`),
+	CONSTRAINT `host_project_env_replica_stage_projects_version` CHECK (`record_version` IS NULL OR `record_version` >= 0),
+	CONSTRAINT `host_project_env_replica_stage_projects_complete` CHECK (`complete` IN (0, 1))
+);
+--> statement-breakpoint
+CREATE TABLE `host_project_env_replica_stage_records` (
+	`attempt_id` text NOT NULL,
+	`project_id` text NOT NULL,
+	`key` text NOT NULL,
+	`revision` integer NOT NULL,
+	`generation` integer NOT NULL,
+	`tombstone` integer NOT NULL,
+	`value_ref_json` text,
+	`binding_json` text,
+	`policy_epoch` integer,
+	`listing_generation` integer NOT NULL,
+	`materialization` text NOT NULL,
+	`materialization_reason` text,
+	`updated_at` integer NOT NULL DEFAULT (unixepoch() * 1000),
+	`present` integer NOT NULL DEFAULT 0,
+	PRIMARY KEY(`attempt_id`, `project_id`, `key`),
+	CONSTRAINT `host_project_env_replica_stage_records_head` CHECK (
+		(`tombstone` = 0 AND `revision` >= 1 AND `generation` >= 1 AND `value_ref_json` IS NOT NULL) OR
+		(`tombstone` = 1 AND `revision` = 1 AND `generation` = 0 AND `value_ref_json` IS NULL) OR
+		(`tombstone` = 1 AND `revision` >= 2 AND `generation` >= 2 AND `value_ref_json` IS NULL)
+	),
+	CONSTRAINT `host_project_env_replica_stage_records_binding` CHECK (
+		(`generation` = 0 AND `binding_json` IS NULL AND `policy_epoch` IS NULL AND `listing_generation` >= 2 AND (`listing_generation` % 2) = 0) OR
+		(`generation` > 0 AND `policy_epoch` >= 1)
+	),
+	CONSTRAINT `host_project_env_replica_stage_records_listing` CHECK (`listing_generation` >= 0),
+	CONSTRAINT `host_project_env_replica_stage_records_boolean` CHECK (`tombstone` IN (0, 1) AND `present` IN (0, 1)),
+	CONSTRAINT `host_project_env_replica_stage_records_materialization` CHECK (
+		(`materialization` = 'installed' AND `tombstone` = 0 AND `materialization_reason` IS NULL) OR
+		(`materialization` IN ('withheld', 'unavailable') AND `materialization_reason` IS NOT NULL)
+	)
+);
+--> statement-breakpoint
+CREATE TABLE `host_project_env_replica_stage_values` (
+	`attempt_id` text NOT NULL,
+	`project_id` text NOT NULL,
+	`key` text NOT NULL,
+	`revision` integer NOT NULL,
+	`generation` integer NOT NULL,
+	`value_ref_json` text NOT NULL,
+	`value_enc` text NOT NULL,
+	`updated_at` integer NOT NULL DEFAULT (unixepoch() * 1000),
+	PRIMARY KEY(`attempt_id`, `project_id`, `key`),
+	CONSTRAINT `host_project_env_replica_stage_values_head` CHECK (`revision` >= 1 AND `generation` >= 1)
+);
+--> statement-breakpoint
+CREATE TABLE `host_project_env_replica_receipts` (
+	`stream_id` text NOT NULL,
+	`sequence` integer NOT NULL,
+	`request_mac` text NOT NULL,
+	`result_json` text,
+	`record_version` integer,
+	`ok` integer NOT NULL,
+	`code` text,
+	`created_at` integer NOT NULL DEFAULT (unixepoch() * 1000),
+	PRIMARY KEY(`stream_id`, `sequence`),
+	CONSTRAINT `host_project_env_replica_receipts_sequence` CHECK (`sequence` >= 1),
+	CONSTRAINT `host_project_env_replica_receipts_boolean` CHECK (`ok` IN (0, 1)),
+	CONSTRAINT `host_project_env_replica_receipts_outcome` CHECK (
+		(`ok` = 1 AND `result_json` IS NOT NULL AND `record_version` IS NOT NULL AND `code` IS NULL) OR
+		(`ok` = 0 AND `result_json` IS NULL AND `record_version` IS NULL AND `code` IS NOT NULL)
+	)
+);

package/db/migrations/meta/_journal.json

@@ -169,6 +169,27 @@
       "when": 1788900000005,
       "tag": "0023_project_env_org",
       "breakpoints": true
+    },
+    {
+      "idx": 24,
+      "version": "6",
+      "when": 1788900000006,
+      "tag": "0024_task_env_mode",
+      "breakpoints": true
+    },
+    {
+      "idx": 25,
+      "version": "6",
+      "when": 1788900000007,
+      "tag": "0025_project_env_authority",
+      "breakpoints": true
+    },
+    {
+      "idx": 26,
+      "version": "6",
+      "when": 1788900000008,
+      "tag": "0026_project_env_replica",
+      "breakpoints": true
     }
   ]
 }

package/db/schema.ts

@@ -29,6 +29,11 @@ export const hostTasks = sqliteTable(
     // Docker Compose only when their legacy runtime identity is complete.
     environmentProvider: text("environment_provider"),
     environmentLocator: text("environment_locator"),
+    // ADR-153 rollout fence. Null rows predate the loader and mean `baked`.
+    envMode: text("env_mode"),
+    // Value-free resolver metadata for rebuilding the project-env gateway
+    // after a runner restart, before the cloud re-sends task-up.
+    projectEnvSpec: text("project_env_spec"),
     statusMirror: text("status_mirror"),
     // Owner + project slugs — received in TaskLaunchInput at task-up and
     // persisted here so the local UI (ADR-028) can show "who/what" without a
@@ -37,8 +42,8 @@ export const hostTasks = sqliteTable(
     ownerEmail: text("owner_email"),
     ownerName: text("owner_name"),
     projectSlugs: text("project_slugs").notNull().default("[]"),
-    // Lead project first. Machine tasks resolve per-project env through these
-    // ids at every agent spawn (Docker tasks take env from compose instead).
+    // Lead project first. Retained for legacy/baked machine-task agent spawns;
+    // loader tasks resolve only declared names through projectEnvSpec.
     projectIds: text("project_ids").notNull().default("[]"),
     // ADR-131 D3: which engine-account scope this task resolves credentials
     // from ("org:<orgId>" on a shared host; null = "host"). Persisted so a
@@ -202,6 +207,311 @@ export const hostProjectEnv = sqliteTable(
 export type HostProjectEnv = typeof hostProjectEnv.$inferSelect;
 export type NewHostProjectEnv = typeof hostProjectEnv.$inferInsert;
 
+// ADR-153: value-free authority records live beside (not inside) the legacy
+// encrypted value row. A delete therefore keeps its binding/head forever,
+// while a live owned-runner head always refers to that row.
+export const hostProjectEnvRecords = sqliteTable(
+  "host_project_env_records",
+  {
+    projectId: text("project_id").notNull(),
+    key: text("key").notNull(),
+    revision: integer("revision").notNull(),
+    generation: integer("generation").notNull(),
+    tombstone: integer("tombstone", { mode: "boolean" }).notNull(),
+    bindingJson: text("binding_json"),
+    policyEpoch: integer("policy_epoch"),
+    listingGeneration: integer("listing_generation").notNull(),
+    updatedAt: integer("updated_at", { mode: "number" })
+      .notNull()
+      .default(sql`(unixepoch() * 1000)`),
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.projectId, t.key] }),
+  }),
+);
+
+export const hostProjectEnvProjects = sqliteTable("host_project_env_projects", {
+  projectId: text("project_id").primaryKey(),
+  recordVersion: integer("record_version").notNull().default(0),
+});
+
+// Singleton activation, serving gate and ordered-delivery cursor. `modernWrite`
+// is raised only inside a mutation transaction so the permanent legacy table
+// triggers can distinguish this build from an old process still writing it.
+export const hostProjectEnvAuthority = sqliteTable("host_project_env_authority", {
+  id: text("id").primaryKey().default("host"),
+  activated: integer("activated", { mode: "boolean" }).notNull().default(false),
+  gateOpen: integer("gate_open", { mode: "boolean" }).notNull().default(true),
+  streamId: text("stream_id"),
+  appliedSequence: integer("applied_sequence").notNull().default(0),
+  attemptId: text("attempt_id"),
+  attemptLegacyVersion: integer("attempt_legacy_version"),
+  legacyVersion: integer("legacy_version").notNull().default(0),
+  policyEpochsJson: text("policy_epochs_json").notNull().default("[1]"),
+  modernWrite: integer("modern_write", { mode: "boolean" }).notNull().default(false),
+  updatedAt: integer("updated_at", { mode: "number" })
+    .notNull()
+    .default(sql`(unixepoch() * 1000)`),
+});
+
+// A receipt contains a keyed request MAC and a value-free result. In
+// particular, a set's plaintext is never replayable from SQLite.
+export const hostProjectEnvDeliveryReceipts = sqliteTable(
+  "host_project_env_delivery_receipts",
+  {
+    streamId: text("stream_id").notNull(),
+    sequence: integer("sequence").notNull(),
+    requestKind: text("request_kind").notNull(),
+    requestMac: text("request_mac").notNull(),
+    ok: integer("ok", { mode: "boolean" }).notNull(),
+    stateJson: text("state_json"),
+    recordVersion: integer("record_version"),
+    code: text("code"),
+    createdAt: integer("created_at", { mode: "number" })
+      .notNull()
+      .default(sql`(unixepoch() * 1000)`),
+  },
+  (t) => ({ pk: primaryKey({ columns: [t.streamId, t.sequence] }) }),
+);
+
+export const hostProjectEnvLegacyJournal = sqliteTable(
+  "host_project_env_legacy_journal",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    projectId: text("project_id").notNull(),
+    key: text("key").notNull(),
+    mutation: text("mutation").notNull(),
+    createdAt: integer("created_at", { mode: "number" })
+      .notNull()
+      .default(sql`(unixepoch() * 1000)`),
+  },
+  (t) => ({ keyIdx: index("host_project_env_legacy_journal_key_idx").on(t.projectId, t.key) }),
+);
+
+// ADR-153 Uai Cloud task-machine replica. These tables are deliberately
+// separate from the owned-runner authority above: a sidecar stages a complete
+// task snapshot while serving nothing, then promotes it atomically. In
+// particular, materialising a cloud value must not fire the owned authority's
+// permanent legacy-write triggers.
+export const hostProjectEnvReplicaAuthority = sqliteTable(
+  "host_project_env_replica_authority",
+  {
+    id: text("id").primaryKey().default("replica"),
+    activated: integer("activated", { mode: "boolean" }).notNull().default(false),
+    gateOpen: integer("gate_open", { mode: "boolean" }).notNull().default(false),
+    streamId: text("stream_id"),
+    appliedSequence: integer("applied_sequence").notNull().default(0),
+    attemptId: text("attempt_id"),
+    orgId: text("org_id"),
+    policyEpochsJson: text("policy_epochs_json").notNull().default("[1]"),
+    updatedAt: integer("updated_at", { mode: "number" })
+      .notNull()
+      .default(sql`(unixepoch() * 1000)`),
+  },
+  (t) => ({
+    singleton: check("host_project_env_replica_authority_singleton", sql`${t.id} = 'replica'`),
+    booleans: check(
+      "host_project_env_replica_authority_booleans",
+      sql`${t.activated} IN (0, 1) AND ${t.gateOpen} IN (0, 1)`,
+    ),
+    cursor: check("host_project_env_replica_authority_cursor", sql`${t.appliedSequence} >= 0`),
+    stream: check(
+      "host_project_env_replica_authority_stream",
+      sql`(${t.activated} = 0 AND ${t.streamId} IS NULL AND ${t.appliedSequence} = 0 AND ${t.attemptId} IS NULL AND ${t.orgId} IS NULL AND ${t.gateOpen} = 0) OR (${t.activated} = 1 AND ${t.streamId} IS NOT NULL AND ${t.orgId} IS NOT NULL)`,
+    ),
+    gate: check(
+      "host_project_env_replica_authority_gate",
+      sql`${t.gateOpen} = 0 OR ${t.attemptId} IS NULL`,
+    ),
+  }),
+);
+
+export const hostProjectEnvReplicaProjects = sqliteTable(
+  "host_project_env_replica_projects",
+  {
+    projectId: text("project_id").primaryKey(),
+    recordVersion: integer("record_version").notNull(),
+  },
+  (t) => ({
+    version: check("host_project_env_replica_projects_version", sql`${t.recordVersion} >= 0`),
+  }),
+);
+
+const replicaRecordColumns = () => ({
+  projectId: text("project_id").notNull(),
+  key: text("key").notNull(),
+  revision: integer("revision").notNull(),
+  generation: integer("generation").notNull(),
+  tombstone: integer("tombstone", { mode: "boolean" }).notNull(),
+  valueRefJson: text("value_ref_json"),
+  bindingJson: text("binding_json"),
+  policyEpoch: integer("policy_epoch"),
+  listingGeneration: integer("listing_generation").notNull(),
+  materialization: text("materialization").notNull(),
+  materializationReason: text("materialization_reason"),
+  updatedAt: integer("updated_at", { mode: "number" })
+    .notNull()
+    .default(sql`(unixepoch() * 1000)`),
+});
+
+export const hostProjectEnvReplicaRecords = sqliteTable(
+  "host_project_env_replica_records",
+  replicaRecordColumns(),
+  (t) => ({
+    pk: primaryKey({ columns: [t.projectId, t.key] }),
+    head: check(
+      "host_project_env_replica_records_head",
+      sql`(${t.tombstone} = 0 AND ${t.revision} >= 1 AND ${t.generation} >= 1 AND ${t.valueRefJson} IS NOT NULL) OR (${t.tombstone} = 1 AND ${t.revision} = 1 AND ${t.generation} = 0 AND ${t.valueRefJson} IS NULL) OR (${t.tombstone} = 1 AND ${t.revision} >= 2 AND ${t.generation} >= 2 AND ${t.valueRefJson} IS NULL)`,
+    ),
+    binding: check(
+      "host_project_env_replica_records_binding",
+      sql`(${t.generation} = 0 AND ${t.bindingJson} IS NULL AND ${t.policyEpoch} IS NULL AND ${t.listingGeneration} >= 2 AND (${t.listingGeneration} % 2) = 0) OR (${t.generation} > 0 AND ${t.policyEpoch} >= 1)`,
+    ),
+    listing: check(
+      "host_project_env_replica_records_listing",
+      sql`${t.listingGeneration} >= 0`,
+    ),
+    boolean: check(
+      "host_project_env_replica_records_boolean",
+      sql`${t.tombstone} IN (0, 1)`,
+    ),
+    materialization: check(
+      "host_project_env_replica_records_materialization",
+      sql`(${t.materialization} = 'installed' AND ${t.tombstone} = 0 AND ${t.materializationReason} IS NULL) OR (${t.materialization} IN ('withheld', 'unavailable') AND ${t.materializationReason} IS NOT NULL)`,
+    ),
+  }),
+);
+
+export const hostProjectEnvReplicaValues = sqliteTable(
+  "host_project_env_replica_values",
+  {
+    projectId: text("project_id").notNull(),
+    key: text("key").notNull(),
+    revision: integer("revision").notNull(),
+    generation: integer("generation").notNull(),
+    valueRefJson: text("value_ref_json").notNull(),
+    valueEnc: text("value_enc").notNull(),
+    updatedAt: integer("updated_at", { mode: "number" })
+      .notNull()
+      .default(sql`(unixepoch() * 1000)`),
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.projectId, t.key] }),
+    head: check(
+      "host_project_env_replica_values_head",
+      sql`${t.revision} >= 1 AND ${t.generation} >= 1`,
+    ),
+  }),
+);
+
+export const hostProjectEnvReplicaStageProjects = sqliteTable(
+  "host_project_env_replica_stage_projects",
+  {
+    attemptId: text("attempt_id").notNull(),
+    projectId: text("project_id").notNull(),
+    recordVersion: integer("record_version"),
+    lastKey: text("last_key"),
+    complete: integer("complete", { mode: "boolean" }).notNull().default(false),
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.attemptId, t.projectId] }),
+    version: check(
+      "host_project_env_replica_stage_projects_version",
+      sql`${t.recordVersion} IS NULL OR ${t.recordVersion} >= 0`,
+    ),
+    completeBoolean: check(
+      "host_project_env_replica_stage_projects_complete",
+      sql`${t.complete} IN (0, 1)`,
+    ),
+  }),
+);
+
+export const hostProjectEnvReplicaStageRecords = sqliteTable(
+  "host_project_env_replica_stage_records",
+  {
+    attemptId: text("attempt_id").notNull(),
+    ...replicaRecordColumns(),
+    present: integer("present", { mode: "boolean" }).notNull().default(false),
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.attemptId, t.projectId, t.key] }),
+    head: check(
+      "host_project_env_replica_stage_records_head",
+      sql`(${t.tombstone} = 0 AND ${t.revision} >= 1 AND ${t.generation} >= 1 AND ${t.valueRefJson} IS NOT NULL) OR (${t.tombstone} = 1 AND ${t.revision} = 1 AND ${t.generation} = 0 AND ${t.valueRefJson} IS NULL) OR (${t.tombstone} = 1 AND ${t.revision} >= 2 AND ${t.generation} >= 2 AND ${t.valueRefJson} IS NULL)`,
+    ),
+    binding: check(
+      "host_project_env_replica_stage_records_binding",
+      sql`(${t.generation} = 0 AND ${t.bindingJson} IS NULL AND ${t.policyEpoch} IS NULL AND ${t.listingGeneration} >= 2 AND (${t.listingGeneration} % 2) = 0) OR (${t.generation} > 0 AND ${t.policyEpoch} >= 1)`,
+    ),
+    listing: check(
+      "host_project_env_replica_stage_records_listing",
+      sql`${t.listingGeneration} >= 0`,
+    ),
+    boolean: check(
+      "host_project_env_replica_stage_records_boolean",
+      sql`${t.tombstone} IN (0, 1) AND ${t.present} IN (0, 1)`,
+    ),
+    materialization: check(
+      "host_project_env_replica_stage_records_materialization",
+      sql`(${t.materialization} = 'installed' AND ${t.tombstone} = 0 AND ${t.materializationReason} IS NULL) OR (${t.materialization} IN ('withheld', 'unavailable') AND ${t.materializationReason} IS NOT NULL)`,
+    ),
+  }),
+);
+
+export const hostProjectEnvReplicaStageValues = sqliteTable(
+  "host_project_env_replica_stage_values",
+  {
+    attemptId: text("attempt_id").notNull(),
+    projectId: text("project_id").notNull(),
+    key: text("key").notNull(),
+    revision: integer("revision").notNull(),
+    generation: integer("generation").notNull(),
+    valueRefJson: text("value_ref_json").notNull(),
+    valueEnc: text("value_enc").notNull(),
+    updatedAt: integer("updated_at", { mode: "number" })
+      .notNull()
+      .default(sql`(unixepoch() * 1000)`),
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.attemptId, t.projectId, t.key] }),
+    head: check(
+      "host_project_env_replica_stage_values_head",
+      sql`${t.revision} >= 1 AND ${t.generation} >= 1`,
+    ),
+  }),
+);
+
+export const hostProjectEnvReplicaReceipts = sqliteTable(
+  "host_project_env_replica_receipts",
+  {
+    streamId: text("stream_id").notNull(),
+    sequence: integer("sequence").notNull(),
+    requestMac: text("request_mac").notNull(),
+    resultJson: text("result_json"),
+    recordVersion: integer("record_version"),
+    ok: integer("ok", { mode: "boolean" }).notNull(),
+    code: text("code"),
+    createdAt: integer("created_at", { mode: "number" })
+      .notNull()
+      .default(sql`(unixepoch() * 1000)`),
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.streamId, t.sequence] }),
+    sequenceCheck: check(
+      "host_project_env_replica_receipts_sequence",
+      sql`${t.sequence} >= 1`,
+    ),
+    booleanCheck: check(
+      "host_project_env_replica_receipts_boolean",
+      sql`${t.ok} IN (0, 1)`,
+    ),
+    outcome: check(
+      "host_project_env_replica_receipts_outcome",
+      sql`(${t.ok} = 1 AND ${t.resultJson} IS NOT NULL AND ${t.recordVersion} IS NOT NULL AND ${t.code} IS NULL) OR (${t.ok} = 0 AND ${t.resultJson} IS NULL AND ${t.recordVersion} IS NULL AND ${t.code} IS NOT NULL)`,
+    ),
+  }),
+);
+
 // User-authed MCP connections (ADR-057). One row per cloud connection id; all
 // secret material (static header, OAuth client secret, PKCE verifier, tokens)
 // is sealed with the host master key in single-column `ct.nonce` base64 form