@intx/db 0.2.2 → 0.3.0

package/dist/workflow-run-launch-spec-store.d.ts

@@ -0,0 +1,13 @@
+import type { DB, DBExecutor } from "./client.js";
+import { parseWorkflowRunLaunchSpecRow } from "./parse-row.js";
+import { workflowRunLaunchSpec } from "./schema/workflow-run-launch-spec.js";
+type DBHandle = DB["db"];
+type LaunchSpecInsert = typeof workflowRunLaunchSpec.$inferInsert;
+type ParsedLaunchSpec = ReturnType<typeof parseWorkflowRunLaunchSpecRow>;
+/** Store for immutable workflow recovery inputs keyed by anchor run. */
+export declare function createWorkflowRunLaunchSpecStore(db: DBHandle): {
+    create(row: LaunchSpecInsert, tx?: DBExecutor): Promise<ParsedLaunchSpec>;
+    get(anchorRunId: string, tx?: DBExecutor): Promise<ParsedLaunchSpec | null>;
+};
+export type WorkflowRunLaunchSpecStore = ReturnType<typeof createWorkflowRunLaunchSpecStore>;
+export {};

package/dist/workflow-run-launch-spec-store.js

@@ -0,0 +1,30 @@
+import { eq } from "drizzle-orm";
+import { parseWorkflowRunLaunchSpecRow } from "./parse-row.js";
+import { workflowRunLaunchSpec } from "./schema/workflow-run-launch-spec.js";
+/** Store for immutable workflow recovery inputs keyed by anchor run. */
+export function createWorkflowRunLaunchSpecStore(db) {
+    return {
+        async create(row, tx) {
+            parseWorkflowRunLaunchSpecRow({
+                ...row,
+                schemaVersion: row.schemaVersion ?? 1,
+                toolPackagePins: row.toolPackagePins ?? null,
+                createdAt: row.createdAt ?? new Date(),
+            });
+            const [inserted] = await (tx ?? db)
+                .insert(workflowRunLaunchSpec)
+                .values(row)
+                .returning();
+            if (inserted === undefined) {
+                throw new Error(`workflowRunLaunchSpecStore.create: insert returned no row for ${row.anchorRunId}`);
+            }
+            return parseWorkflowRunLaunchSpecRow(inserted);
+        },
+        async get(anchorRunId, tx) {
+            const row = await (tx ?? db).query.workflowRunLaunchSpec.findFirst({
+                where: eq(workflowRunLaunchSpec.anchorRunId, anchorRunId),
+            });
+            return row === undefined ? null : parseWorkflowRunLaunchSpecRow(row);
+        },
+    };
+}

package/dist/workflow-run-store.d.ts

@@ -0,0 +1,54 @@
+import type { DB, DBExecutor } from "./client.js";
+import { workflowRun } from "./schema/workflow-run.js";
+import { parseWorkflowRunRow } from "./parse-row.js";
+type DBHandle = DB["db"];
+type WorkflowRunInsert = typeof workflowRun.$inferInsert;
+type ParsedWorkflowRun = ReturnType<typeof parseWorkflowRunRow>;
+/**
+ * Store for the `workflow_run` table, the per-run authorization subject that
+ * approvals and signal correlations anchor to. Each method accepts an optional
+ * transaction handle so the run row can be written in the same transaction that
+ * co-writes the run's principal or its approval.
+ */
+export declare function createWorkflowRunStore(db: DBHandle): {
+    create(row: WorkflowRunInsert, tx?: DBExecutor): Promise<ParsedWorkflowRun>;
+    /**
+     * Idempotent variant of `create`. On an `id` primary-key conflict the
+     * insert is a no-op and this returns `null` rather than throwing, so a
+     * redelivered createIfAbsent (workflow-log replay, supervisor restart
+     * re-emitting) does not fail the run's co-write. Returns the parsed row
+     * only when this call performed the insert.
+     */
+    createIfAbsent(row: WorkflowRunInsert, tx?: DBExecutor): Promise<ParsedWorkflowRun | null>;
+    /**
+     * Anchor an externally-triggered run onto its deploy-time anchor row. The
+     * anchor is created at deploy (born "deployed" with a null principal); the
+     * first trigger reconciles it here, attaching `principalId` and flipping
+     * "deployed" -> "running" in one UPDATE. The insert is a conflict-tolerant
+     * safety net: the anchor provably exists by the time a trigger runs, so it
+     * normally no-ops. The three-part guard makes the reconcile single-shot and
+     * safe: `principalId IS NULL` never overwrites a principal a concurrent
+     * winner already set, and `status = 'deployed'` never resurrects a run a
+     * concurrent teardown already settled terminal (the null-principal guard
+     * alone would). `principalId` must be non-null: only the externally-
+     * triggered path anchors through here, and it always mints one.
+     */
+    anchorWithPrincipal(row: WorkflowRunInsert & {
+        principalId: string;
+    }, tx?: DBExecutor): Promise<void>;
+    /**
+     * Atomically settle a live run into a terminal state. The live-status guard
+     * (`status IN ('deployed','running')`) makes the flip single-shot: the first
+     * caller stamps the terminal status and `endedAt` and gets the row back; any
+     * later caller matches no row and receives null, so the run is not
+     * re-terminated and its `endedAt` is not overwritten. Accepting "deployed"
+     * settles a deployment torn down before its first trigger. This is a safety
+     * property, not a recovery path -- it makes a second call (a manual replay
+     * against an already-settled run) a harmless no-op; it does not by itself
+     * re-drive a flip that failed. Returns the parsed row only on the winning
+     * flip.
+     */
+    markTerminal(runId: string, status: "completed" | "failed" | "cancelled", endedAt: Date, tx?: DBExecutor): Promise<ParsedWorkflowRun | null>;
+};
+export type WorkflowRunStore = ReturnType<typeof createWorkflowRunStore>;
+export {};

package/dist/workflow-run-store.js

@@ -0,0 +1,85 @@
+import { and, eq, inArray, isNull } from "drizzle-orm";
+import { liveWorkflowRunStatuses, workflowRun } from "./schema/workflow-run.js";
+import { parseWorkflowRunRow } from "./parse-row.js";
+/**
+ * Store for the `workflow_run` table, the per-run authorization subject that
+ * approvals and signal correlations anchor to. Each method accepts an optional
+ * transaction handle so the run row can be written in the same transaction that
+ * co-writes the run's principal or its approval.
+ */
+export function createWorkflowRunStore(db) {
+    return {
+        async create(row, tx) {
+            const [inserted] = await (tx ?? db)
+                .insert(workflowRun)
+                .values(row)
+                .returning();
+            if (inserted === undefined) {
+                throw new Error(`workflowRunStore.create: insert returned no row for ${row.id}`);
+            }
+            return parseWorkflowRunRow(inserted);
+        },
+        /**
+         * Idempotent variant of `create`. On an `id` primary-key conflict the
+         * insert is a no-op and this returns `null` rather than throwing, so a
+         * redelivered createIfAbsent (workflow-log replay, supervisor restart
+         * re-emitting) does not fail the run's co-write. Returns the parsed row
+         * only when this call performed the insert.
+         */
+        async createIfAbsent(row, tx) {
+            const [inserted] = await (tx ?? db)
+                .insert(workflowRun)
+                .values(row)
+                .onConflictDoNothing({ target: workflowRun.id })
+                .returning();
+            return inserted === undefined ? null : parseWorkflowRunRow(inserted);
+        },
+        /**
+         * Anchor an externally-triggered run onto its deploy-time anchor row. The
+         * anchor is created at deploy (born "deployed" with a null principal); the
+         * first trigger reconciles it here, attaching `principalId` and flipping
+         * "deployed" -> "running" in one UPDATE. The insert is a conflict-tolerant
+         * safety net: the anchor provably exists by the time a trigger runs, so it
+         * normally no-ops. The three-part guard makes the reconcile single-shot and
+         * safe: `principalId IS NULL` never overwrites a principal a concurrent
+         * winner already set, and `status = 'deployed'` never resurrects a run a
+         * concurrent teardown already settled terminal (the null-principal guard
+         * alone would). `principalId` must be non-null: only the externally-
+         * triggered path anchors through here, and it always mints one.
+         */
+        async anchorWithPrincipal(row, tx) {
+            const executor = tx ?? db;
+            const [inserted] = await executor
+                .insert(workflowRun)
+                .values(row)
+                .onConflictDoNothing({ target: workflowRun.id })
+                .returning();
+            if (inserted !== undefined)
+                return;
+            await executor
+                .update(workflowRun)
+                .set({ principalId: row.principalId, status: "running" })
+                .where(and(eq(workflowRun.id, row.id), isNull(workflowRun.principalId), eq(workflowRun.status, "deployed")));
+        },
+        /**
+         * Atomically settle a live run into a terminal state. The live-status guard
+         * (`status IN ('deployed','running')`) makes the flip single-shot: the first
+         * caller stamps the terminal status and `endedAt` and gets the row back; any
+         * later caller matches no row and receives null, so the run is not
+         * re-terminated and its `endedAt` is not overwritten. Accepting "deployed"
+         * settles a deployment torn down before its first trigger. This is a safety
+         * property, not a recovery path -- it makes a second call (a manual replay
+         * against an already-settled run) a harmless no-op; it does not by itself
+         * re-drive a flip that failed. Returns the parsed row only on the winning
+         * flip.
+         */
+        async markTerminal(runId, status, endedAt, tx) {
+            const [updated] = await (tx ?? db)
+                .update(workflowRun)
+                .set({ status, endedAt })
+                .where(and(eq(workflowRun.id, runId), inArray(workflowRun.status, [...liveWorkflowRunStatuses])))
+                .returning();
+            return updated === undefined ? null : parseWorkflowRunRow(updated);
+        },
+    };
+}

package/migrations/0037_credential_use_backfill.sql

@@ -0,0 +1,39 @@
+-- Backfill `credential:{id}` / `use` grants for the owner of every existing
+-- personal credential (rows where `principal_id` is set) that does not already
+-- have one. This keeps existing personal-credential owners working once
+-- launch enforcement fails closed. Organizational credentials
+-- (`principal_id` IS NULL) are intentionally excluded: they remain gated
+-- behind tenant-owner role inheritance and explicit administrative grants.
+--
+-- Idempotent: the `WHERE NOT EXISTS` guard skips any credential whose owner
+-- already holds a matching grant, so re-application inserts nothing and does
+-- not fail. Grant ids reproduce the app convention (`grt_` prefix followed by
+-- 32 hex characters) via `gen_random_uuid()`.
+INSERT INTO "grant" (
+  "id",
+  "tenant_id",
+  "principal_id",
+  "resource",
+  "action",
+  "effect",
+  "origin",
+  "expires_at"
+)
+SELECT
+  'grt_' || replace(gen_random_uuid()::text, '-', ''),
+  c."tenant_id",
+  c."principal_id",
+  'credential:' || c."id",
+  'use',
+  'allow',
+  'creator',
+  NULL
+FROM "credential" c
+WHERE c."principal_id" IS NOT NULL
+  AND NOT EXISTS (
+    SELECT 1
+    FROM "grant" g
+    WHERE g."principal_id" = c."principal_id"
+      AND g."resource" = 'credential:' || c."id"
+      AND g."action" = 'use'
+  );

package/migrations/0038_chilly_blacklash.sql

@@ -0,0 +1,37 @@
+CREATE TABLE "approval" (
+	"id" text PRIMARY KEY NOT NULL,
+	"tenant_id" text NOT NULL,
+	"instance_id" text NOT NULL,
+	"agent_id" text NOT NULL,
+	"origin_principal_id" text NOT NULL,
+	"correlation_id" text NOT NULL,
+	"tool_definition" jsonb NOT NULL,
+	"tool_arguments" jsonb NOT NULL,
+	"scope" text,
+	"status" text DEFAULT 'pending' NOT NULL,
+	"origin_kind" text NOT NULL,
+	"timeout_at" timestamp NOT NULL,
+	"resolved_at" timestamp,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	"updated_at" timestamp DEFAULT now() NOT NULL,
+	CONSTRAINT "approval_correlation_id_unique" UNIQUE("correlation_id")
+);
+--> statement-breakpoint
+CREATE TABLE "signal_correlation" (
+	"correlation_id" text PRIMARY KEY NOT NULL,
+	"tenant_id" text NOT NULL,
+	"deployment_id" text NOT NULL,
+	"agent_address" text NOT NULL,
+	"run_id" text NOT NULL,
+	"signal_name" text NOT NULL,
+	"kind" text NOT NULL,
+	"signal_id" text,
+	"resolved_at" timestamp,
+	"created_at" timestamp DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "approval" ADD CONSTRAINT "approval_tenant_id_tenant_id_fk" FOREIGN KEY ("tenant_id") REFERENCES "public"."tenant"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "approval" ADD CONSTRAINT "approval_instance_id_agent_instance_id_fk" FOREIGN KEY ("instance_id") REFERENCES "public"."agent_instance"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "approval" ADD CONSTRAINT "approval_agent_id_agent_id_fk" FOREIGN KEY ("agent_id") REFERENCES "public"."agent"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "approval" ADD CONSTRAINT "approval_origin_principal_id_principal_id_fk" FOREIGN KEY ("origin_principal_id") REFERENCES "public"."principal"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "signal_correlation" ADD CONSTRAINT "signal_correlation_tenant_id_tenant_id_fk" FOREIGN KEY ("tenant_id") REFERENCES "public"."tenant"("id") ON DELETE cascade ON UPDATE no action;

package/migrations/0039_quick_carnage.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "approval" ALTER COLUMN "tool_definition" DROP NOT NULL;--> statement-breakpoint
+ALTER TABLE "approval" ALTER COLUMN "tool_arguments" DROP NOT NULL;

package/migrations/0040_reshape_approval_origin.sql

@@ -0,0 +1,24 @@
+-- Reshape `approval` so its origin is the workflow deployment it came from.
+-- The dropped instance/agent/origin-principal FKs had no valid referent: a
+-- workflow deployment has no agent_instance/agent row and its run principal is
+-- a substrate principal, not a `principal`-table row. The three added columns
+-- are NOT NULL with no default and no backfill; like the repo's other such
+-- adds (e.g. 0014, `workflow_deployment.address`), this relies on the table
+-- being empty when the migration runs. The table is unreleased -- the approval
+-- routes are 501 stubs -- so no populated row predates these columns.
+ALTER TABLE "approval" DROP CONSTRAINT "approval_instance_id_agent_instance_id_fk";
+--> statement-breakpoint
+ALTER TABLE "approval" DROP CONSTRAINT "approval_agent_id_agent_id_fk";
+--> statement-breakpoint
+ALTER TABLE "approval" DROP CONSTRAINT "approval_origin_principal_id_principal_id_fk";
+--> statement-breakpoint
+ALTER TABLE "approval" ADD COLUMN "deployment_id" text NOT NULL;--> statement-breakpoint
+ALTER TABLE "approval" ADD COLUMN "run_id" text NOT NULL;--> statement-breakpoint
+ALTER TABLE "approval" ADD COLUMN "agent_address" text NOT NULL;--> statement-breakpoint
+ALTER TABLE "approval" ADD CONSTRAINT "approval_deployment_id_workflow_deployment_id_fk" FOREIGN KEY ("deployment_id") REFERENCES "public"."workflow_deployment"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "approval_tenant_status_idx" ON "approval" USING btree ("tenant_id","status","created_at");--> statement-breakpoint
+CREATE INDEX "approval_deployment_idx" ON "approval" USING btree ("deployment_id");--> statement-breakpoint
+ALTER TABLE "approval" DROP COLUMN "instance_id";--> statement-breakpoint
+ALTER TABLE "approval" DROP COLUMN "agent_id";--> statement-breakpoint
+ALTER TABLE "approval" DROP COLUMN "origin_principal_id";--> statement-breakpoint
+ALTER TABLE "approval" DROP COLUMN "origin_kind";

package/migrations/0041_make_approval_timeout_at_nullable.sql

@@ -0,0 +1 @@
+ALTER TABLE "approval" ALTER COLUMN "timeout_at" DROP NOT NULL;

package/migrations/0042_youthful_mantis.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "approval" ALTER COLUMN "tool_definition" SET NOT NULL;--> statement-breakpoint
+ALTER TABLE "approval" ALTER COLUMN "tool_arguments" SET NOT NULL;

package/migrations/0043_signal_correlation_deployment_fk.sql

@@ -0,0 +1 @@
+ALTER TABLE "signal_correlation" ADD CONSTRAINT "signal_correlation_deployment_id_workflow_deployment_id_fk" FOREIGN KEY ("deployment_id") REFERENCES "public"."workflow_deployment"("id") ON DELETE cascade ON UPDATE no action;

package/migrations/0044_model_offering_quirks.sql

@@ -0,0 +1 @@
+ALTER TABLE "model_offering" ADD COLUMN "quirks" jsonb;

package/migrations/0045_create_workflow_run.sql

@@ -0,0 +1,13 @@
+CREATE TABLE "workflow_run" (
+	"id" text PRIMARY KEY NOT NULL,
+	"deployment_id" text NOT NULL,
+	"tenant_id" text NOT NULL,
+	"principal_id" text,
+	"status" text DEFAULT 'running' NOT NULL,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	"ended_at" timestamp
+);
+--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD CONSTRAINT "workflow_run_deployment_id_workflow_deployment_id_fk" FOREIGN KEY ("deployment_id") REFERENCES "public"."workflow_deployment"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD CONSTRAINT "workflow_run_tenant_id_tenant_id_fk" FOREIGN KEY ("tenant_id") REFERENCES "public"."tenant"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD CONSTRAINT "workflow_run_principal_id_principal_id_fk" FOREIGN KEY ("principal_id") REFERENCES "public"."principal"("id") ON DELETE set null ON UPDATE no action;

package/migrations/0046_approval_signal_correlation_run_fk.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "approval" ADD CONSTRAINT "approval_run_id_workflow_run_id_fk" FOREIGN KEY ("run_id") REFERENCES "public"."workflow_run"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "signal_correlation" ADD CONSTRAINT "signal_correlation_run_id_workflow_run_id_fk" FOREIGN KEY ("run_id") REFERENCES "public"."workflow_run"("id") ON DELETE cascade ON UPDATE no action;

package/migrations/0047_create_workflow_definition.sql

@@ -0,0 +1,30 @@
+CREATE TABLE "workflow_definition" (
+	"id" text PRIMARY KEY NOT NULL,
+	"tenant_id" text NOT NULL,
+	"creator_principal_id" text,
+	"asset_id" text,
+	"name" text NOT NULL,
+	"description" text,
+	"grant_requirements" jsonb,
+	"current_version" text DEFAULT '1' NOT NULL,
+	"status" text DEFAULT 'deployed' NOT NULL,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	"updated_at" timestamp DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "workflow_definition_version" (
+	"id" text PRIMARY KEY NOT NULL,
+	"definition_id" text NOT NULL,
+	"version" text NOT NULL,
+	"status" text DEFAULT 'active' NOT NULL,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	CONSTRAINT "workflow_definition_version_definition_version" UNIQUE("definition_id","version")
+);
+--> statement-breakpoint
+ALTER TABLE "workflow_definition" ADD CONSTRAINT "workflow_definition_tenant_id_tenant_id_fk" FOREIGN KEY ("tenant_id") REFERENCES "public"."tenant"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "workflow_definition" ADD CONSTRAINT "workflow_definition_creator_principal_id_principal_id_fk" FOREIGN KEY ("creator_principal_id") REFERENCES "public"."principal"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "workflow_definition" ADD CONSTRAINT "workflow_definition_asset_id_asset_id_fk" FOREIGN KEY ("asset_id") REFERENCES "public"."asset"("id") ON DELETE restrict ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "workflow_definition_version" ADD CONSTRAINT "workflow_definition_version_definition_id_workflow_definition_id_fk" FOREIGN KEY ("definition_id") REFERENCES "public"."workflow_definition"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "workflow_definition_tenant_idx" ON "workflow_definition" USING btree ("tenant_id","created_at");--> statement-breakpoint
+CREATE UNIQUE INDEX "workflow_definition_asset_idx" ON "workflow_definition" USING btree ("asset_id");--> statement-breakpoint
+CREATE INDEX "workflow_definition_version_definition_idx" ON "workflow_definition_version" USING btree ("definition_id");

package/migrations/0048_workflow_definition_origin_agent_id.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "workflow_definition" ADD COLUMN "origin_agent_id" text;--> statement-breakpoint
+CREATE INDEX "workflow_definition_origin_agent_idx" ON "workflow_definition" USING btree ("origin_agent_id");

package/migrations/0049_curly_omega_flight.sql

@@ -0,0 +1,2 @@
+DROP INDEX "workflow_definition_origin_agent_idx";--> statement-breakpoint
+CREATE UNIQUE INDEX "workflow_definition_origin_agent_idx" ON "workflow_definition" USING btree ("origin_agent_id") WHERE "workflow_definition"."origin_agent_id" is not null;

package/migrations/0050_late_crystal.sql

@@ -0,0 +1,10 @@
+ALTER TABLE "workflow_run" ALTER COLUMN "deployment_id" DROP NOT NULL;--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD COLUMN "definition_id" text;--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD COLUMN "address" text;--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD COLUMN "public_key" text;--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD COLUMN "sidecar_id" text;--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD COLUMN "kernel_id" text;--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD COLUMN "model_preferences" jsonb;--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD CONSTRAINT "workflow_run_definition_id_workflow_definition_id_fk" FOREIGN KEY ("definition_id") REFERENCES "public"."workflow_definition"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD CONSTRAINT "workflow_run_sidecar_id_sidecar_id_fk" FOREIGN KEY ("sidecar_id") REFERENCES "public"."sidecar"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "workflow_run_definition_idx" ON "workflow_run" USING btree ("definition_id");

package/migrations/0051_funny_madelyne_pryor.sql

@@ -0,0 +1 @@
+CREATE UNIQUE INDEX "workflow_run_address_idx" ON "workflow_run" USING btree ("address") WHERE "workflow_run"."address" is not null;

package/migrations/0052_drop_inference_turn_instance_fk.sql

@@ -0,0 +1 @@
+ALTER TABLE "inference_turn" DROP CONSTRAINT "inference_turn_instance_id_agent_instance_id_fk";

package/migrations/0053_session_mail_session_id_index.sql

@@ -0,0 +1 @@
+CREATE INDEX "session_mail_session_id_created_at_idx" ON "session_mail" USING btree ("session_id","created_at");

package/migrations/0054_rekey_instance_grants_to_workflow_run.sql

@@ -0,0 +1,10 @@
+-- Re-key run-scoped grants onto the folded workflow-run resource. A folded run
+-- shares the instance id space, so the rewrite is prefix-identity: the id after
+-- the colon is unchanged, only the type name moves instance: -> workflow-run:
+-- (carrying instance:* -> workflow-run:* too). The match is colon-delimited so
+-- it never touches the unrelated agent-state: grants; there is no instance-state
+-- sibling. Idempotent: after this runs no row matches instance:%, so a re-run is
+-- a no-op.
+UPDATE "grant"
+SET resource = 'workflow-run:' || substr(resource, length('instance:') + 1)
+WHERE resource LIKE 'instance:%';

package/migrations/0055_backfill_anchor_workflow_runs.sql

@@ -0,0 +1,69 @@
+-- Reconstruct an anchor workflow_run for every deployment that predates the
+-- runtime anchor insert. A deployment's routing address and reconnect key now
+-- live on its anchor run (the workflow_run whose id equals the deployment id),
+-- which new deploys create at runtime -- but deployments created earlier have a
+-- workflow_deployment row and no anchor run, so the reconnect key lookup finds
+-- no run for their address and their reconnect challenge fails closed. This
+-- copies the deployment's identity onto a fresh anchor run so those deployments
+-- reconnect exactly as ones deployed after the runtime anchor insert do.
+--
+-- A runtime-created anchor run also carries its definition -- deploy resolves
+-- and writes definition_id -- so a reconstructed one must too; an anchor run
+-- without a definition is only half the deployment's first-class stand-in. A
+-- definition_id resolves from the deployment's asset, which the workflow-asset
+-- fold populates. The guard below aborts the migration before it writes
+-- anything if any deployment still needing an anchor run has no folded
+-- definition, so the backfill reconstructs every anchor run completely or
+-- writes nothing and tells the operator to run the fold first. The production
+-- path applies migrations under `drizzle-kit migrate`, which wraps the pending
+-- set in a transaction, and PostgreSQL DDL is transactional, so an aborting
+-- guard rolls the whole set back -- there is no partial commit to re-run from
+-- the top, so the guard is simply a clear up-front precondition.
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1
+    FROM "workflow_deployment" wd
+    WHERE NOT EXISTS (
+        SELECT 1 FROM "workflow_run" r WHERE r.id = wd.id
+      )
+      AND NOT EXISTS (
+        SELECT 1 FROM "workflow_definition" wdef
+        WHERE wdef.asset_id = wd.definition_asset_id
+      )
+  ) THEN
+    RAISE EXCEPTION 'workflow-asset fold has not run: a deployment lacks a folded definition and its anchor run would be definition-less. The fold tooling has been retired; create the missing workflow_definition for the deployment asset by hand before applying this migration (see the agent-fold migration note in DEV.md).';
+  END IF;
+END $$;
+--> statement-breakpoint
+-- public_key is copied from the deployment (its old deploy-ack key) so the
+-- reconnect challenge resolves the same key it did before; created_at is copied
+-- so listing order is stable; status is the anchor's live value; definition_id
+-- resolves through the folded definition the guard above proved present. The
+-- remaining columns match a runtime anchor insert: no principal, no runtime
+-- bindings, not ended. NOT EXISTS on the id keeps it idempotent and skips
+-- deployments that already have a runtime-created anchor run.
+INSERT INTO "workflow_run" (
+  id,
+  tenant_id,
+  deployment_id,
+  definition_id,
+  address,
+  public_key,
+  status,
+  created_at
+)
+SELECT
+  wd.id,
+  wd.tenant_id,
+  wd.id,
+  wdef.id,
+  wd.address,
+  wd.public_key,
+  'running',
+  wd.created_at
+FROM "workflow_deployment" wd
+LEFT JOIN "workflow_definition" wdef ON wdef.asset_id = wd.definition_asset_id
+WHERE NOT EXISTS (
+  SELECT 1 FROM "workflow_run" r WHERE r.id = wd.id
+);

package/migrations/0056_repoint_deployment_fks_to_anchor_run.sql

@@ -0,0 +1,32 @@
+-- Re-point the three deployment_id foreign keys from the workflow_deployment
+-- projection onto the anchor run -- the workflow_run whose id equals the
+-- deployment id -- leaving the projection unreferenced. Every deployment_id
+-- value already equals an anchor run's id (migration 0055 backfilled one per
+-- deployment), so each re-pointed constraint validates on add; a deployment
+-- that somehow lacks its anchor run makes the ADD CONSTRAINT abort, a free
+-- integrity check.
+--
+-- First, fill definition_id on the runs the projection still anchors, so every
+-- run carries its definition -- the run anchors on the definition, not the
+-- deployment. A pre-existing non-anchor run -- a folded or child run created
+-- before this branch added the column -- has a null definition_id that only the
+-- deployment -> asset -> definition join can resolve; migration 0055 fills the
+-- anchor runs it inserts but never touches these existing rows, and
+-- workflow_deployment is the only place their mapping survives. asset_id is
+-- unique per definition, so the join matches at most one definition per run.
+UPDATE "workflow_run" r
+SET definition_id = wdef.id
+FROM "workflow_deployment" wd
+JOIN "workflow_definition" wdef ON wdef.asset_id = wd.definition_asset_id
+WHERE r.deployment_id = wd.id
+  AND r.definition_id IS NULL;
+--> statement-breakpoint
+ALTER TABLE "approval" DROP CONSTRAINT "approval_deployment_id_workflow_deployment_id_fk";
+--> statement-breakpoint
+ALTER TABLE "signal_correlation" DROP CONSTRAINT "signal_correlation_deployment_id_workflow_deployment_id_fk";
+--> statement-breakpoint
+ALTER TABLE "workflow_run" DROP CONSTRAINT "workflow_run_deployment_id_workflow_deployment_id_fk";
+--> statement-breakpoint
+ALTER TABLE "approval" ADD CONSTRAINT "approval_deployment_id_workflow_run_id_fk" FOREIGN KEY ("deployment_id") REFERENCES "public"."workflow_run"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "signal_correlation" ADD CONSTRAINT "signal_correlation_deployment_id_workflow_run_id_fk" FOREIGN KEY ("deployment_id") REFERENCES "public"."workflow_run"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "workflow_run" ADD CONSTRAINT "workflow_run_deployment_id_workflow_run_id_fk" FOREIGN KEY ("deployment_id") REFERENCES "public"."workflow_run"("id") ON DELETE cascade ON UPDATE no action;

package/migrations/0057_drop_workflow_deployment_projection.sql

@@ -0,0 +1,22 @@
+-- Drop the workflow_deployment projection. Its routing identity, reconnect key,
+-- and status now live on the anchor run, its foreign keys were re-pointed onto
+-- the anchor run, and nothing reads or writes it. This is irreversible.
+--
+-- Promote workflow_run.definition_id to NOT NULL: every run now carries a
+-- definition (set at birth for new runs, filled by 0056 for the rows the
+-- projection anchored). The guard below aborts before writing anything if any
+-- run is still null -- that means the workflow-asset fold has not run, and
+-- dropping the projection would strand those rows with no way to resolve their
+-- definition. A blunt IS NULL check catches every class, including a run with a
+-- null deployment_id the deployment join could never reach. Abort loudly so the
+-- operator runs the fold and retries.
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM "workflow_run" WHERE definition_id IS NULL) THEN
+    RAISE EXCEPTION 'workflow_run rows without a definition remain; run the workflow-asset fold (bin/db-backfill) before applying this migration';
+  END IF;
+END $$;
+--> statement-breakpoint
+ALTER TABLE "workflow_run" ALTER COLUMN "definition_id" SET NOT NULL;
+--> statement-breakpoint
+DROP TABLE "workflow_deployment";

package/migrations/0058_repoint_offering_fk_to_definition.sql

@@ -0,0 +1,41 @@
+-- Re-point the offering foreign key off the agent onto the folded workflow
+-- definition. The column keeps its agent_id name -- the offering API exposes
+-- agentId -- but its values become workflow_definition ids: every agent was
+-- folded to exactly one definition, linked by workflow_definition.origin_agent_id
+-- (a partial unique index, so the join matches at most one definition).
+--
+-- The guard runs before any write. The production path applies migrations under
+-- `drizzle-kit migrate`, which wraps the pending set in a transaction, and
+-- PostgreSQL DDL is transactional, so an aborting guard rolls the whole set
+-- back -- there is no partial commit to defend against. It aborts loudly if any
+-- offering's agent has no folded definition, meaning the agent fold has not
+-- run; the total fold makes that impossible in a folded database, so the guard
+-- is a fail-loud assertion.
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1
+    FROM "offering" o
+    WHERE NOT EXISTS (
+      SELECT 1 FROM "workflow_definition" wd
+      WHERE wd.origin_agent_id = o.agent_id
+    )
+  ) THEN
+    RAISE EXCEPTION 'offering(s) reference an agent with no folded definition; run the agent fold (bin/db-backfill) before applying this migration';
+  END IF;
+END $$;
+--> statement-breakpoint
+-- Drop the old agent foreign key BEFORE rewriting the values: the rewrite sets
+-- agent_id to a workflow_definition id, which is not an agent id, so it would
+-- violate the still-active agent FK. The offering table was renamed from
+-- `capability` (migration 0004); Postgres does not rename constraints on a
+-- table rename, so its agent FK still carries the original `capability_`-
+-- prefixed name, not the `offering_`-prefixed name drizzle's snapshot infers.
+ALTER TABLE "offering" DROP CONSTRAINT "capability_agent_id_agent_id_fk";
+--> statement-breakpoint
+UPDATE "offering" o
+SET agent_id = wd.id
+FROM "workflow_definition" wd
+WHERE wd.origin_agent_id = o.agent_id;
+--> statement-breakpoint
+ALTER TABLE "offering" ADD CONSTRAINT "offering_agent_id_workflow_definition_id_fk" FOREIGN KEY ("agent_id") REFERENCES "public"."workflow_definition"("id") ON DELETE restrict ON UPDATE no action;

package/migrations/0059_repoint_transaction_fk_to_run.sql

@@ -0,0 +1,10 @@
+-- Re-point the transaction ledger off the agent onto the run that incurs a
+-- charge. The table is unwritten (no producer), so there is no data to migrate
+-- and no contract to preserve: rename agent_id to run_id and reference
+-- workflow_run, keeping the nullable set-null delete so ledger history survives
+-- the deletion of the run it references.
+ALTER TABLE "transaction" RENAME COLUMN "agent_id" TO "run_id";
+--> statement-breakpoint
+ALTER TABLE "transaction" DROP CONSTRAINT "transaction_agent_id_agent_id_fk";
+--> statement-breakpoint
+ALTER TABLE "transaction" ADD CONSTRAINT "transaction_run_id_workflow_run_id_fk" FOREIGN KEY ("run_id") REFERENCES "public"."workflow_run"("id") ON DELETE set null ON UPDATE no action;

package/migrations/0060_drop_session_mail_instance_fk.sql

@@ -0,0 +1,6 @@
+-- Drop session_mail's foreign key to agent_instance. instance_id becomes a
+-- bare polymorphic column -- a legacy agent_instance id, or null for a folded
+-- run -- mirroring inference_turn.instance_id (migration 0052). A folded run's
+-- id comes from a shared id space that agent_instance does not contain, so no
+-- single-table foreign key spans both.
+ALTER TABLE "session_mail" DROP CONSTRAINT "session_mail_instance_id_agent_instance_id_fk";

package/migrations/0061_drop_session_asset_instance_fk.sql

@@ -0,0 +1,7 @@
+-- Drop session_asset's foreign key to agent_instance. instance_id becomes a
+-- bare polymorphic column -- a legacy agent_instance id or a folded run id --
+-- mirroring inference_turn.instance_id (migration 0052). A folded launch
+-- already writes its workflow_run id here, which the agent_instance FK rejected,
+-- so this also unblocks attaching assets to a folded run. instance_id stays NOT
+-- NULL and part of the (instance_id, mount_path) primary key.
+ALTER TABLE "session_asset" DROP CONSTRAINT "session_asset_instance_id_agent_instance_id_fk";

package/migrations/0062_drop_agent_asset_table.sql

@@ -0,0 +1,11 @@
+-- Drop the agent_asset table. Manual attach-to-an-agent was never wired,
+-- so the table has no writer and is empty, and the launch-time direct
+-- attachment path that read it is gone. session_asset's agent_asset_id
+-- foreign key and its source column only distinguished direct attachments
+-- from resolver-derived materializations; with the direct path gone every
+-- row is resolver-derived, so both are dead. Drop the two columns first --
+-- dropping agent_asset_id takes its foreign key with it -- so the table
+-- has no remaining dependents when it goes (no CASCADE needed).
+ALTER TABLE "session_asset" DROP COLUMN "agent_asset_id";--> statement-breakpoint
+ALTER TABLE "session_asset" DROP COLUMN "source";--> statement-breakpoint
+DROP TABLE "agent_asset";