create-windy 0.6.11 → 0.6.14

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

@@ -0,0 +1,213 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  doublePrecision,
+  foreignKey,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import type {
+  AgentWorkflowArtifactRef,
+  AgentWorkflowSideEffectCommand,
+  JsonValue,
+} from "@southwind-ai/shared";
+import { agentWorkflowNodeRuns, agentWorkflowRuns } from "./agent-workflow.js";
+import { agentWorkflowBudgetReservations } from "./agent-workflow-delegation.js";
+
+export const agentWorkflowSideEffectCommands = pgTable(
+  "agent_workflow_side_effect_commands",
+  {
+    commandId: varchar("command_id", { length: 96 }).primaryKey(),
+    runId: varchar("run_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowRuns.runId, { onDelete: "restrict" }),
+    nodeRunId: varchar("node_run_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowNodeRuns.nodeRunId, {
+        onDelete: "restrict",
+      }),
+    effectKind: varchar("effect_kind", { length: 24 })
+      .$type<AgentWorkflowSideEffectCommand["effectKind"]>()
+      .notNull(),
+    effectKey: varchar("effect_key", { length: 160 }).notNull(),
+    adapterKind: varchar("adapter_kind", { length: 32 }).notNull(),
+    adapterCoordinate: varchar("adapter_coordinate", { length: 220 }).notNull(),
+    idempotencyKey: varchar("idempotency_key", { length: 220 }).notNull(),
+    requestDigest: varchar("request_digest", { length: 71 }).notNull(),
+    generation: integer("generation").notNull().default(0),
+    fenceTokenDigest: varchar("fence_token_digest", { length: 71 }),
+    authorizationSnapshotDigest: varchar("authorization_snapshot_digest", {
+      length: 71,
+    }),
+    runPolicyDigest: varchar("run_policy_digest", { length: 71 }),
+    budgetReservationId: varchar("budget_reservation_id", { length: 96 }),
+    delegationId: varchar("delegation_id", { length: 96 }),
+    status: varchar("status", { length: 24 })
+      .$type<AgentWorkflowSideEffectCommand["status"]>()
+      .notNull(),
+    safeErrorCode: varchar("safe_error_code", { length: 80 }),
+    claimedAt: doublePrecision("claimed_at"),
+    committedAt: doublePrecision("committed_at"),
+    version: integer("version").notNull().default(1),
+    createdAt: doublePrecision("created_at").notNull(),
+    updatedAt: doublePrecision("updated_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_effect_idempotency").on(
+      table.idempotencyKey,
+    ),
+    uniqueIndex("uk_agent_workflow_effect_node_key").on(
+      table.nodeRunId,
+      table.effectKind,
+      table.effectKey,
+    ),
+    uniqueIndex("uk_agent_workflow_effect_receipt_coordinate").on(
+      table.commandId,
+      table.runId,
+      table.nodeRunId,
+      table.effectKind,
+      table.generation,
+      table.requestDigest,
+      table.fenceTokenDigest,
+    ),
+    index("idx_agent_workflow_effect_reconcile").on(
+      table.status,
+      table.updatedAt,
+    ),
+    check(
+      "ck_agent_workflow_effect_kind",
+      sql`${table.effectKind} in ('tool', 'approval', 'job', 'subagent')`,
+    ),
+    check(
+      "ck_agent_workflow_effect_adapter",
+      sql`(${table.effectKind} = 'tool' and ${table.adapterKind} = 'agent-tool')
+        or (${table.effectKind} = 'approval' and ${table.adapterKind} = 'approval-work-item')
+        or (${table.effectKind} = 'job' and ${table.adapterKind} = 'durable-job')
+        or (${table.effectKind} = 'subagent' and ${table.adapterKind} = 'child-agent')`,
+    ),
+    check(
+      "ck_agent_workflow_effect_budget",
+      sql`(${table.effectKind} = 'subagent' and ${table.budgetReservationId} is not null and ${table.delegationId} is not null)
+        or (${table.effectKind} <> 'subagent' and ${table.budgetReservationId} is null and ${table.delegationId} is null)`,
+    ),
+    foreignKey({
+      columns: [table.nodeRunId, table.runId],
+      foreignColumns: [
+        agentWorkflowNodeRuns.nodeRunId,
+        agentWorkflowNodeRuns.runId,
+      ],
+      name: "fk_agent_workflow_effect_node_run",
+    }).onDelete("restrict"),
+    foreignKey({
+      columns: [
+        table.budgetReservationId,
+        table.delegationId,
+        table.runId,
+        table.nodeRunId,
+      ],
+      foreignColumns: [
+        agentWorkflowBudgetReservations.reservationId,
+        agentWorkflowBudgetReservations.delegationId,
+        agentWorkflowBudgetReservations.parentRunId,
+        agentWorkflowBudgetReservations.parentNodeRunId,
+      ],
+      name: "fk_agent_workflow_effect_budget_reservation",
+    }).onDelete("restrict"),
+    check(
+      "ck_agent_workflow_effect_status",
+      sql`${table.status} in ('prepared', 'dispatched', 'cancellation-requested', 'committed', 'reconciled', 'cancelled', 'failed')`,
+    ),
+    check("ck_agent_workflow_effect_version", sql`${table.version} > 0`),
+    check("ck_agent_workflow_effect_generation", sql`${table.generation} >= 0`),
+    check(
+      "ck_agent_workflow_effect_fence",
+      sql`(${table.generation} = 0 and ${table.fenceTokenDigest} is null and ${table.authorizationSnapshotDigest} is null and ${table.runPolicyDigest} is null and ${table.claimedAt} is null)
+        or (${table.generation} > 0 and ${table.fenceTokenDigest} is not null and ${table.authorizationSnapshotDigest} is not null and ${table.runPolicyDigest} is not null and ${table.claimedAt} is not null)`,
+    ),
+    check(
+      "ck_agent_workflow_effect_committed_time",
+      sql`(${table.status} in ('committed', 'reconciled') and ${table.committedAt} is not null)
+        or (${table.status} in ('prepared', 'dispatched', 'cancellation-requested', 'cancelled', 'failed') and ${table.committedAt} is null)`,
+    ),
+  ],
+);
+
+export const agentWorkflowSideEffectReceipts = pgTable(
+  "agent_workflow_side_effect_receipts",
+  {
+    receiptId: varchar("receipt_id", { length: 96 }).primaryKey(),
+    commandId: varchar("command_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowSideEffectCommands.commandId, {
+        onDelete: "restrict",
+      }),
+    runId: varchar("run_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowRuns.runId, { onDelete: "restrict" }),
+    nodeRunId: varchar("node_run_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowNodeRuns.nodeRunId, {
+        onDelete: "restrict",
+      }),
+    effectKind: varchar("effect_kind", { length: 24 })
+      .$type<AgentWorkflowSideEffectCommand["effectKind"]>()
+      .notNull(),
+    generation: integer("generation").notNull(),
+    fenceTokenDigest: varchar("fence_token_digest", {
+      length: 71,
+    }).notNull(),
+    requestDigest: varchar("request_digest", { length: 71 }).notNull(),
+    externalReceiptId: varchar("external_receipt_id", {
+      length: 200,
+    }).notNull(),
+    resultDigest: varchar("result_digest", { length: 71 }).notNull(),
+    smallResultJson: jsonb("small_result_json").$type<JsonValue>(),
+    artifactRefsJson:
+      jsonb("artifact_refs_json").$type<readonly AgentWorkflowArtifactRef[]>(),
+    authorizationSnapshotDigest: varchar("authorization_snapshot_digest", {
+      length: 71,
+    }).notNull(),
+    runPolicyDigest: varchar("run_policy_digest", { length: 71 }).notNull(),
+    committedAt: doublePrecision("committed_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_effect_receipt_command").on(table.commandId),
+    index("idx_agent_workflow_effect_receipt_run").on(
+      table.runId,
+      table.committedAt,
+    ),
+    foreignKey({
+      columns: [
+        table.commandId,
+        table.runId,
+        table.nodeRunId,
+        table.effectKind,
+        table.generation,
+        table.requestDigest,
+        table.fenceTokenDigest,
+      ],
+      foreignColumns: [
+        agentWorkflowSideEffectCommands.commandId,
+        agentWorkflowSideEffectCommands.runId,
+        agentWorkflowSideEffectCommands.nodeRunId,
+        agentWorkflowSideEffectCommands.effectKind,
+        agentWorkflowSideEffectCommands.generation,
+        agentWorkflowSideEffectCommands.requestDigest,
+        agentWorkflowSideEffectCommands.fenceTokenDigest,
+      ],
+      name: "fk_agent_workflow_effect_receipt_command",
+    }).onDelete("restrict"),
+    check(
+      "ck_agent_workflow_effect_receipt_kind",
+      sql`${table.effectKind} in ('tool', 'approval', 'job', 'subagent')`,
+    ),
+    check(
+      "ck_agent_workflow_effect_receipt_generation",
+      sql`${table.generation} > 0`,
+    ),
+  ],
+);

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

@@ -0,0 +1,67 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  doublePrecision,
+  index,
+  jsonb,
+  pgTable,
+  text,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import type {
+  AgentWorkflowEvaluationArm,
+  AgentWorkflowEvaluationIdentity,
+} from "@southwind-ai/shared";
+
+export const agentWorkflowEvaluations = pgTable(
+  "agent_workflow_evaluations",
+  {
+    evaluationId: varchar("evaluation_id", { length: 96 }).primaryKey(),
+    tenantId: varchar("tenant_id", { length: 64 }).notNull(),
+    createdBy: varchar("created_by", { length: 64 }).notNull(),
+    evaluationSetKey: varchar("evaluation_set_key", { length: 160 }).notNull(),
+    evaluationSetVersion: varchar("evaluation_set_version", {
+      length: 80,
+    }).notNull(),
+    identityDigest: varchar("identity_digest", { length: 71 }).notNull(),
+    identityJson: jsonb("identity_json")
+      .$type<AgentWorkflowEvaluationIdentity>()
+      .notNull(),
+    singleArmJson: jsonb("single_arm_json")
+      .$type<AgentWorkflowEvaluationArm>()
+      .notNull(),
+    multiArmJson: jsonb("multi_arm_json")
+      .$type<AgentWorkflowEvaluationArm>()
+      .notNull(),
+    status: varchar("status", { length: 24 }).notNull(),
+    dispositionReason: text("disposition_reason"),
+    createdAt: doublePrecision("created_at").notNull(),
+    completedAt: doublePrecision("completed_at"),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_evaluation_identity").on(
+      table.tenantId,
+      table.createdBy,
+      table.evaluationSetKey,
+      table.evaluationSetVersion,
+      table.identityDigest,
+    ),
+    index("idx_agent_workflow_evaluation_created").on(table.createdAt),
+    index("idx_agent_workflow_evaluation_actor").on(
+      table.tenantId,
+      table.createdBy,
+      table.createdAt,
+    ),
+    check(
+      "ck_agent_workflow_evaluation_status",
+      sql`${table.status} in ('pending', 'completed', 'unavailable', 'non-comparable')`,
+    ),
+    check(
+      "ck_agent_workflow_evaluation_result",
+      sql`(${table.status} = 'pending' and ${table.completedAt} is null)
+        or (${table.status} = 'completed' and ${table.completedAt} is not null and ${table.dispositionReason} is null)
+        or (${table.status} in ('unavailable', 'non-comparable') and ${table.completedAt} is not null and ${table.dispositionReason} is not null)`,
+    ),
+  ],
+);

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

@@ -0,0 +1,270 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  doublePrecision,
+  foreignKey,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  primaryKey,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import type {
+  AgentWorkflowArtifactRef,
+  AgentWorkflowBudget,
+  AgentWorkflowDefinition,
+  AgentWorkflowInputReceipt,
+  AgentWorkflowNodeResultReceipt,
+  AgentWorkflowReleaseCoordinates,
+  AgentWorkflowUsage,
+  AgentWorkflowEventData,
+} from "@southwind-ai/shared";
+
+export const agentWorkflowDefinitions = pgTable(
+  "agent_workflow_definitions",
+  {
+    definitionId: varchar("definition_id", { length: 96 }).primaryKey(),
+    workflowKey: varchar("workflow_key", { length: 160 }).notNull(),
+    version: varchar("version", { length: 80 }).notNull(),
+    definitionDigest: varchar("definition_digest", { length: 71 }).notNull(),
+    definitionJson: jsonb("definition_json")
+      .$type<AgentWorkflowDefinition>()
+      .notNull(),
+    createdBy: varchar("created_by", { length: 64 }).notNull(),
+    createdAt: doublePrecision("created_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_definition_version").on(
+      table.workflowKey,
+      table.version,
+    ),
+    uniqueIndex("uk_agent_workflow_definition_digest").on(
+      table.workflowKey,
+      table.definitionDigest,
+    ),
+  ],
+);
+
+export const agentWorkflowReleases = pgTable(
+  "agent_workflow_releases",
+  {
+    releaseId: varchar("release_id", { length: 96 }).primaryKey(),
+    releaseDigest: varchar("release_digest", { length: 71 }).notNull(),
+    definitionId: varchar("definition_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowDefinitions.definitionId, {
+        onDelete: "restrict",
+      }),
+    definitionDigest: varchar("definition_digest", { length: 71 }).notNull(),
+    releaseJson: jsonb("release_json")
+      .$type<{
+        definition: AgentWorkflowDefinition;
+        coordinates: AgentWorkflowReleaseCoordinates;
+      }>()
+      .notNull(),
+    publishedBy: varchar("published_by", { length: 64 }).notNull(),
+    publishedAt: doublePrecision("published_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_release_definition").on(table.definitionId),
+    uniqueIndex("uk_agent_workflow_release_digest").on(table.releaseDigest),
+    index("idx_agent_workflow_release_published").on(table.publishedAt),
+  ],
+);
+
+export const agentWorkflowRuns = pgTable(
+  "agent_workflow_runs",
+  {
+    runId: varchar("run_id", { length: 96 }).primaryKey(),
+    releaseId: varchar("release_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowReleases.releaseId, {
+        onDelete: "restrict",
+      }),
+    idempotencyKey: varchar("idempotency_key", { length: 200 }).notNull(),
+    tenantId: varchar("tenant_id", { length: 64 }).notNull(),
+    actorId: varchar("actor_id", { length: 64 }).notNull(),
+    routeKey: varchar("route_key", { length: 160 }).notNull(),
+    inputDigest: varchar("input_digest", { length: 71 }).notNull(),
+    inputReceiptJson: jsonb("input_receipt_json")
+      .$type<AgentWorkflowInputReceipt>()
+      .notNull(),
+    scopeDigest: varchar("scope_digest", { length: 71 }).notNull(),
+    authorizationSnapshotDigest: varchar("authorization_snapshot_digest", {
+      length: 71,
+    }).notNull(),
+    toolPolicyDigest: varchar("tool_policy_digest", { length: 71 }).notNull(),
+    workspacePolicyDigest: varchar("workspace_policy_digest", {
+      length: 71,
+    }).notNull(),
+    executionPolicyDigest: varchar("execution_policy_digest", {
+      length: 71,
+    }).notNull(),
+    sessionId: varchar("session_id", { length: 80 }),
+    parentRunId: varchar("parent_run_id", { length: 96 }),
+    parentNodeId: varchar("parent_node_id", { length: 96 }),
+    parentNodeRunId: varchar("parent_node_run_id", { length: 96 }),
+    status: varchar("status", { length: 24 }).notNull(),
+    budgetJson: jsonb("budget_json").$type<AgentWorkflowBudget>().notNull(),
+    usageJson: jsonb("usage_json").$type<AgentWorkflowUsage>().notNull(),
+    deadlineAt: doublePrecision("deadline_at").notNull(),
+    cancellationRequestedAt: doublePrecision("cancellation_requested_at"),
+    safeErrorCode: varchar("safe_error_code", { length: 80 }),
+    recoveryCount: integer("recovery_count").notNull().default(0),
+    version: integer("version").notNull().default(1),
+    createdAt: doublePrecision("created_at").notNull(),
+    updatedAt: doublePrecision("updated_at").notNull(),
+    finishedAt: doublePrecision("finished_at"),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_run_idempotency").on(
+      table.tenantId,
+      table.actorId,
+      table.releaseId,
+      table.routeKey,
+      table.inputDigest,
+      table.idempotencyKey,
+    ),
+    index("idx_agent_workflow_run_actor").on(table.actorId, table.createdAt),
+    index("idx_agent_workflow_run_recovery").on(table.status, table.updatedAt),
+    index("idx_agent_workflow_run_parent").on(table.parentRunId),
+    check(
+      "ck_agent_workflow_run_status",
+      sql`${table.status} in ('accepted', 'running', 'waiting', 'completed', 'failed', 'cancelled', 'timed-out')`,
+    ),
+    check("ck_agent_workflow_run_version", sql`${table.version} > 0`),
+    check(
+      "ck_agent_workflow_run_recovery_count",
+      sql`${table.recoveryCount} >= 0`,
+    ),
+    check(
+      "ck_agent_workflow_run_parent",
+      sql`(${table.parentRunId} is null and ${table.parentNodeId} is null and ${table.parentNodeRunId} is null) or (${table.parentRunId} is not null and ${table.parentNodeId} is not null and ${table.parentNodeRunId} is not null)`,
+    ),
+    check(
+      "ck_agent_workflow_run_terminal_time",
+      sql`(${table.status} in ('completed', 'failed', 'cancelled', 'timed-out') and ${table.finishedAt} is not null) or (${table.status} in ('accepted', 'running', 'waiting') and ${table.finishedAt} is null)`,
+    ),
+    check(
+      "ck_agent_workflow_run_time_order",
+      sql`${table.createdAt} <= ${table.updatedAt} and ${table.deadlineAt} >= ${table.createdAt}
+        and (${table.cancellationRequestedAt} is null or (${table.cancellationRequestedAt} >= ${table.createdAt} and ${table.cancellationRequestedAt} <= ${table.updatedAt}))
+        and (${table.finishedAt} is null or (${table.finishedAt} >= ${table.createdAt} and ${table.finishedAt} <= ${table.updatedAt}))`,
+    ),
+  ],
+);
+
+export const agentWorkflowNodeRuns = pgTable(
+  "agent_workflow_node_runs",
+  {
+    nodeRunId: varchar("node_run_id", { length: 96 }).primaryKey(),
+    runId: varchar("run_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowRuns.runId, { onDelete: "restrict" }),
+    nodeId: varchar("node_id", { length: 96 }).notNull(),
+    previousNodeRunId: varchar("previous_node_run_id", { length: 96 }),
+    nodeType: varchar("node_type", { length: 24 }).notNull(),
+    status: varchar("status", { length: 24 }).notNull(),
+    attempt: integer("attempt").notNull().default(0),
+    maxAttempts: integer("max_attempts").notNull(),
+    idempotencyKey: varchar("idempotency_key", { length: 220 }).notNull(),
+    adapterKind: varchar("adapter_kind", { length: 32 }),
+    adapterCoordinate: varchar("adapter_coordinate", { length: 220 }),
+    inputArtifactsJson: jsonb("input_artifacts_json")
+      .$type<readonly AgentWorkflowArtifactRef[]>()
+      .notNull(),
+    outputArtifactsJson: jsonb("output_artifacts_json")
+      .$type<readonly AgentWorkflowArtifactRef[]>()
+      .notNull(),
+    resultReceiptJson: jsonb(
+      "result_receipt_json",
+    ).$type<AgentWorkflowNodeResultReceipt>(),
+    safeErrorCode: varchar("safe_error_code", { length: 80 }),
+    createdAt: doublePrecision("created_at").notNull(),
+    updatedAt: doublePrecision("updated_at").notNull(),
+    startedAt: doublePrecision("started_at"),
+    finishedAt: doublePrecision("finished_at"),
+    version: integer("version").notNull().default(1),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_node_attempt").on(
+      table.runId,
+      table.nodeId,
+      table.attempt,
+    ),
+    uniqueIndex("uk_agent_workflow_node_idempotency").on(table.idempotencyKey),
+    uniqueIndex("uk_agent_workflow_node_coordinate").on(
+      table.nodeRunId,
+      table.runId,
+    ),
+    index("idx_agent_workflow_node_status").on(table.runId, table.status),
+    foreignKey({
+      columns: [table.previousNodeRunId, table.runId],
+      foreignColumns: [table.nodeRunId, table.runId],
+      name: "fk_agent_workflow_node_previous_attempt",
+    }).onDelete("restrict"),
+    check(
+      "ck_agent_workflow_node_type",
+      sql`${table.nodeType} in ('model', 'tool', 'subagent', 'condition', 'parallel', 'join', 'approval', 'job', 'wait', 'artifact', 'final')`,
+    ),
+    check(
+      "ck_agent_workflow_node_status",
+      sql`${table.status} in ('pending', 'ready', 'running', 'waiting', 'retry-scheduled', 'completed', 'failed', 'cancelled', 'skipped', 'timed-out')`,
+    ),
+    check(
+      "ck_agent_workflow_node_attempts",
+      sql`${table.attempt} > 0 and ${table.maxAttempts} > 0 and ${table.attempt} <= ${table.maxAttempts}`,
+    ),
+    check(
+      "ck_agent_workflow_node_previous_attempt",
+      sql`(${table.attempt} = 1 and ${table.previousNodeRunId} is null) or (${table.attempt} > 1 and ${table.previousNodeRunId} is not null)`,
+    ),
+    check("ck_agent_workflow_node_version", sql`${table.version} > 0`),
+    check(
+      "ck_agent_workflow_node_terminal_time",
+      sql`(${table.status} in ('completed', 'failed', 'cancelled', 'skipped', 'timed-out', 'retry-scheduled') and ${table.finishedAt} is not null) or (${table.status} in ('pending', 'ready', 'running', 'waiting') and ${table.finishedAt} is null)`,
+    ),
+    check(
+      "ck_agent_workflow_node_time_order",
+      sql`${table.createdAt} <= ${table.updatedAt}
+        and (${table.startedAt} is null or (${table.startedAt} >= ${table.createdAt} and ${table.startedAt} <= ${table.updatedAt}))
+        and (${table.finishedAt} is null or (${table.finishedAt} >= coalesce(${table.startedAt}, ${table.createdAt}) and ${table.finishedAt} <= ${table.updatedAt}))`,
+    ),
+    check(
+      "ck_agent_workflow_node_result_receipt",
+      sql`${table.status} <> 'completed' or ${table.resultReceiptJson} is not null`,
+    ),
+    check(
+      "ck_agent_workflow_node_adapter",
+      sql`(${table.adapterKind} is null and ${table.adapterCoordinate} is null) or (${table.adapterKind} in ('model-operation', 'agent-tool', 'child-agent', 'approval-work-item', 'durable-job', 'wait-signal', 'artifact-store', 'finalizer') and ${table.adapterCoordinate} is not null)`,
+    ),
+  ],
+);
+
+export const agentWorkflowEvents = pgTable(
+  "agent_workflow_events",
+  {
+    eventId: varchar("event_id", { length: 96 }).notNull(),
+    runId: varchar("run_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowRuns.runId, { onDelete: "restrict" }),
+    sequence: integer("sequence").notNull(),
+    eventType: varchar("event_type", { length: 80 }).notNull(),
+    parentEventId: varchar("parent_event_id", { length: 96 }),
+    causationEventId: varchar("causation_event_id", { length: 96 }),
+    childWorkflowRunId: varchar("child_workflow_run_id", { length: 96 }),
+    payloadJson: jsonb("payload_json")
+      .$type<AgentWorkflowEventData>()
+      .notNull(),
+    occurredAt: doublePrecision("occurred_at").notNull(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.runId, table.sequence] }),
+    uniqueIndex("uk_agent_workflow_event_id").on(table.eventId),
+    index("idx_agent_workflow_event_parent").on(table.parentEventId),
+    index("idx_agent_workflow_event_causation").on(table.causationEventId),
+    check("ck_agent_workflow_event_sequence", sql`${table.sequence} > 0`),
+  ],
+);

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

@@ -0,0 +1,95 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  doublePrecision,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+
+export const clientAgentSessions = pgTable(
+  "client_agent_sessions",
+  {
+    sessionId: varchar("session_id", { length: 80 }).primaryKey(),
+    clientRunId: varchar("client_run_id", { length: 80 }).notNull(),
+    actorId: varchar("actor_id", { length: 64 }).notNull(),
+    operationKey: varchar("operation_key", { length: 200 }).notNull(),
+    releaseId: varchar("release_id", { length: 80 }).notNull(),
+    tokenHash: varchar("token_hash", { length: 71 }).notNull(),
+    clientBindingDigest: varchar("client_binding_digest", {
+      length: 71,
+    }).notNull(),
+    hostSessionDigest: varchar("host_session_digest", {
+      length: 71,
+    }).notNull(),
+    modelAlias: varchar("model_alias", { length: 80 }).notNull(),
+    status: varchar("status", { length: 24 }).notNull(),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    activeRequests: integer("active_requests").notNull().default(0),
+    pendingAttempts: jsonb("pending_attempts").$type<number[]>().notNull(),
+    admissionJson: jsonb("admission_json")
+      .$type<Record<string, unknown>>()
+      .notNull(),
+    terminalDigest: varchar("terminal_digest", { length: 71 }),
+    finalResultJson:
+      jsonb("final_result_json").$type<Record<string, unknown>>(),
+    createdAt: doublePrecision("created_at").notNull(),
+    expiresAt: doublePrecision("expires_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_client_agent_sessions_run").on(table.clientRunId),
+    uniqueIndex("uk_client_agent_sessions_token").on(table.tokenHash),
+    index("idx_client_agent_sessions_actor").on(table.actorId, table.status),
+    index("idx_client_agent_sessions_binding").on(
+      table.clientBindingDigest,
+      table.status,
+    ),
+    index("idx_client_agent_sessions_host").on(
+      table.hostSessionDigest,
+      table.status,
+    ),
+    index("idx_client_agent_sessions_expiry").on(table.status, table.expiresAt),
+    check(
+      "ck_client_agent_sessions_status",
+      sql`${table.status} in ('active', 'completed', 'cancelled', 'revoked', 'expired')`,
+    ),
+    check(
+      "ck_client_agent_sessions_attempts",
+      sql`${table.attemptCount} >= 0 and ${table.activeRequests} >= 0`,
+    ),
+  ],
+);
+
+export const clientAgentReceipts = pgTable(
+  "client_agent_receipts",
+  {
+    receiptId: varchar("receipt_id", { length: 80 }).primaryKey(),
+    sessionId: varchar("session_id", { length: 80 })
+      .notNull()
+      .references(() => clientAgentSessions.sessionId, { onDelete: "cascade" }),
+    clientRunId: varchar("client_run_id", { length: 80 }).notNull(),
+    actorId: varchar("actor_id", { length: 64 }).notNull(),
+    operationKey: varchar("operation_key", { length: 200 }).notNull(),
+    releaseId: varchar("release_id", { length: 80 }).notNull(),
+    clientBindingDigest: varchar("client_binding_digest", {
+      length: 71,
+    }).notNull(),
+    attempt: integer("attempt").notNull(),
+    requestDigest: varchar("request_digest", { length: 71 }).notNull(),
+    responseDigest: varchar("response_digest", { length: 71 }).notNull(),
+    deploymentDigest: varchar("deployment_digest", { length: 71 }).notNull(),
+    canonicalResultJson: jsonb("canonical_result_json"),
+    issuedAt: doublePrecision("issued_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_client_agent_receipts_attempt").on(
+      table.sessionId,
+      table.attempt,
+    ),
+    index("idx_client_agent_receipts_run").on(table.clientRunId, table.attempt),
+    check("ck_client_agent_receipts_attempt", sql`${table.attempt} > 0`),
+  ],
+);

package/template/packages/database/src/schema/index.ts

@@ -31,6 +31,14 @@ export * from "./workflow.js";
 // @windy-module system.workflow end
 // @windy-module system.agent begin
 export * from "./agent-runtime.js";
+export * from "./agent-workflow.js";
+export * from "./agent-workflow-delegation.js";
+export * from "./agent-workflow-effects.js";
+export * from "./agent-workflow-evaluation.js";
+export * from "./agent-context-message.js";
+export * from "./agent-session-receipt.js";
+export * from "./agent-session.js";
+export * from "./client-agent.js";
 export * from "./embedding-runtime.js";
 export * from "./ai-output-artifacts.js";
 // @windy-module system.agent end

package/template/packages/jobs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/jobs",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {

package/template/packages/modules/index.ts

@@ -14,4 +14,6 @@ export * from "./src/project-module-assembly.js";
 export * from "./src/module-host-range.js";
 export * from "./src/admin-ui-manifest.js";
 export * from "./src/system-admin-ui-catalog.js";
+// @windy-module system.agent begin
 export * from "./src/system-agent-supervisor.js";
+// @windy-module system.agent end