@sentry/junior 0.202.0 → 0.204.0

package/dist/executor-DcMSlI5c.js

@@ -0,0 +1,721 @@
+import "./config-nGCW1OTG.js";
+import { n as juniorDestinations, r as timestamptz } from "./destinations-BeBiJeEM.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { getTableColumns, sql } from "drizzle-orm";
+import { bigint, boolean, check, date, foreignKey, index, integer, jsonb, pgTable, primaryKey, text, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+import { Pool } from "@neondatabase/serverless";
+import { drizzle } from "drizzle-orm/neon-serverless";
+import { migrate } from "drizzle-orm/neon-serverless/migrator";
+import pg from "pg";
+import { drizzle as drizzle$1 } from "drizzle-orm/node-postgres";
+import { migrate as migrate$1 } from "drizzle-orm/node-postgres/migrator";
+//#region src/db/schema/artifacts.ts
+/** Durable metadata for conversation-owned public artifacts. */
+const juniorArtifacts = pgTable("junior_artifacts", {
+	/** Public identity used in `/public/artifacts/<id>.<ext>`. */
+	id: text("id").primaryKey(),
+	conversationId: text("conversation_id").notNull(),
+	sha256: text("sha256").notNull(),
+	ext: text("ext").notNull(),
+	storageKey: text("storage_key").notNull(),
+	contentType: text("content_type").notNull(),
+	bytes: integer("bytes").notNull(),
+	public: boolean("public").notNull(),
+	createdAt: timestamptz("created_at").notNull(),
+	/** Set when the artifact should stop being served publicly. */
+	deleteRequestedAt: timestamptz("delete_requested_at")
+}, (table) => [
+	uniqueIndex("junior_artifacts_conversation_sha_uidx").on(table.conversationId, table.sha256),
+	index("junior_artifacts_gc_idx").on(table.deleteRequestedAt, table.createdAt),
+	index("junior_artifacts_conversation_idx").on(table.conversationId)
+]);
+//#endregion
+//#region src/db/schema/users.ts
+const juniorUsers = pgTable("junior_users", {
+	id: text("id").primaryKey(),
+	primaryEmail: text("primary_email").notNull(),
+	primaryEmailNormalized: text("primary_email_normalized").notNull(),
+	displayName: text("display_name"),
+	createdAt: timestamptz("created_at").notNull(),
+	updatedAt: timestamptz("updated_at").notNull()
+}, (table) => [uniqueIndex("junior_users_primary_email_normalized_uidx").on(table.primaryEmailNormalized)]);
+//#endregion
+//#region src/db/schema/identities.ts
+const juniorIdentities = pgTable("junior_identities", {
+	id: text("id").primaryKey(),
+	kind: text("kind").$type().notNull(),
+	provider: text("provider").notNull(),
+	providerTenantId: text("provider_tenant_id").notNull().default(""),
+	providerSubjectId: text("provider_subject_id").notNull(),
+	displayName: text("display_name"),
+	handle: text("handle"),
+	email: text("email"),
+	avatarUrl: text("avatar_url"),
+	metadata: jsonb("metadata_json"),
+	createdAt: timestamptz("created_at").notNull(),
+	updatedAt: timestamptz("updated_at").notNull(),
+	userId: text("user_id").references(() => juniorUsers.id),
+	emailNormalized: text("email_normalized"),
+	emailVerified: boolean("email_verified").notNull().default(false)
+}, (table) => [
+	uniqueIndex("junior_identities_provider_subject_uidx").on(table.provider, table.providerTenantId, table.providerSubjectId),
+	index("junior_identities_user_idx").on(table.userId),
+	index("junior_identities_verified_email_idx").on(table.emailNormalized).where(sql`${table.emailVerified} = true AND ${table.emailNormalized} IS NOT NULL`),
+	index("junior_identities_kind_provider_idx").on(table.kind, table.provider)
+]);
+//#endregion
+//#region src/db/schema/conversations.ts
+const juniorConversations = pgTable("junior_conversations", {
+	conversationId: text("conversation_id").primaryKey(),
+	schemaVersion: integer("schema_version").notNull().default(1),
+	source: text("source").$type(),
+	/** Structured session Source locator; set-once on the conversation root. */
+	sessionSource: jsonb("source_json").$type(),
+	originType: text("origin_type"),
+	originId: text("origin_id"),
+	originRunId: text("origin_run_id"),
+	/** Complete Location associated with this Conversation. */
+	location: jsonb("location_json").$type(),
+	destinationId: text("destination_id").references(() => juniorDestinations.id),
+	destination: jsonb("destination_json").$type(),
+	actorIdentityId: text("actor_identity_id").references(() => juniorIdentities.id),
+	creatorIdentityId: text("creator_identity_id").references(() => juniorIdentities.id),
+	credentialSubjectIdentityId: text("credential_subject_identity_id").references(() => juniorIdentities.id),
+	actor: jsonb("actor_json").$type(),
+	channelName: text("channel_name"),
+	title: text("title"),
+	createdAt: timestamptz("created_at").notNull(),
+	lastActivityAt: timestamptz("last_activity_at").notNull(),
+	updatedAt: timestamptz("updated_at").notNull(),
+	executionUpdatedAt: timestamptz("execution_updated_at"),
+	executionStatus: text("execution_status").$type().notNull(),
+	runId: text("run_id"),
+	lastCheckpointAt: timestamptz("last_checkpoint_at"),
+	lastEnqueuedAt: timestamptz("last_enqueued_at"),
+	parentConversationId: text("parent_conversation_id").references(() => juniorConversations.conversationId),
+	rootConversationId: text("root_conversation_id").references(() => juniorConversations.conversationId),
+	transcriptPurgedAt: timestamptz("transcript_purged_at"),
+	durationMs: integer("duration_ms").notNull().default(0),
+	usage: jsonb("usage_json").$type(),
+	executionDurationMs: integer("execution_duration_ms").notNull().default(0),
+	executionUsage: jsonb("execution_usage_json").$type(),
+	metricRunId: text("metric_run_id"),
+	legacyArchivedAt: timestamptz("archived_at")
+}, (table) => [
+	index("junior_conversations_last_activity_idx").on(table.lastActivityAt.desc(), table.conversationId),
+	index("junior_conversations_active_idx").using("btree", sql`coalesce(${table.executionUpdatedAt}, ${table.updatedAt})`, table.conversationId).where(sql`${table.executionStatus} <> 'idle'`),
+	index("junior_conversations_destination_activity_idx").on(table.destinationId, table.lastActivityAt.desc()),
+	index("junior_conversations_actor_activity_idx").on(table.actorIdentityId, table.lastActivityAt.desc()),
+	index("junior_conversations_origin_idx").on(table.originType, table.originId, table.lastActivityAt.desc()),
+	index("junior_conversations_parent_idx").on(table.parentConversationId),
+	index("junior_conversations_root_idx").on(table.rootConversationId)
+]);
+/** Select runtime conversation fields without reading the legacy archive column. */
+function conversationReadColumns() {
+	const { legacyArchivedAt, ...columns } = getTableColumns(juniorConversations);
+	return columns;
+}
+//#endregion
+//#region src/db/schema/attachments.ts
+/** Durable metadata for files owned by one conversation. */
+const juniorAttachments = pgTable("junior_attachments", {
+	id: text("id").primaryKey(),
+	conversationId: text("conversation_id").notNull().references(() => juniorConversations.conversationId, { onDelete: "cascade" }),
+	/** Service that stores the file bytes. */
+	storageProvider: text("storage_provider").notNull(),
+	storageKey: text("storage_key").notNull(),
+	/** Provider that supplied the file. */
+	provider: text("provider"),
+	/** File id assigned by the source provider. */
+	providerId: text("provider_id"),
+	filename: text("filename").notNull(),
+	contentType: text("content_type").notNull(),
+	bytes: integer("bytes").notNull(),
+	sha256: text("sha256").notNull(),
+	visionSummary: text("vision_summary"),
+	createdAt: timestamptz("created_at").notNull(),
+	/** Set when conversation purge marks the attachment unavailable. */
+	deleteRequestedAt: timestamptz("delete_requested_at")
+}, (table) => [
+	index("junior_attachments_conversation_idx").on(table.conversationId),
+	index("junior_attachments_provider_idx").on(table.conversationId, table.provider, table.providerId),
+	index("junior_attachments_gc_idx").on(table.storageProvider, table.deleteRequestedAt, table.createdAt)
+]);
+//#endregion
+//#region src/db/schema/code.ts
+/** Repository known to Junior through an installed code plugin. */
+const juniorCodeRepositories = pgTable("junior_code_repositories", {
+	id: uuid("id").primaryKey(),
+	name: text("name").notNull(),
+	provider: text("provider").notNull(),
+	providerId: text("provider_id").notNull(),
+	url: text("url"),
+	updatedAt: timestamptz("updated_at").notNull()
+}, (table) => [uniqueIndex("junior_code_repositories_provider_id_idx").on(table.provider, table.providerId)]);
+/** Latest known state for one code change created by Junior. */
+const juniorCodeChanges = pgTable("junior_code_changes", {
+	id: uuid("id").primaryKey(),
+	closedAt: timestamptz("closed_at"),
+	conversationIds: text("conversation_ids").array().notNull().default(sql`ARRAY[]::text[]`),
+	mergedAt: timestamptz("merged_at"),
+	number: integer("number").notNull(),
+	openedAt: timestamptz("opened_at").notNull(),
+	provider: text("provider").notNull(),
+	providerId: text("provider_id").notNull(),
+	repositoryId: uuid("repository_id").notNull().references(() => juniorCodeRepositories.id, { onDelete: "cascade" }),
+	state: text("state").$type().notNull(),
+	title: text("title"),
+	updatedAt: timestamptz("updated_at").notNull(),
+	url: text("url")
+}, (table) => [
+	uniqueIndex("junior_code_changes_provider_id_idx").on(table.provider, table.providerId),
+	index("junior_code_changes_opened_at_idx").on(table.openedAt),
+	index("junior_code_changes_merged_at_idx").on(table.mergedAt),
+	index("junior_code_changes_closed_at_idx").on(table.closedAt),
+	index("junior_code_changes_open_idx").on(table.id).where(sql`${table.state} = 'open'`)
+]);
+//#endregion
+//#region src/db/schema/conversation-annotations.ts
+const juniorConversationAnnotations = pgTable("junior_conversation_annotations", {
+	conversationId: text("conversation_id").notNull(),
+	plugin: text("plugin").notNull(),
+	kind: text("kind").notNull(),
+	key: text("key").notNull(),
+	annotation: jsonb("annotation_json").$type().notNull(),
+	createdAt: timestamptz("created_at").notNull(),
+	updatedAt: timestamptz("updated_at").notNull()
+}, (table) => [primaryKey({
+	name: "junior_conversation_annotations_pk",
+	columns: [
+		table.conversationId,
+		table.plugin,
+		table.kind,
+		table.key
+	]
+}), foreignKey({
+	name: "junior_conversation_annotations_conversation_id_fk",
+	columns: [table.conversationId],
+	foreignColumns: [juniorConversations.conversationId]
+}).onDelete("cascade")]);
+//#endregion
+//#region src/db/schema/api-tokens.ts
+const juniorApiTokens = pgTable("junior_api_tokens", {
+	id: text("id").primaryKey(),
+	ownerEmailNormalized: text("owner_email_normalized").notNull(),
+	name: text("name").notNull(),
+	tokenHash: text("token_hash").notNull(),
+	tokenSuffix: text("token_suffix").notNull(),
+	createdAt: timestamptz("created_at").notNull(),
+	expiresAt: timestamptz("expires_at").notNull(),
+	lastUsedAt: timestamptz("last_used_at"),
+	revokedAt: timestamptz("revoked_at")
+}, (table) => [uniqueIndex("junior_api_tokens_token_hash_uidx").on(table.tokenHash), index("junior_api_tokens_owner_email_idx").on(table.ownerEmailNormalized)]);
+//#endregion
+//#region src/db/schema/conversation-events.ts
+/**
+* Append-only canonical conversation history. `history_version` partitions
+* model-history replacements, while `(conversation_id, seq)` is the stable
+* event identity and lease-fencing tripwire.
+*
+* `actor_identity_id` is the first-class author identity for human-authored
+* events. Message payloads may still carry display author fields in `meta`.
+*/
+const juniorConversationEvents = pgTable("junior_conversation_events", {
+	conversationId: text("conversation_id").notNull(),
+	seq: integer("seq").notNull(),
+	historyVersion: integer("history_version").notNull(),
+	schemaVersion: integer("schema_version").default(1).notNull(),
+	idempotencyKey: text("idempotency_key"),
+	type: text("type").notNull(),
+	payload: jsonb("payload").$type().notNull(),
+	actorIdentityId: text("actor_identity_id").references(() => juniorIdentities.id),
+	createdAt: timestamptz("created_at").notNull()
+}, (table) => [
+	primaryKey({
+		name: "junior_conversation_events_conversation_id_seq_pk",
+		columns: [table.conversationId, table.seq]
+	}),
+	foreignKey({
+		name: "junior_conversation_events_conversation_id_junior_conversations_conversation_id_fk",
+		columns: [table.conversationId],
+		foreignColumns: [juniorConversations.conversationId]
+	}),
+	index("junior_conversation_events_history_version_idx").on(table.conversationId, table.historyVersion, table.seq),
+	index("junior_conversation_events_type_idx").on(table.conversationId, table.type, table.seq),
+	index("junior_conversation_events_actor_identity_idx").on(table.actorIdentityId, table.conversationId, table.seq),
+	index("junior_conversation_events_message_search_idx").using("gin", sql`to_tsvector('english', ${table.payload}->>'text')`).where(sql`${table.type} = 'message'`),
+	uniqueIndex("junior_conversation_events_idempotency_idx").on(table.conversationId, table.idempotencyKey)
+]);
+//#endregion
+//#region src/db/schema/conversation-bindings.ts
+/** Provider conversation coordinates bound to Junior's opaque durable conversation id. */
+const juniorConversationBindings = pgTable("junior_conversation_bindings", {
+	conversationId: text("conversation_id").notNull().references(() => juniorConversations.conversationId),
+	provider: text("provider").notNull(),
+	providerTenantId: text("provider_tenant_id").notNull().default(""),
+	providerDestinationId: text("provider_destination_id").notNull(),
+	providerConversationId: text("provider_conversation_id").notNull(),
+	createdAt: timestamptz("created_at").notNull()
+}, (table) => [primaryKey({
+	name: "junior_conversation_bindings_provider_conversation_pk",
+	columns: [
+		table.provider,
+		table.providerTenantId,
+		table.providerDestinationId,
+		table.providerConversationId
+	]
+}), index("junior_conversation_bindings_conversation_idx").on(table.conversationId)]);
+//#endregion
+//#region src/db/schema/conversation-participants.ts
+/**
+* Materialized personal-feed membership for one linked user on one root
+* conversation. Rows come from the root actor and from durable human user
+* message authors.
+*/
+const juniorConversationParticipants = pgTable("junior_conversation_participants", {
+	userId: text("user_id").notNull().references(() => juniorUsers.id),
+	rootConversationId: text("root_conversation_id").notNull().references(() => juniorConversations.conversationId),
+	lastMessageAt: timestamptz("last_message_at").notNull(),
+	archivedAt: timestamptz("archived_at")
+}, (table) => [
+	primaryKey({
+		name: "junior_conversation_participants_user_root_pk",
+		columns: [table.userId, table.rootConversationId]
+	}),
+	index("junior_conversation_participants_user_activity_idx").on(table.userId, table.lastMessageAt.desc()),
+	index("junior_conversation_participants_root_idx").on(table.rootConversationId)
+]);
+//#endregion
+//#region src/db/schema/agent-invocations.ts
+const AGENT_INVOCATION_MAILBOX_STATUSES = ["pending", "appended"];
+const juniorAgentBindings = pgTable("junior_agent_bindings", {
+	parentConversationId: text("parent_conversation_id").notNull().references(() => juniorConversations.conversationId),
+	name: text("name").notNull(),
+	childConversationId: text("child_conversation_id").notNull().references(() => juniorConversations.conversationId)
+}, (table) => [primaryKey({ columns: [table.parentConversationId, table.name] }), uniqueIndex("junior_agent_bindings_child_idx").on(table.childConversationId)]);
+const juniorAgentInvocations = pgTable("junior_agent_invocations", {
+	invocationId: text("invocation_id").primaryKey(),
+	parentConversationId: text("parent_conversation_id").notNull().references(() => juniorConversations.conversationId),
+	childConversationId: text("child_conversation_id").notNull().references(() => juniorConversations.conversationId),
+	agentName: text("agent_name"),
+	input: text("input").notNull(),
+	actor: jsonb("actor_json").$type().notNull(),
+	credentialContext: jsonb("credential_context_json").$type(),
+	source: jsonb("source_json").$type().notNull(),
+	destination: jsonb("destination_json").$type().notNull(),
+	destinationVisibility: text("destination_visibility").$type(),
+	reasoningLevel: text("reasoning_level").$type(),
+	status: text("status").$type().notNull(),
+	mailboxStatus: text("mailbox_status").$type().notNull(),
+	result: text("result"),
+	errorMessage: text("error_message"),
+	createdAt: timestamptz("created_at").notNull(),
+	updatedAt: timestamptz("updated_at").notNull(),
+	terminalAt: timestamptz("terminal_at")
+}, (table) => [index("junior_agent_invocations_child_idx").on(table.childConversationId), index("junior_agent_invocations_mailbox_idx").on(table.mailboxStatus, table.createdAt)]);
+//#endregion
+//#region src/db/schema/location-configurations.ts
+/** Durable user configuration entries scoped to provider Locations. */
+const juniorLocationConfigurations = pgTable("junior_location_configurations", {
+	locationId: text("location_id").notNull().references(() => juniorDestinations.id, { onDelete: "cascade" }),
+	key: text("key").notNull(),
+	value: text("value").notNull(),
+	updatedAt: timestamptz("updated_at").notNull(),
+	updatedBy: text("updated_by"),
+	source: text("source"),
+	expiresAt: text("expires_at")
+}, (table) => [primaryKey({ columns: [table.locationId, table.key] })]);
+//#endregion
+//#region src/db/schema/event-tasks.ts
+const juniorEventTasks = pgTable("junior_event_tasks", {
+	id: text("id").primaryKey(),
+	teamId: text("team_id").notNull(),
+	namespace: text("namespace").notNull(),
+	identifier: text("identifier").notNull(),
+	createdAtMs: bigint("created_at_ms", { mode: "number" }).notNull(),
+	/** Retained row status. Deleted tasks keep history but stop matching. */
+	status: text("status").$type().notNull().default("active"),
+	/** Short display title generated from the task instruction. */
+	title: text("title"),
+	task: jsonb("task_json").$type().notNull()
+}, (table) => [index("junior_event_tasks_team_idx").on(table.teamId, table.createdAtMs, table.id).where(sql`${table.status} <> 'deleted'`), index("junior_event_tasks_match_idx").on(table.namespace, table.identifier, table.createdAtMs, table.id).where(sql`${table.status} <> 'deleted'`)]);
+//#endregion
+//#region src/db/schema/stats.ts
+/**
+* Daily named counters used by Junior and loaded plugins.
+* TODO: store hour keys when dashboard 24h workspace usage needs hourly bars.
+* `date` is a Postgres date column, so counters stay day-bucketed today.
+*/
+const juniorStats = pgTable("junior_stats", {
+	date: date("date", { mode: "string" }).notNull(),
+	namespace: text("namespace").notNull(),
+	metric: text("metric").notNull(),
+	name: text("name").notNull(),
+	count: integer("count").notNull().default(0)
+}, (table) => [primaryKey({
+	name: "junior_stats_date_namespace_metric_name_pk",
+	columns: [
+		table.date,
+		table.namespace,
+		table.metric,
+		table.name
+	]
+})]);
+//#endregion
+//#region src/db/schema/task-executions.ts
+/** One terminal task execution linked to its durable conversation when present. */
+const juniorTaskExecutions = pgTable("junior_task_executions", {
+	executionId: text("execution_id").notNull(),
+	kind: text("kind").notNull(),
+	namespace: text("namespace").notNull(),
+	taskId: text("task_id").notNull(),
+	conversationId: text("conversation_id"),
+	executedAtMs: bigint("executed_at_ms", { mode: "number" }).notNull(),
+	status: text("status").$type().notNull()
+}, (table) => [
+	check("junior_task_executions_kind_check", sql`${table.kind} in ('scheduled', 'event')`),
+	check("junior_task_executions_status_check", sql`${table.status} in ('blocked', 'completed', 'failed')`),
+	primaryKey({
+		name: "junior_task_executions_kind_namespace_execution_id_pk",
+		columns: [
+			table.kind,
+			table.namespace,
+			table.executionId
+		]
+	}),
+	foreignKey({
+		name: "junior_task_executions_conversation_id_junior_conversations_conversation_id_fk",
+		columns: [table.conversationId],
+		foreignColumns: [juniorConversations.conversationId]
+	}),
+	index("junior_task_executions_task_time_idx").on(table.kind, table.namespace, table.taskId, table.executedAtMs),
+	index("junior_task_executions_time_kind_idx").on(table.executedAtMs, table.kind),
+	index("junior_task_executions_conversation_time_idx").on(table.conversationId, table.executedAtMs)
+]);
+//#endregion
+//#region src/db/schema/scheduled-tasks.ts
+const juniorSchedulerTasks = pgTable("junior_scheduler_tasks", {
+	id: text("id").primaryKey(),
+	teamId: text("team_id").notNull(),
+	creatorSlackUserId: text("creator_slack_user_id"),
+	creatorIdentityId: text("creator_identity_id"),
+	status: text("status").notNull(),
+	nextRunAtMs: bigint("next_run_at_ms", { mode: "number" }),
+	runNowAtMs: bigint("run_now_at_ms", { mode: "number" }),
+	createdAtMs: bigint("created_at_ms", { mode: "number" }).notNull(),
+	/** Short display title generated from the task instruction. */
+	title: text("title"),
+	record: jsonb("record").$type().notNull()
+}, (table) => [
+	index("junior_scheduler_tasks_creator_idx").on(table.teamId, table.creatorSlackUserId, table.createdAtMs, table.id).where(sql`${table.status} <> 'deleted'`),
+	index("junior_scheduler_tasks_creator_identity_idx").on(table.creatorIdentityId, table.createdAtMs, table.id).where(sql`${table.status} <> 'deleted' AND ${table.creatorIdentityId} IS NOT NULL`),
+	index("junior_scheduler_tasks_team_status_idx").on(table.teamId, table.createdAtMs, table.id).where(sql`${table.status} <> 'deleted'`),
+	index("junior_scheduler_tasks_run_now_due_idx").on(table.runNowAtMs, table.createdAtMs, table.id).where(sql`${table.status} = 'active' AND ${table.runNowAtMs} IS NOT NULL`),
+	index("junior_scheduler_tasks_next_run_due_idx").on(table.nextRunAtMs, table.createdAtMs, table.id).where(sql`${table.status} = 'active' AND ${table.nextRunAtMs} IS NOT NULL`)
+]);
+const juniorSchedulerRuns = pgTable("junior_scheduler_runs", {
+	id: text("id").primaryKey(),
+	taskId: text("task_id").notNull(),
+	status: text("status").notNull(),
+	scheduledForMs: bigint("scheduled_for_ms", { mode: "number" }).notNull(),
+	record: jsonb("record").$type().notNull()
+}, (table) => [index("junior_scheduler_runs_task_status_idx").on(table.taskId, table.status, table.scheduledForMs), index("junior_scheduler_runs_status_idx").on(table.status, table.scheduledForMs)]);
+//#endregion
+//#region src/db/schema/workspaces.ts
+/** Named recipe used to prepare a reusable Sandbox. */
+const juniorWorkspaces = pgTable("junior_workspaces", {
+	id: text("id").primaryKey(),
+	name: text("name").notNull(),
+	setupScript: text("setup_script").notNull().default(""),
+	createdAt: timestamptz("created_at").notNull(),
+	updatedAt: timestamptz("updated_at").notNull()
+}, (table) => [uniqueIndex("junior_workspaces_name_idx").on(table.name)]);
+/** Repository included in one Workspace recipe. */
+const juniorWorkspaceRepos = pgTable("junior_workspace_repos", {
+	workspaceId: text("workspace_id").notNull().references(() => juniorWorkspaces.id, { onDelete: "cascade" }),
+	provider: text("provider").notNull(),
+	repo: text("repo").notNull()
+}, (table) => [primaryKey({ columns: [
+	table.workspaceId,
+	table.provider,
+	table.repo
+] })]);
+//#endregion
+//#region src/db/schema/snapshots.ts
+/**
+* Sandbox snapshot build and ready artifact for one Workspace recipe.
+* A ready row keeps its builder owner until the snapshot is discarded.
+*/
+const juniorSnapshots = pgTable("junior_snapshots", {
+	id: text("id").primaryKey(),
+	workspaceId: text("workspace_id").notNull().references(() => juniorWorkspaces.id, { onDelete: "cascade" }),
+	profileHash: text("profile_hash").notNull(),
+	status: text("status").$type().notNull(),
+	snapshotId: text("snapshot_id"),
+	buildDurationMs: integer("build_duration_ms"),
+	sizeBytes: bigint("size_bytes", { mode: "number" }),
+	generatedAt: timestamptz("generated_at"),
+	buildStartedAt: timestamptz("build_started_at"),
+	buildPhase: text("build_phase").$type(),
+	buildSandboxName: text("build_sandbox_name"),
+	buildCommandId: text("build_command_id"),
+	buildError: text("build_error"),
+	createdAt: timestamptz("created_at").notNull(),
+	updatedAt: timestamptz("updated_at").notNull()
+}, (table) => [
+	check("junior_snapshots_status_check", sql`${table.status} in ('building', 'failed', 'ready')`),
+	check("junior_snapshots_build_phase_check", sql`${table.buildPhase} is null or ${table.buildPhase} in ('created', 'dependencies_installed', 'repositories_prepared')`),
+	check("junior_snapshots_ready_fields_check", sql`${table.status} <> 'ready' or (${table.snapshotId} is not null and ${table.buildDurationMs} is not null and ${table.generatedAt} is not null)`),
+	check("junior_snapshots_build_fields_check", sql`${table.status} = 'ready' or (${table.buildStartedAt} is not null and ${table.buildPhase} is not null)`),
+	check("junior_snapshots_build_duration_check", sql`${table.buildDurationMs} is null or ${table.buildDurationMs} >= 0`),
+	check("junior_snapshots_size_bytes_check", sql`${table.sizeBytes} is null or ${table.sizeBytes} >= 0`),
+	uniqueIndex("junior_snapshots_snapshot_id_uidx").on(table.snapshotId),
+	index("junior_snapshots_workspace_idx").on(table.workspaceId),
+	index("junior_snapshots_workspace_profile_status_idx").on(table.workspaceId, table.profileHash, table.status),
+	uniqueIndex("junior_snapshots_active_build_uidx").on(table.workspaceId, table.profileHash).where(sql`${table.status} = 'building'`),
+	index("junior_snapshots_workspace_status_idx").on(table.workspaceId, table.status)
+]);
+//#endregion
+//#region src/db/schema.ts
+const juniorSqlSchema = {
+	juniorArtifacts,
+	juniorAttachments,
+	juniorCodeChanges,
+	juniorCodeRepositories,
+	juniorConversationAnnotations,
+	juniorApiTokens,
+	juniorAgentBindings,
+	juniorAgentInvocations,
+	juniorConversationEvents,
+	juniorConversationBindings,
+	juniorConversationParticipants,
+	juniorConversations,
+	juniorLocationConfigurations,
+	juniorDestinations,
+	juniorEventTasks,
+	juniorIdentities,
+	juniorSnapshots,
+	juniorStats,
+	juniorTaskExecutions,
+	juniorSchedulerRuns,
+	juniorSchedulerTasks,
+	juniorUsers,
+	juniorWorkspaceRepos,
+	juniorWorkspaces
+};
+//#endregion
+//#region src/db/neon.ts
+var NeonExecutor = class {
+	pool;
+	transactionClient = new AsyncLocalStorage();
+	savepointId = 0;
+	constructor(pool) {
+		this.pool = pool;
+	}
+	db() {
+		return drizzle(this.queryClient(), { schema: juniorSqlSchema });
+	}
+	async execute(statement, params = []) {
+		await this.queryClient().query(statement, [...params]);
+	}
+	async query(statement, params = []) {
+		return (await this.queryClient().query(statement, [...params])).rows;
+	}
+	async migrate(config) {
+		await migrate(drizzle(this.queryClient(), { schema: juniorSqlSchema }), config);
+	}
+	async transaction(callback) {
+		const existingClient = this.transactionClient.getStore();
+		if (existingClient) {
+			const savepoint = `junior_savepoint_${++this.savepointId}`;
+			await existingClient.query(`SAVEPOINT ${savepoint}`);
+			try {
+				const result = await callback();
+				await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
+				return result;
+			} catch (error) {
+				await existingClient.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+				await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
+				throw error;
+			}
+		}
+		const client = await this.pool.connect();
+		try {
+			await client.query("BEGIN");
+			const result = await this.transactionClient.run(client, callback);
+			await client.query("COMMIT");
+			return result;
+		} catch (error) {
+			await client.query("ROLLBACK");
+			throw error;
+		} finally {
+			client.release();
+		}
+	}
+	async withLock(lockName, callback) {
+		if (!lockName) throw new Error("SQL lock name is required");
+		const existingClient = this.transactionClient.getStore();
+		if (existingClient) {
+			await existingClient.query("SELECT pg_advisory_xact_lock(hashtext($1))", [lockName]);
+			return await callback();
+		}
+		const client = await this.pool.connect();
+		try {
+			await client.query("BEGIN");
+			return await this.transactionClient.run(client, async () => {
+				try {
+					await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [lockName]);
+					const result = await callback();
+					await client.query("COMMIT");
+					return result;
+				} catch (error) {
+					await client.query("ROLLBACK");
+					throw error;
+				}
+			});
+		} finally {
+			client.release();
+		}
+	}
+	async withMigrationLock(migrationTable, callback) {
+		const client = await this.pool.connect();
+		const lockName = `junior:migrate:${migrationTable}`;
+		try {
+			await client.query("SELECT pg_advisory_lock(hashtext($1))", [lockName]);
+			return await callback();
+		} finally {
+			client.release(true);
+		}
+	}
+	async close() {
+		await this.pool.end();
+	}
+	queryClient() {
+		return this.transactionClient.getStore() ?? this.pool;
+	}
+};
+/** Create the shared Neon-backed Junior SQL executor. */
+function createNeonJuniorSqlExecutor(args) {
+	return new NeonExecutor(new Pool({
+		connectionString: args.connectionString,
+		max: 3,
+		statement_timeout: args.statementTimeoutMs
+	}));
+}
+//#endregion
+//#region src/db/postgres.ts
+const { Pool: Pool$1 } = pg;
+var PostgresExecutor = class {
+	pool;
+	transactionClient = new AsyncLocalStorage();
+	savepointId = 0;
+	constructor(pool) {
+		this.pool = pool;
+	}
+	db() {
+		return drizzle$1(this.queryClient(), { schema: juniorSqlSchema });
+	}
+	async execute(statement, params = []) {
+		await this.queryClient().query(statement, [...params]);
+	}
+	async query(statement, params = []) {
+		return (await this.queryClient().query(statement, [...params])).rows;
+	}
+	async migrate(config) {
+		await migrate$1(drizzle$1(this.queryClient(), { schema: juniorSqlSchema }), config);
+	}
+	async transaction(callback) {
+		const existingClient = this.transactionClient.getStore();
+		if (existingClient) {
+			const savepoint = `junior_savepoint_${++this.savepointId}`;
+			await existingClient.query(`SAVEPOINT ${savepoint}`);
+			try {
+				const result = await callback();
+				await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
+				return result;
+			} catch (error) {
+				await existingClient.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+				await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
+				throw error;
+			}
+		}
+		const client = await this.pool.connect();
+		try {
+			await client.query("BEGIN");
+			const result = await this.transactionClient.run(client, callback);
+			await client.query("COMMIT");
+			return result;
+		} catch (error) {
+			await client.query("ROLLBACK");
+			throw error;
+		} finally {
+			client.release();
+		}
+	}
+	async withLock(lockName, callback) {
+		if (!lockName) throw new Error("SQL lock name is required");
+		const existingClient = this.transactionClient.getStore();
+		if (existingClient) {
+			await existingClient.query("SELECT pg_advisory_xact_lock(hashtext($1))", [lockName]);
+			return await callback();
+		}
+		const client = await this.pool.connect();
+		try {
+			await client.query("BEGIN");
+			return await this.transactionClient.run(client, async () => {
+				try {
+					await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [lockName]);
+					const result = await callback();
+					await client.query("COMMIT");
+					return result;
+				} catch (error) {
+					await client.query("ROLLBACK");
+					throw error;
+				}
+			});
+		} finally {
+			client.release();
+		}
+	}
+	async withMigrationLock(migrationTable, callback) {
+		const client = await this.pool.connect();
+		const lockName = `junior:migrate:${migrationTable}`;
+		try {
+			await client.query("SELECT pg_advisory_lock(hashtext($1))", [lockName]);
+			return await callback();
+		} finally {
+			client.release(true);
+		}
+	}
+	async close() {
+		await this.pool.end();
+	}
+	queryClient() {
+		return this.transactionClient.getStore() ?? this.pool;
+	}
+};
+/** Create the shared Node Postgres-backed Junior SQL executor. */
+function createPostgresJuniorSqlExecutor(args) {
+	return new PostgresExecutor(new Pool$1({
+		application_name: args.applicationName,
+		connectionString: args.connectionString,
+		max: 3,
+		statement_timeout: args.statementTimeoutMs
+	}));
+}
+//#endregion
+//#region src/db/executor.ts
+/** Create the SQL executor appropriate for the configured database URL. */
+function createJuniorSqlExecutor(args) {
+	const statementTimeoutMs = args.statementTimeoutMs ?? 3e4;
+	if (args.driver === "postgres") return createPostgresJuniorSqlExecutor({
+		connectionString: args.connectionString,
+		statementTimeoutMs
+	});
+	return createNeonJuniorSqlExecutor({
+		connectionString: args.connectionString,
+		statementTimeoutMs
+	});
+}
+//#endregion
+export { juniorConversations as C, juniorArtifacts as E, conversationReadColumns as S, juniorUsers as T, juniorApiTokens as _, juniorSchedulerRuns as a, juniorCodeRepositories as b, juniorStats as c, AGENT_INVOCATION_MAILBOX_STATUSES as d, juniorAgentBindings as f, juniorConversationEvents as g, juniorConversationBindings as h, juniorWorkspaces as i, juniorEventTasks as l, juniorConversationParticipants as m, juniorSnapshots as n, juniorSchedulerTasks as o, juniorAgentInvocations as p, juniorWorkspaceRepos as r, juniorTaskExecutions as s, createJuniorSqlExecutor as t, juniorLocationConfigurations as u, juniorConversationAnnotations as v, juniorIdentities as w, juniorAttachments as x, juniorCodeChanges as y };