create-windy 0.6.11 → 0.6.14

package/template/packages/database/drizzle/meta/_journal.json

@@ -386,6 +386,55 @@
       "when": 1785963705804,
       "tag": "0054_tough_thanos",
       "breakpoints": true
+    },
+    {
+      "idx": 55,
+      "version": "7",
+      "when": 1787737413930,
+      "tag": "0055_square_yellowjacket",
+      "breakpoints": true
+    },
+    {
+      "idx": 56,
+      "version": "7",
+      "when": 1787739466125,
+      "tag": "0056_tricky_living_mummy",
+      "breakpoints": true
+    },
+    {
+      "idx": 57,
+      "version": "7",
+      "when": 1787758172139,
+      "tag": "0057_mature_doomsday",
+      "breakpoints": true
+    },
+    {
+      "idx": 58,
+      "version": "7",
+      "when": 1787762071896,
+      "tag": "0058_agent_session_memory",
+      "breakpoints": true
+    },
+    {
+      "idx": 59,
+      "version": "7",
+      "when": 1787764355854,
+      "tag": "0059_agent_source_module_key",
+      "breakpoints": true
+    },
+    {
+      "idx": 60,
+      "version": "7",
+      "when": 1787768932367,
+      "tag": "0060_slimy_rocket_raccoon",
+      "breakpoints": true
+    },
+    {
+      "idx": 61,
+      "version": "7",
+      "when": 1787795894000,
+      "tag": "0061_agent_workflow",
+      "breakpoints": true
     }
   ]
 }

package/template/packages/database/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/database",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {

package/template/packages/database/src/agent-runtime-schema.test.ts

@@ -9,6 +9,8 @@ import {
   agentRuntimeReportRuns,
   agentRuntimeEvents,
   agentRuntimeRuns,
+  clientAgentReceipts,
+  clientAgentSessions,
 } from "./schema/index.js";
 
 test("Agent Run 固定不可变 Release 并持久化恢复租约", async () => {
@@ -55,6 +57,14 @@ test("Agent Run 固定不可变 Release 并持久化恢复租约", async () => {
       (index) => index.config.name === "idx_agent_report_attempts_started",
     ),
   ).toBe(true);
+  expect(getTableConfig(clientAgentSessions).name).toBe(
+    "client_agent_sessions",
+  );
+  expect(clientAgentSessions.tokenHash.notNull).toBe(true);
+  expect(clientAgentSessions.hostSessionDigest.notNull).toBe(true);
+  expect(getTableConfig(clientAgentReceipts).name).toBe(
+    "client_agent_receipts",
+  );
 
   const migration = await Bun.file(
     new URL("../drizzle/0040_colossal_baron_strucker.sql", import.meta.url),
@@ -117,6 +127,22 @@ test("Agent Run 固定不可变 Release 并持久化恢复租约", async () => {
   expect(screenshotMigration).toContain(
     'CREATE TABLE "agent_screenshot_intakes"',
   );
+  const clientSessionMigration = await Bun.file(
+    new URL("../drizzle/0055_square_yellowjacket.sql", import.meta.url),
+  ).text();
+  expect(clientSessionMigration).toContain(
+    'CREATE TABLE "client_agent_sessions"',
+  );
+  expect(clientSessionMigration).toContain(
+    'CREATE TABLE "client_agent_receipts"',
+  );
+  expect(clientSessionMigration).not.toContain("prompt");
+  expect(clientSessionMigration).not.toContain("provider_key");
+  const hostBindingMigration = await Bun.file(
+    new URL("../drizzle/0056_tricky_living_mummy.sql", import.meta.url),
+  ).text();
+  expect(hostBindingMigration).toContain("host_session_digest");
+  expect(hostBindingMigration).not.toContain("provider_key");
   expect(screenshotMigration).toContain(
     'CREATE UNIQUE INDEX "uk_agent_screenshot_intakes_run"',
   );

package/template/packages/database/src/schema/agent-context-message.ts

@@ -0,0 +1,38 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  integer,
+  jsonb,
+  pgTable,
+  primaryKey,
+  text,
+  varchar,
+} from "drizzle-orm/pg-core";
+import { agentContextVersions } from "./agent-session.js";
+
+export const agentContextMessages = pgTable(
+  "agent_context_messages",
+  {
+    contextVersionId: varchar("context_version_id", { length: 96 })
+      .notNull()
+      .references(() => agentContextVersions.contextVersionId, {
+        onDelete: "cascade",
+      }),
+    ordinal: integer("ordinal").notNull(),
+    role: varchar("role", { length: 16 }).notNull(),
+    contentCipher: text("content_cipher").notNull(),
+    payloadDigest: varchar("payload_digest", { length: 71 }).notNull(),
+    contentDigest: varchar("content_digest", { length: 64 }).notNull(),
+    originsJson: jsonb("origins_json")
+      .$type<readonly Record<string, unknown>[]>()
+      .notNull(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.contextVersionId, table.ordinal] }),
+    check("ck_agent_context_messages_ordinal", sql`${table.ordinal} >= 0`),
+    check(
+      "ck_agent_context_messages_role",
+      sql`${table.role} in ('system', 'user', 'assistant', 'tool')`,
+    ),
+  ],
+);

package/template/packages/database/src/schema/agent-runtime.ts

@@ -38,6 +38,9 @@ export const agentRuntimeRuns = pgTable(
   "agent_runtime_runs",
   {
     runId: varchar("run_id", { length: 80 }).primaryKey(),
+    engineId: varchar("engine_id", { length: 80 })
+      .default("windy.direct.openai-compatible.v1")
+      .notNull(),
     operationKey: varchar("operation_key", { length: 200 }).notNull(),
     idempotencyKey: varchar("idempotency_key", { length: 200 }).notNull(),
     fingerprint: varchar("fingerprint", { length: 64 }).notNull(),
@@ -93,6 +96,9 @@ export const agentRuntimeReportRuns = pgTable(
   "agent_runtime_report_runs",
   {
     runId: varchar("run_id", { length: 80 }).primaryKey(),
+    engineId: varchar("engine_id", { length: 80 })
+      .default("windy.direct.openai-compatible.v1")
+      .notNull(),
     operationKey: varchar("operation_key", { length: 200 }).notNull(),
     releaseId: varchar("release_id", { length: 80 }).notNull(),
     traceId: varchar("trace_id", { length: 160 }).notNull(),
@@ -234,6 +240,7 @@ export const agentRunBindings = pgTable(
   {
     bindingId: varchar("binding_id", { length: 80 }).primaryKey(),
     runId: varchar("run_id", { length: 80 }),
+    sessionId: varchar("session_id", { length: 80 }),
     operationKey: varchar("operation_key", { length: 200 }).notNull(),
     actorId: varchar("actor_id", { length: 64 }).notNull(),
     idempotencyHash: varchar("idempotency_hash", { length: 64 }).notNull(),

package/template/packages/database/src/schema/agent-session-receipt.ts

@@ -0,0 +1,36 @@
+import {
+  check,
+  doublePrecision,
+  integer,
+  pgTable,
+  primaryKey,
+  varchar,
+} from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+import { agentSessions } from "./agent-session.js";
+
+export const agentSessionRunProjectionReceipts = pgTable(
+  "agent_session_run_projection_receipts",
+  {
+    sessionId: varchar("session_id", { length: 80 })
+      .notNull()
+      .references(() => agentSessions.sessionId, { onDelete: "cascade" }),
+    runId: varchar("run_id", { length: 160 }).notNull(),
+    terminalSequence: integer("terminal_sequence").notNull(),
+    resultDigest: varchar("result_digest", { length: 71 }).notNull(),
+    workingMemoryId: varchar("working_memory_id", { length: 96 }).notNull(),
+    summaryMemoryId: varchar("summary_memory_id", { length: 96 }).notNull(),
+    projectedAt: doublePrecision("projected_at").notNull(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.sessionId, table.runId] }),
+    check(
+      "ck_agent_session_run_projection_receipts_sequence",
+      sql`${table.terminalSequence} > 0`,
+    ),
+    check(
+      "ck_agent_session_run_projection_receipts_projected_at",
+      sql`${table.projectedAt} > 0`,
+    ),
+  ],
+);

package/template/packages/database/src/schema/agent-session.ts

@@ -0,0 +1,344 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  doublePrecision,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  primaryKey,
+  text,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+
+export const agentSessions = pgTable(
+  "agent_sessions",
+  {
+    sessionId: varchar("session_id", { length: 80 }).primaryKey(),
+    actorId: varchar("actor_id", { length: 64 }).notNull(),
+    scopeDigest: varchar("scope_digest", { length: 71 }).notNull(),
+    status: varchar("status", { length: 24 }).notNull(),
+    headSequence: integer("head_sequence").notNull().default(0),
+    parentSessionId: varchar("parent_session_id", { length: 80 }),
+    parentCheckpointId: varchar("parent_checkpoint_id", { length: 80 }),
+    parentSequence: integer("parent_sequence"),
+    createdAt: doublePrecision("created_at").notNull(),
+    updatedAt: doublePrecision("updated_at").notNull(),
+  },
+  (table) => [
+    index("idx_agent_sessions_actor_updated").on(
+      table.actorId,
+      table.updatedAt,
+    ),
+    index("idx_agent_sessions_parent").on(table.parentSessionId),
+    check(
+      "ck_agent_sessions_status",
+      sql`${table.status} in ('active', 'archived')`,
+    ),
+    check("ck_agent_sessions_head", sql`${table.headSequence} >= 0`),
+    check(
+      "ck_agent_sessions_lineage",
+      sql`(${table.parentSessionId} is null and ${table.parentCheckpointId} is null and ${table.parentSequence} is null)
+        or (${table.parentSessionId} is not null and ${table.parentCheckpointId} is not null and ${table.parentSequence} > 0)`,
+    ),
+  ],
+);
+
+export const agentSessionEvents = pgTable(
+  "agent_session_events",
+  {
+    eventId: varchar("event_id", { length: 96 }).primaryKey(),
+    sessionId: varchar("session_id", { length: 80 })
+      .notNull()
+      .references(() => agentSessions.sessionId, { onDelete: "cascade" }),
+    sequence: integer("sequence").notNull(),
+    eventType: varchar("event_type", { length: 80 }).notNull(),
+    schemaVersion: integer("schema_version").notNull(),
+    payloadCipher: text("payload_cipher").notNull(),
+    payloadDigest: varchar("payload_digest", { length: 71 }).notNull(),
+    occurredAt: doublePrecision("occurred_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_session_events_sequence").on(
+      table.sessionId,
+      table.sequence,
+    ),
+    index("idx_agent_session_events_type").on(
+      table.sessionId,
+      table.eventType,
+      table.sequence,
+    ),
+    check("ck_agent_session_events_sequence", sql`${table.sequence} > 0`),
+    check("ck_agent_session_events_schema", sql`${table.schemaVersion} > 0`),
+  ],
+);
+
+export const agentSessionCheckpoints = pgTable(
+  "agent_session_checkpoints",
+  {
+    checkpointId: varchar("checkpoint_id", { length: 96 }).primaryKey(),
+    sessionId: varchar("session_id", { length: 80 })
+      .notNull()
+      .references(() => agentSessions.sessionId, { onDelete: "cascade" }),
+    throughSequence: integer("through_sequence").notNull(),
+    factDigest: varchar("fact_digest", { length: 71 }).notNull(),
+    createdAt: doublePrecision("created_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_session_checkpoints_sequence").on(
+      table.sessionId,
+      table.throughSequence,
+    ),
+    check(
+      "ck_agent_session_checkpoints_sequence",
+      sql`${table.throughSequence} >= 0`,
+    ),
+  ],
+);
+
+export const agentContextVersions = pgTable(
+  "agent_context_versions",
+  {
+    contextVersionId: varchar("context_version_id", {
+      length: 96,
+    }).primaryKey(),
+    sessionId: varchar("session_id", { length: 80 })
+      .notNull()
+      .references(() => agentSessions.sessionId, { onDelete: "cascade" }),
+    turnId: varchar("turn_id", { length: 96 }).notNull(),
+    runId: varchar("run_id", { length: 160 }).notNull(),
+    modelAttemptId: varchar("model_attempt_id", { length: 160 }).notNull(),
+    currentCaseId: varchar("current_case_id", { length: 160 }),
+    digest: varchar("digest", { length: 71 }).notNull(),
+    providerDeploymentKey: varchar("provider_deployment_key", { length: 160 }),
+    providerModel: varchar("provider_model", { length: 160 }),
+    providerRequestDigest: varchar("provider_request_digest", { length: 64 }),
+    toolsDigest: varchar("tools_digest", { length: 64 }),
+    outputSchemaDigest: varchar("output_schema_digest", { length: 64 }),
+    committedAt: doublePrecision("committed_at"),
+    status: varchar("status", { length: 24 }).notNull().default("active"),
+    invalidatedAt: doublePrecision("invalidated_at"),
+    invalidationReason: varchar("invalidation_reason", { length: 32 }),
+    createdAt: doublePrecision("created_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_context_versions_attempt").on(table.modelAttemptId),
+    index("idx_agent_context_versions_session").on(
+      table.sessionId,
+      table.createdAt,
+    ),
+    check(
+      "ck_agent_context_versions_status",
+      sql`${table.status} in ('active', 'invalidated')`,
+    ),
+  ],
+);
+
+export const agentContextSources = pgTable(
+  "agent_context_sources",
+  {
+    contextVersionId: varchar("context_version_id", { length: 96 })
+      .notNull()
+      .references(() => agentContextVersions.contextVersionId, {
+        onDelete: "cascade",
+      }),
+    ordinal: integer("ordinal").notNull(),
+    sourceModuleKey: varchar("source_module_key", { length: 160 }).notNull(),
+    sourceKind: varchar("source_kind", { length: 48 }).notNull(),
+    sourceId: varchar("source_id", { length: 256 }).notNull(),
+    sourceVersion: varchar("source_version", { length: 160 }).notNull(),
+    sourceSequence: integer("source_sequence").notNull(),
+    sourceDigest: varchar("source_digest", { length: 71 }).notNull(),
+    validityStatus: varchar("validity_status", { length: 16 }).notNull(),
+    validityReason: varchar("validity_reason", { length: 32 }),
+    checkedAt: doublePrecision("checked_at").notNull(),
+    expiresAt: doublePrecision("expires_at"),
+  },
+  (table) => [
+    primaryKey({ columns: [table.contextVersionId, table.ordinal] }),
+    index("idx_agent_context_sources_origin").on(
+      table.sourceModuleKey,
+      table.sourceKind,
+      table.sourceId,
+      table.sourceVersion,
+    ),
+    check("ck_agent_context_sources_ordinal", sql`${table.ordinal} >= 0`),
+    check(
+      "ck_agent_context_sources_sequence",
+      sql`${table.sourceSequence} > 0`,
+    ),
+    check(
+      "ck_agent_context_sources_validity",
+      sql`${table.validityStatus} in ('valid', 'invalid')`,
+    ),
+  ],
+);
+
+export const agentMemoryProjections = pgTable(
+  "agent_memory_projections",
+  {
+    memoryId: varchar("memory_id", { length: 96 }).primaryKey(),
+    kind: varchar("kind", { length: 48 }).notNull(),
+    scopeKind: varchar("scope_kind", { length: 16 }).notNull(),
+    scopeId: varchar("scope_id", { length: 160 }).notNull(),
+    currentCaseId: varchar("current_case_id", { length: 160 }),
+    derivedFromSessionId: varchar("derived_from_session_id", {
+      length: 80,
+    }).notNull(),
+    derivedThroughSequence: integer("derived_through_sequence").notNull(),
+    payloadCipher: text("payload_cipher").notNull(),
+    payloadDigest: varchar("payload_digest", { length: 71 }).notNull(),
+    status: varchar("status", { length: 24 }).notNull().default("active"),
+    expiresAt: doublePrecision("expires_at"),
+    createdAt: doublePrecision("created_at").notNull(),
+    updatedAt: doublePrecision("updated_at").notNull(),
+  },
+  (table) => [
+    index("idx_agent_memory_scope").on(
+      table.scopeKind,
+      table.scopeId,
+      table.kind,
+      table.updatedAt,
+    ),
+    index("idx_agent_memory_expiry").on(table.status, table.expiresAt),
+    index("idx_agent_memory_derivation").on(
+      table.derivedFromSessionId,
+      table.status,
+    ),
+    check(
+      "ck_agent_memory_kind",
+      sql`${table.kind} in ('working-context', 'session-summary', 'user-preference', 'case-memory-candidate', 'verified-fact-reference')`,
+    ),
+    check(
+      "ck_agent_memory_scope",
+      sql`${table.scopeKind} in ('session', 'user', 'case')`,
+    ),
+    check(
+      "ck_agent_memory_status",
+      sql`${table.status} in ('active', 'invalidated', 'deleted')`,
+    ),
+    check(
+      "ck_agent_memory_derivation_sequence",
+      sql`${table.derivedThroughSequence} > 0`,
+    ),
+  ],
+);
+
+export const agentMemorySources = pgTable(
+  "agent_memory_sources",
+  {
+    memoryId: varchar("memory_id", { length: 96 })
+      .notNull()
+      .references(() => agentMemoryProjections.memoryId, {
+        onDelete: "cascade",
+      }),
+    ordinal: integer("ordinal").notNull(),
+    sourceModuleKey: varchar("source_module_key", { length: 160 }).notNull(),
+    sourceKind: varchar("source_kind", { length: 48 }).notNull(),
+    sourceId: varchar("source_id", { length: 256 }).notNull(),
+    sourceVersion: varchar("source_version", { length: 160 }).notNull(),
+    sourceSequence: integer("source_sequence").notNull(),
+    sourceDigest: varchar("source_digest", { length: 71 }).notNull(),
+    validityStatus: varchar("validity_status", { length: 16 }).notNull(),
+    validityReason: varchar("validity_reason", { length: 32 }),
+    checkedAt: doublePrecision("checked_at").notNull(),
+    expiresAt: doublePrecision("expires_at"),
+  },
+  (table) => [
+    primaryKey({ columns: [table.memoryId, table.ordinal] }),
+    index("idx_agent_memory_sources_origin").on(
+      table.sourceModuleKey,
+      table.sourceKind,
+      table.sourceId,
+      table.sourceVersion,
+    ),
+    check("ck_agent_memory_sources_ordinal", sql`${table.ordinal} >= 0`),
+    check("ck_agent_memory_sources_sequence", sql`${table.sourceSequence} > 0`),
+    check(
+      "ck_agent_memory_sources_validity",
+      sql`${table.validityStatus} in ('valid', 'invalid')`,
+    ),
+  ],
+);
+
+export const agentSourceInvalidations = pgTable(
+  "agent_source_invalidations",
+  {
+    invalidationId: varchar("invalidation_id", { length: 96 }).primaryKey(),
+    sourceModuleKey: varchar("source_module_key", { length: 160 }).notNull(),
+    sourceKind: varchar("source_kind", { length: 48 }).notNull(),
+    sourceId: varchar("source_id", { length: 256 }).notNull(),
+    sourceVersion: varchar("source_version", { length: 160 }).notNull(),
+    sequence: integer("sequence").notNull(),
+    sourceDigest: varchar("source_digest", { length: 71 }),
+    cause: varchar("cause", { length: 32 }).notNull(),
+    status: varchar("status", { length: 24 }).notNull().default("pending"),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    leaseOwner: varchar("lease_owner", { length: 96 }),
+    leaseUntil: doublePrecision("lease_until"),
+    payloadJson: jsonb("payload_json")
+      .$type<Record<string, unknown>>()
+      .notNull(),
+    occurredAt: doublePrecision("occurred_at").notNull(),
+    updatedAt: doublePrecision("updated_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_source_invalidations_sequence").on(
+      table.sourceModuleKey,
+      table.sourceKind,
+      table.sourceId,
+      table.sequence,
+    ),
+    index("idx_agent_source_invalidations_claim").on(
+      table.status,
+      table.leaseUntil,
+      table.occurredAt,
+    ),
+    check("ck_agent_source_invalidations_sequence", sql`${table.sequence} > 0`),
+    check(
+      "ck_agent_source_invalidations_cause",
+      sql`${table.cause} in ('authorization-revoked', 'source-deleted', 'source-archived', 'source-invalidated', 'source-expired', 'source-superseded')`,
+    ),
+    check(
+      "ck_agent_source_invalidations_status",
+      sql`${table.status} in ('pending', 'processing', 'completed', 'failed')`,
+    ),
+    check(
+      "ck_agent_source_invalidations_attempts",
+      sql`${table.attemptCount} >= 0`,
+    ),
+  ],
+);
+
+export const agentSourceInvalidationDeliveries = pgTable(
+  "agent_source_invalidation_deliveries",
+  {
+    invalidationId: varchar("invalidation_id", { length: 96 })
+      .notNull()
+      .references(() => agentSourceInvalidations.invalidationId, {
+        onDelete: "cascade",
+      }),
+    sinkKey: varchar("sink_key", { length: 48 }).notNull(),
+    status: varchar("status", { length: 24 }).notNull().default("pending"),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    leaseToken: varchar("lease_token", { length: 96 }),
+    leaseOwner: varchar("lease_owner", { length: 96 }),
+    leaseUntil: doublePrecision("lease_until"),
+    nextAttemptAt: doublePrecision("next_attempt_at").notNull(),
+    lastErrorCode: varchar("last_error_code", { length: 80 }),
+    deliveredAt: doublePrecision("delivered_at"),
+  },
+  (table) => [
+    primaryKey({ columns: [table.invalidationId, table.sinkKey] }),
+    index("idx_agent_source_delivery_retry").on(
+      table.status,
+      table.nextAttemptAt,
+    ),
+    check(
+      "ck_agent_source_delivery_status",
+      sql`${table.status} in ('pending', 'processing', 'delivered', 'rejected')`,
+    ),
+    check("ck_agent_source_delivery_attempts", sql`${table.attemptCount} >= 0`),
+  ],
+);

package/template/packages/database/src/schema/agent-workflow-delegation.ts

@@ -0,0 +1,126 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  doublePrecision,
+  foreignKey,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import type {
+  AgentDelegationGrant,
+  AgentWorkflowBudget,
+  AgentWorkflowUsage,
+} from "@southwind-ai/shared";
+import { agentWorkflowNodeRuns, agentWorkflowRuns } from "./agent-workflow.js";
+
+export const agentWorkflowDelegations = pgTable(
+  "agent_workflow_delegations",
+  {
+    delegationId: varchar("delegation_id", { length: 96 }).primaryKey(),
+    parentRunId: varchar("parent_run_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowRuns.runId, { onDelete: "restrict" }),
+    parentNodeId: varchar("parent_node_id", { length: 96 }).notNull(),
+    parentNodeRunId: varchar("parent_node_run_id", { length: 96 }).notNull(),
+    idempotencyKey: varchar("idempotency_key", { length: 220 }).notNull(),
+    childSessionId: varchar("child_session_id", { length: 80 }).notNull(),
+    childAgentRunId: varchar("child_agent_run_id", { length: 160 }),
+    grantJson: jsonb("grant_json").$type<AgentDelegationGrant>().notNull(),
+    status: varchar("status", { length: 24 }).notNull(),
+    createdAt: doublePrecision("created_at").notNull(),
+    updatedAt: doublePrecision("updated_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_delegation_node_run").on(
+      table.parentNodeRunId,
+    ),
+    uniqueIndex("uk_agent_workflow_delegation_idempotency").on(
+      table.idempotencyKey,
+    ),
+    uniqueIndex("uk_agent_workflow_delegation_coordinate").on(
+      table.delegationId,
+      table.parentRunId,
+      table.parentNodeRunId,
+    ),
+    index("idx_agent_workflow_delegation_child").on(table.childSessionId),
+    foreignKey({
+      columns: [table.parentNodeRunId, table.parentRunId],
+      foreignColumns: [
+        agentWorkflowNodeRuns.nodeRunId,
+        agentWorkflowNodeRuns.runId,
+      ],
+      name: "fk_agent_workflow_delegation_node_run",
+    }).onDelete("restrict"),
+    check(
+      "ck_agent_workflow_delegation_status",
+      sql`${table.status} in ('created', 'running', 'completed', 'failed', 'cancelled')`,
+    ),
+  ],
+);
+
+export const agentWorkflowBudgetReservations = pgTable(
+  "agent_workflow_budget_reservations",
+  {
+    reservationId: varchar("reservation_id", { length: 96 }).primaryKey(),
+    parentRunId: varchar("parent_run_id", { length: 96 }).notNull(),
+    parentNodeRunId: varchar("parent_node_run_id", { length: 96 }).notNull(),
+    delegationId: varchar("delegation_id", { length: 96 }).notNull(),
+    idempotencyKey: varchar("idempotency_key", { length: 220 }).notNull(),
+    authorizationProofId: varchar("authorization_proof_id", {
+      length: 160,
+    }).notNull(),
+    authorizationSnapshotDigest: varchar("authorization_snapshot_digest", {
+      length: 71,
+    }).notNull(),
+    runPolicyDigest: varchar("run_policy_digest", { length: 71 }).notNull(),
+    reservedJson: jsonb("reserved_json").$type<AgentWorkflowBudget>().notNull(),
+    consumedJson: jsonb("consumed_json").$type<AgentWorkflowUsage>().notNull(),
+    status: varchar("status", { length: 16 }).notNull(),
+    usageReceiptId: varchar("usage_receipt_id", { length: 96 }),
+    reasonCode: varchar("reason_code", { length: 80 }),
+    settledAt: doublePrecision("settled_at"),
+    version: integer("version").notNull().default(1),
+    createdAt: doublePrecision("created_at").notNull(),
+    updatedAt: doublePrecision("updated_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_budget_delegation").on(table.delegationId),
+    uniqueIndex("uk_agent_workflow_budget_idempotency").on(
+      table.idempotencyKey,
+    ),
+    uniqueIndex("uk_agent_workflow_budget_coordinate").on(
+      table.reservationId,
+      table.delegationId,
+      table.parentRunId,
+      table.parentNodeRunId,
+    ),
+    index("idx_agent_workflow_budget_parent").on(
+      table.parentRunId,
+      table.status,
+    ),
+    foreignKey({
+      columns: [table.delegationId, table.parentRunId, table.parentNodeRunId],
+      foreignColumns: [
+        agentWorkflowDelegations.delegationId,
+        agentWorkflowDelegations.parentRunId,
+        agentWorkflowDelegations.parentNodeRunId,
+      ],
+      name: "fk_agent_workflow_budget_delegation",
+    }).onDelete("restrict"),
+    check(
+      "ck_agent_workflow_budget_status",
+      sql`${table.status} in ('active', 'settled', 'released')`,
+    ),
+    check("ck_agent_workflow_budget_version", sql`${table.version} > 0`),
+    check(
+      "ck_agent_workflow_budget_terminal",
+      sql`(${table.status} = 'active' and ${table.usageReceiptId} is null and ${table.reasonCode} is null and ${table.settledAt} is null)
+        or (${table.status} = 'settled' and ${table.usageReceiptId} is not null and (${table.reasonCode} is null or ${table.reasonCode} in ('BUDGET_EXCEEDED', 'USAGE_UNKNOWN_OR_EXCEEDED')) and ${table.settledAt} is not null)
+        or (${table.status} = 'released' and ${table.usageReceiptId} is null and ${table.reasonCode} is not null and ${table.settledAt} is not null)`,
+    ),
+  ],
+);