merge: wave 2 executor (01-02) into main

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

paperclip-reference/packages/db/src/schema/activity_log.ts

@@ -0,0 +1,26 @@
+import { pgTable, uuid, text, timestamp, jsonb, index } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+import { heartbeatRuns } from "./heartbeat_runs.js";
+
+export const activityLog = pgTable(
+  "activity_log",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    actorType: text("actor_type").notNull().default("system"),
+    actorId: text("actor_id").notNull(),
+    action: text("action").notNull(),
+    entityType: text("entity_type").notNull(),
+    entityId: text("entity_id").notNull(),
+    agentId: uuid("agent_id").references(() => agents.id),
+    runId: uuid("run_id").references(() => heartbeatRuns.id),
+    details: jsonb("details").$type<Record<string, unknown>>(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyCreatedIdx: index("activity_log_company_created_idx").on(table.companyId, table.createdAt),
+    runIdIdx: index("activity_log_run_id_idx").on(table.runId),
+    entityIdx: index("activity_log_entity_type_id_idx").on(table.entityType, table.entityId),
+  }),
+);

paperclip-reference/packages/db/src/schema/agent_api_keys.ts

@@ -0,0 +1,21 @@
+import { pgTable, uuid, text, timestamp, index } from "drizzle-orm/pg-core";
+import { agents } from "./agents.js";
+import { companies } from "./companies.js";
+
+export const agentApiKeys = pgTable(
+  "agent_api_keys",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    agentId: uuid("agent_id").notNull().references(() => agents.id),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    name: text("name").notNull(),
+    keyHash: text("key_hash").notNull(),
+    lastUsedAt: timestamp("last_used_at", { withTimezone: true }),
+    revokedAt: timestamp("revoked_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    keyHashIdx: index("agent_api_keys_key_hash_idx").on(table.keyHash),
+    companyAgentIdx: index("agent_api_keys_company_agent_idx").on(table.companyId, table.agentId),
+  }),
+);

paperclip-reference/packages/db/src/schema/agent_config_revisions.ts

@@ -0,0 +1,28 @@
+import { pgTable, uuid, text, timestamp, jsonb, index } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+
+export const agentConfigRevisions = pgTable(
+  "agent_config_revisions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    agentId: uuid("agent_id").notNull().references(() => agents.id, { onDelete: "cascade" }),
+    createdByAgentId: uuid("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    createdByUserId: text("created_by_user_id"),
+    source: text("source").notNull().default("patch"),
+    rolledBackFromRevisionId: uuid("rolled_back_from_revision_id"),
+    changedKeys: jsonb("changed_keys").$type<string[]>().notNull().default([]),
+    beforeConfig: jsonb("before_config").$type<Record<string, unknown>>().notNull(),
+    afterConfig: jsonb("after_config").$type<Record<string, unknown>>().notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyAgentCreatedIdx: index("agent_config_revisions_company_agent_created_idx").on(
+      table.companyId,
+      table.agentId,
+      table.createdAt,
+    ),
+    agentCreatedIdx: index("agent_config_revisions_agent_created_idx").on(table.agentId, table.createdAt),
+  }),
+);

paperclip-reference/packages/db/src/schema/agent_runtime_state.ts

@@ -0,0 +1,28 @@
+import { pgTable, uuid, text, timestamp, jsonb, bigint, index } from "drizzle-orm/pg-core";
+import { agents } from "./agents.js";
+import { companies } from "./companies.js";
+
+export const agentRuntimeState = pgTable(
+  "agent_runtime_state",
+  {
+    agentId: uuid("agent_id").primaryKey().references(() => agents.id),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    adapterType: text("adapter_type").notNull(),
+    sessionId: text("session_id"),
+    stateJson: jsonb("state_json").$type<Record<string, unknown>>().notNull().default({}),
+    lastRunId: uuid("last_run_id"),
+    lastRunStatus: text("last_run_status"),
+    totalInputTokens: bigint("total_input_tokens", { mode: "number" }).notNull().default(0),
+    totalOutputTokens: bigint("total_output_tokens", { mode: "number" }).notNull().default(0),
+    totalCachedInputTokens: bigint("total_cached_input_tokens", { mode: "number" }).notNull().default(0),
+    totalCostCents: bigint("total_cost_cents", { mode: "number" }).notNull().default(0),
+    lastError: text("last_error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyAgentIdx: index("agent_runtime_state_company_agent_idx").on(table.companyId, table.agentId),
+    companyUpdatedIdx: index("agent_runtime_state_company_updated_idx").on(table.companyId, table.updatedAt),
+  }),
+);
+

paperclip-reference/packages/db/src/schema/agent_task_sessions.ts

@@ -0,0 +1,39 @@
+import { pgTable, uuid, text, timestamp, jsonb, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+import { heartbeatRuns } from "./heartbeat_runs.js";
+
+export const agentTaskSessions = pgTable(
+  "agent_task_sessions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    agentId: uuid("agent_id").notNull().references(() => agents.id),
+    adapterType: text("adapter_type").notNull(),
+    taskKey: text("task_key").notNull(),
+    sessionParamsJson: jsonb("session_params_json").$type<Record<string, unknown>>(),
+    sessionDisplayId: text("session_display_id"),
+    lastRunId: uuid("last_run_id").references(() => heartbeatRuns.id),
+    lastError: text("last_error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyAgentTaskUniqueIdx: uniqueIndex("agent_task_sessions_company_agent_adapter_task_uniq").on(
+      table.companyId,
+      table.agentId,
+      table.adapterType,
+      table.taskKey,
+    ),
+    companyAgentUpdatedIdx: index("agent_task_sessions_company_agent_updated_idx").on(
+      table.companyId,
+      table.agentId,
+      table.updatedAt,
+    ),
+    companyTaskUpdatedIdx: index("agent_task_sessions_company_task_updated_idx").on(
+      table.companyId,
+      table.taskKey,
+      table.updatedAt,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/agent_wakeup_requests.ts

@@ -0,0 +1,40 @@
+import { pgTable, uuid, text, timestamp, jsonb, integer, index } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+
+export const agentWakeupRequests = pgTable(
+  "agent_wakeup_requests",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    agentId: uuid("agent_id").notNull().references(() => agents.id),
+    source: text("source").notNull(),
+    triggerDetail: text("trigger_detail"),
+    reason: text("reason"),
+    payload: jsonb("payload").$type<Record<string, unknown>>(),
+    status: text("status").notNull().default("queued"),
+    coalescedCount: integer("coalesced_count").notNull().default(0),
+    requestedByActorType: text("requested_by_actor_type"),
+    requestedByActorId: text("requested_by_actor_id"),
+    idempotencyKey: text("idempotency_key"),
+    runId: uuid("run_id"),
+    requestedAt: timestamp("requested_at", { withTimezone: true }).notNull().defaultNow(),
+    claimedAt: timestamp("claimed_at", { withTimezone: true }),
+    finishedAt: timestamp("finished_at", { withTimezone: true }),
+    error: text("error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyAgentStatusIdx: index("agent_wakeup_requests_company_agent_status_idx").on(
+      table.companyId,
+      table.agentId,
+      table.status,
+    ),
+    companyRequestedIdx: index("agent_wakeup_requests_company_requested_idx").on(
+      table.companyId,
+      table.requestedAt,
+    ),
+    agentRequestedIdx: index("agent_wakeup_requests_agent_requested_idx").on(table.agentId, table.requestedAt),
+  }),
+);

paperclip-reference/packages/db/src/schema/agents.ts

@@ -0,0 +1,42 @@
+import {
+  type AnyPgColumn,
+  pgTable,
+  uuid,
+  text,
+  integer,
+  timestamp,
+  jsonb,
+  index,
+} from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+
+export const agents = pgTable(
+  "agents",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    name: text("name").notNull(),
+    role: text("role").notNull().default("general"),
+    title: text("title"),
+    icon: text("icon"),
+    status: text("status").notNull().default("idle"),
+    reportsTo: uuid("reports_to").references((): AnyPgColumn => agents.id),
+    capabilities: text("capabilities"),
+    adapterType: text("adapter_type").notNull().default("process"),
+    adapterConfig: jsonb("adapter_config").$type<Record<string, unknown>>().notNull().default({}),
+    runtimeConfig: jsonb("runtime_config").$type<Record<string, unknown>>().notNull().default({}),
+    budgetMonthlyCents: integer("budget_monthly_cents").notNull().default(0),
+    spentMonthlyCents: integer("spent_monthly_cents").notNull().default(0),
+    pauseReason: text("pause_reason"),
+    pausedAt: timestamp("paused_at", { withTimezone: true }),
+    permissions: jsonb("permissions").$type<Record<string, unknown>>().notNull().default({}),
+    lastHeartbeatAt: timestamp("last_heartbeat_at", { withTimezone: true }),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyStatusIdx: index("agents_company_status_idx").on(table.companyId, table.status),
+    companyReportsToIdx: index("agents_company_reports_to_idx").on(table.companyId, table.reportsTo),
+  }),
+);

paperclip-reference/packages/db/src/schema/approval_comments.ts

@@ -0,0 +1,26 @@
+import { pgTable, uuid, text, timestamp, index } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { approvals } from "./approvals.js";
+import { agents } from "./agents.js";
+
+export const approvalComments = pgTable(
+  "approval_comments",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    approvalId: uuid("approval_id").notNull().references(() => approvals.id),
+    authorAgentId: uuid("author_agent_id").references(() => agents.id),
+    authorUserId: text("author_user_id"),
+    body: text("body").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyIdx: index("approval_comments_company_idx").on(table.companyId),
+    approvalIdx: index("approval_comments_approval_idx").on(table.approvalId),
+    approvalCreatedIdx: index("approval_comments_approval_created_idx").on(
+      table.approvalId,
+      table.createdAt,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/approvals.ts

@@ -0,0 +1,28 @@
+import { pgTable, uuid, text, timestamp, jsonb, index } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+
+export const approvals = pgTable(
+  "approvals",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    type: text("type").notNull(),
+    requestedByAgentId: uuid("requested_by_agent_id").references(() => agents.id),
+    requestedByUserId: text("requested_by_user_id"),
+    status: text("status").notNull().default("pending"),
+    payload: jsonb("payload").$type<Record<string, unknown>>().notNull(),
+    decisionNote: text("decision_note"),
+    decidedByUserId: text("decided_by_user_id"),
+    decidedAt: timestamp("decided_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyStatusTypeIdx: index("approvals_company_status_type_idx").on(
+      table.companyId,
+      table.status,
+      table.type,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/assets.ts

@@ -0,0 +1,26 @@
+import { pgTable, uuid, text, integer, timestamp, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+
+export const assets = pgTable(
+  "assets",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    provider: text("provider").notNull(),
+    objectKey: text("object_key").notNull(),
+    contentType: text("content_type").notNull(),
+    byteSize: integer("byte_size").notNull(),
+    sha256: text("sha256").notNull(),
+    originalFilename: text("original_filename"),
+    createdByAgentId: uuid("created_by_agent_id").references(() => agents.id),
+    createdByUserId: text("created_by_user_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyCreatedIdx: index("assets_company_created_idx").on(table.companyId, table.createdAt),
+    companyProviderIdx: index("assets_company_provider_idx").on(table.companyId, table.provider),
+    companyObjectKeyUq: uniqueIndex("assets_company_object_key_uq").on(table.companyId, table.objectKey),
+  }),
+);

paperclip-reference/packages/db/src/schema/auth.ts

@@ -0,0 +1,47 @@
+import { pgTable, text, timestamp, boolean } from "drizzle-orm/pg-core";
+
+export const authUsers = pgTable("user", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  email: text("email").notNull(),
+  emailVerified: boolean("email_verified").notNull().default(false),
+  image: text("image"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+});
+
+export const authSessions = pgTable("session", {
+  id: text("id").primaryKey(),
+  expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+  token: text("token").notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+  ipAddress: text("ip_address"),
+  userAgent: text("user_agent"),
+  userId: text("user_id").notNull().references(() => authUsers.id, { onDelete: "cascade" }),
+});
+
+export const authAccounts = pgTable("account", {
+  id: text("id").primaryKey(),
+  accountId: text("account_id").notNull(),
+  providerId: text("provider_id").notNull(),
+  userId: text("user_id").notNull().references(() => authUsers.id, { onDelete: "cascade" }),
+  accessToken: text("access_token"),
+  refreshToken: text("refresh_token"),
+  idToken: text("id_token"),
+  accessTokenExpiresAt: timestamp("access_token_expires_at", { withTimezone: true }),
+  refreshTokenExpiresAt: timestamp("refresh_token_expires_at", { withTimezone: true }),
+  scope: text("scope"),
+  password: text("password"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+});
+
+export const authVerifications = pgTable("verification", {
+  id: text("id").primaryKey(),
+  identifier: text("identifier").notNull(),
+  value: text("value").notNull(),
+  expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }),
+  updatedAt: timestamp("updated_at", { withTimezone: true }),
+});

paperclip-reference/packages/db/src/schema/board_api_keys.ts

@@ -0,0 +1,20 @@
+import { pgTable, uuid, text, timestamp, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { authUsers } from "./auth.js";
+
+export const boardApiKeys = pgTable(
+  "board_api_keys",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    userId: text("user_id").notNull().references(() => authUsers.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    keyHash: text("key_hash").notNull(),
+    lastUsedAt: timestamp("last_used_at", { withTimezone: true }),
+    revokedAt: timestamp("revoked_at", { withTimezone: true }),
+    expiresAt: timestamp("expires_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    keyHashIdx: uniqueIndex("board_api_keys_key_hash_idx").on(table.keyHash),
+    userIdx: index("board_api_keys_user_idx").on(table.userId),
+  }),
+);

paperclip-reference/packages/db/src/schema/budget_incidents.ts

@@ -0,0 +1,42 @@
+import { sql } from "drizzle-orm";
+import { index, integer, pgTable, text, timestamp, uuid, uniqueIndex } from "drizzle-orm/pg-core";
+import { approvals } from "./approvals.js";
+import { budgetPolicies } from "./budget_policies.js";
+import { companies } from "./companies.js";
+
+export const budgetIncidents = pgTable(
+  "budget_incidents",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    policyId: uuid("policy_id").notNull().references(() => budgetPolicies.id),
+    scopeType: text("scope_type").notNull(),
+    scopeId: uuid("scope_id").notNull(),
+    metric: text("metric").notNull(),
+    windowKind: text("window_kind").notNull(),
+    windowStart: timestamp("window_start", { withTimezone: true }).notNull(),
+    windowEnd: timestamp("window_end", { withTimezone: true }).notNull(),
+    thresholdType: text("threshold_type").notNull(),
+    amountLimit: integer("amount_limit").notNull(),
+    amountObserved: integer("amount_observed").notNull(),
+    status: text("status").notNull().default("open"),
+    approvalId: uuid("approval_id").references(() => approvals.id),
+    resolvedAt: timestamp("resolved_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyStatusIdx: index("budget_incidents_company_status_idx").on(table.companyId, table.status),
+    companyScopeIdx: index("budget_incidents_company_scope_idx").on(
+      table.companyId,
+      table.scopeType,
+      table.scopeId,
+      table.status,
+    ),
+    policyWindowIdx: uniqueIndex("budget_incidents_policy_window_threshold_idx").on(
+      table.policyId,
+      table.windowStart,
+      table.thresholdType,
+    ).where(sql`${table.status} <> 'dismissed'`),
+  }),
+);

paperclip-reference/packages/db/src/schema/budget_policies.ts

@@ -0,0 +1,43 @@
+import { boolean, index, integer, pgTable, text, timestamp, uuid, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+
+export const budgetPolicies = pgTable(
+  "budget_policies",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    scopeType: text("scope_type").notNull(),
+    scopeId: uuid("scope_id").notNull(),
+    metric: text("metric").notNull().default("billed_cents"),
+    windowKind: text("window_kind").notNull(),
+    amount: integer("amount").notNull().default(0),
+    warnPercent: integer("warn_percent").notNull().default(80),
+    hardStopEnabled: boolean("hard_stop_enabled").notNull().default(true),
+    notifyEnabled: boolean("notify_enabled").notNull().default(true),
+    isActive: boolean("is_active").notNull().default(true),
+    createdByUserId: text("created_by_user_id"),
+    updatedByUserId: text("updated_by_user_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyScopeActiveIdx: index("budget_policies_company_scope_active_idx").on(
+      table.companyId,
+      table.scopeType,
+      table.scopeId,
+      table.isActive,
+    ),
+    companyWindowIdx: index("budget_policies_company_window_idx").on(
+      table.companyId,
+      table.windowKind,
+      table.metric,
+    ),
+    companyScopeMetricUniqueIdx: uniqueIndex("budget_policies_company_scope_metric_unique_idx").on(
+      table.companyId,
+      table.scopeType,
+      table.scopeId,
+      table.metric,
+      table.windowKind,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/cli_auth_challenges.ts

@@ -0,0 +1,30 @@
+import { pgTable, uuid, text, timestamp, index } from "drizzle-orm/pg-core";
+import { authUsers } from "./auth.js";
+import { companies } from "./companies.js";
+import { boardApiKeys } from "./board_api_keys.js";
+
+export const cliAuthChallenges = pgTable(
+  "cli_auth_challenges",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    secretHash: text("secret_hash").notNull(),
+    command: text("command").notNull(),
+    clientName: text("client_name"),
+    requestedAccess: text("requested_access").notNull().default("board"),
+    requestedCompanyId: uuid("requested_company_id").references(() => companies.id, { onDelete: "set null" }),
+    pendingKeyHash: text("pending_key_hash").notNull(),
+    pendingKeyName: text("pending_key_name").notNull(),
+    approvedByUserId: text("approved_by_user_id").references(() => authUsers.id, { onDelete: "set null" }),
+    boardApiKeyId: uuid("board_api_key_id").references(() => boardApiKeys.id, { onDelete: "set null" }),
+    approvedAt: timestamp("approved_at", { withTimezone: true }),
+    cancelledAt: timestamp("cancelled_at", { withTimezone: true }),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    secretHashIdx: index("cli_auth_challenges_secret_hash_idx").on(table.secretHash),
+    approvedByIdx: index("cli_auth_challenges_approved_by_idx").on(table.approvedByUserId),
+    requestedCompanyIdx: index("cli_auth_challenges_requested_company_idx").on(table.requestedCompanyId),
+  }),
+);

paperclip-reference/packages/db/src/schema/companies.ts

@@ -0,0 +1,26 @@
+import { pgTable, uuid, text, integer, timestamp, boolean, uniqueIndex } from "drizzle-orm/pg-core";
+
+export const companies = pgTable(
+  "companies",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    name: text("name").notNull(),
+    description: text("description"),
+    status: text("status").notNull().default("active"),
+    pauseReason: text("pause_reason"),
+    pausedAt: timestamp("paused_at", { withTimezone: true }),
+    issuePrefix: text("issue_prefix").notNull().default("PAP"),
+    issueCounter: integer("issue_counter").notNull().default(0),
+    budgetMonthlyCents: integer("budget_monthly_cents").notNull().default(0),
+    spentMonthlyCents: integer("spent_monthly_cents").notNull().default(0),
+    requireBoardApprovalForNewAgents: boolean("require_board_approval_for_new_agents")
+      .notNull()
+      .default(true),
+    brandColor: text("brand_color"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    issuePrefixUniqueIdx: uniqueIndex("companies_issue_prefix_idx").on(table.issuePrefix),
+  }),
+);

paperclip-reference/packages/db/src/schema/company_logos.ts

@@ -0,0 +1,18 @@
+import { pgTable, uuid, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { assets } from "./assets.js";
+
+export const companyLogos = pgTable(
+  "company_logos",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id, { onDelete: "cascade" }),
+    assetId: uuid("asset_id").notNull().references(() => assets.id, { onDelete: "cascade" }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyUq: uniqueIndex("company_logos_company_uq").on(table.companyId),
+    assetUq: uniqueIndex("company_logos_asset_uq").on(table.assetId),
+  }),
+);

paperclip-reference/packages/db/src/schema/company_memberships.ts

@@ -0,0 +1,29 @@
+import { pgTable, uuid, text, timestamp, uniqueIndex, index } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+
+export const companyMemberships = pgTable(
+  "company_memberships",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    principalType: text("principal_type").notNull(),
+    principalId: text("principal_id").notNull(),
+    status: text("status").notNull().default("active"),
+    membershipRole: text("membership_role"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyPrincipalUniqueIdx: uniqueIndex("company_memberships_company_principal_unique_idx").on(
+      table.companyId,
+      table.principalType,
+      table.principalId,
+    ),
+    principalStatusIdx: index("company_memberships_principal_status_idx").on(
+      table.principalType,
+      table.principalId,
+      table.status,
+    ),
+    companyStatusIdx: index("company_memberships_company_status_idx").on(table.companyId, table.status),
+  }),
+);

paperclip-reference/packages/db/src/schema/company_secret_versions.ts

@@ -0,0 +1,23 @@
+import { pgTable, uuid, text, timestamp, integer, jsonb, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { agents } from "./agents.js";
+import { companySecrets } from "./company_secrets.js";
+
+export const companySecretVersions = pgTable(
+  "company_secret_versions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    secretId: uuid("secret_id").notNull().references(() => companySecrets.id, { onDelete: "cascade" }),
+    version: integer("version").notNull(),
+    material: jsonb("material").$type<Record<string, unknown>>().notNull(),
+    valueSha256: text("value_sha256").notNull(),
+    createdByAgentId: uuid("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    createdByUserId: text("created_by_user_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    revokedAt: timestamp("revoked_at", { withTimezone: true }),
+  },
+  (table) => ({
+    secretIdx: index("company_secret_versions_secret_idx").on(table.secretId, table.createdAt),
+    valueHashIdx: index("company_secret_versions_value_sha256_idx").on(table.valueSha256),
+    secretVersionUq: uniqueIndex("company_secret_versions_secret_version_uq").on(table.secretId, table.version),
+  }),
+);

paperclip-reference/packages/db/src/schema/company_secrets.ts

@@ -0,0 +1,25 @@
+import { pgTable, uuid, text, timestamp, integer, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+
+export const companySecrets = pgTable(
+  "company_secrets",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    name: text("name").notNull(),
+    provider: text("provider").notNull().default("local_encrypted"),
+    externalRef: text("external_ref"),
+    latestVersion: integer("latest_version").notNull().default(1),
+    description: text("description"),
+    createdByAgentId: uuid("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    createdByUserId: text("created_by_user_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyIdx: index("company_secrets_company_idx").on(table.companyId),
+    companyProviderIdx: index("company_secrets_company_provider_idx").on(table.companyId, table.provider),
+    companyNameUq: uniqueIndex("company_secrets_company_name_uq").on(table.companyId, table.name),
+  }),
+);

paperclip-reference/packages/db/src/schema/company_skills.ts

@@ -0,0 +1,36 @@
+import {
+  pgTable,
+  uuid,
+  text,
+  timestamp,
+  jsonb,
+  index,
+  uniqueIndex,
+} from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+
+export const companySkills = pgTable(
+  "company_skills",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    key: text("key").notNull(),
+    slug: text("slug").notNull(),
+    name: text("name").notNull(),
+    description: text("description"),
+    markdown: text("markdown").notNull(),
+    sourceType: text("source_type").notNull().default("local_path"),
+    sourceLocator: text("source_locator"),
+    sourceRef: text("source_ref"),
+    trustLevel: text("trust_level").notNull().default("markdown_only"),
+    compatibility: text("compatibility").notNull().default("compatible"),
+    fileInventory: jsonb("file_inventory").$type<Array<Record<string, unknown>>>().notNull().default([]),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyKeyUniqueIdx: uniqueIndex("company_skills_company_key_idx").on(table.companyId, table.key),
+    companyNameIdx: index("company_skills_company_name_idx").on(table.companyId, table.name),
+  }),
+);

paperclip-reference/packages/db/src/schema/cost_events.ts

@@ -0,0 +1,53 @@
+import { pgTable, uuid, text, timestamp, integer, index } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+import { issues } from "./issues.js";
+import { projects } from "./projects.js";
+import { goals } from "./goals.js";
+import { heartbeatRuns } from "./heartbeat_runs.js";
+
+export const costEvents = pgTable(
+  "cost_events",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    agentId: uuid("agent_id").notNull().references(() => agents.id),
+    issueId: uuid("issue_id").references(() => issues.id),
+    projectId: uuid("project_id").references(() => projects.id),
+    goalId: uuid("goal_id").references(() => goals.id),
+    heartbeatRunId: uuid("heartbeat_run_id").references(() => heartbeatRuns.id),
+    billingCode: text("billing_code"),
+    provider: text("provider").notNull(),
+    biller: text("biller").notNull().default("unknown"),
+    billingType: text("billing_type").notNull().default("unknown"),
+    model: text("model").notNull(),
+    inputTokens: integer("input_tokens").notNull().default(0),
+    cachedInputTokens: integer("cached_input_tokens").notNull().default(0),
+    outputTokens: integer("output_tokens").notNull().default(0),
+    costCents: integer("cost_cents").notNull(),
+    occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyOccurredIdx: index("cost_events_company_occurred_idx").on(table.companyId, table.occurredAt),
+    companyAgentOccurredIdx: index("cost_events_company_agent_occurred_idx").on(
+      table.companyId,
+      table.agentId,
+      table.occurredAt,
+    ),
+    companyProviderOccurredIdx: index("cost_events_company_provider_occurred_idx").on(
+      table.companyId,
+      table.provider,
+      table.occurredAt,
+    ),
+    companyBillerOccurredIdx: index("cost_events_company_biller_occurred_idx").on(
+      table.companyId,
+      table.biller,
+      table.occurredAt,
+    ),
+    companyHeartbeatRunIdx: index("cost_events_company_heartbeat_run_idx").on(
+      table.companyId,
+      table.heartbeatRunId,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/document_revisions.ts

@@ -0,0 +1,30 @@
+import { pgTable, uuid, text, integer, timestamp, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+import { documents } from "./documents.js";
+
+export const documentRevisions = pgTable(
+  "document_revisions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+    revisionNumber: integer("revision_number").notNull(),
+    body: text("body").notNull(),
+    changeSummary: text("change_summary"),
+    createdByAgentId: uuid("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    createdByUserId: text("created_by_user_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    documentRevisionUq: uniqueIndex("document_revisions_document_revision_uq").on(
+      table.documentId,
+      table.revisionNumber,
+    ),
+    companyDocumentCreatedIdx: index("document_revisions_company_document_created_idx").on(
+      table.companyId,
+      table.documentId,
+      table.createdAt,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/documents.ts

@@ -0,0 +1,26 @@
+import { pgTable, uuid, text, integer, timestamp, index } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+
+export const documents = pgTable(
+  "documents",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    title: text("title"),
+    format: text("format").notNull().default("markdown"),
+    latestBody: text("latest_body").notNull(),
+    latestRevisionId: uuid("latest_revision_id"),
+    latestRevisionNumber: integer("latest_revision_number").notNull().default(1),
+    createdByAgentId: uuid("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    createdByUserId: text("created_by_user_id"),
+    updatedByAgentId: uuid("updated_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    updatedByUserId: text("updated_by_user_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyUpdatedIdx: index("documents_company_updated_idx").on(table.companyId, table.updatedAt),
+    companyCreatedIdx: index("documents_company_created_idx").on(table.companyId, table.createdAt),
+  }),
+);

paperclip-reference/packages/db/src/schema/execution_workspaces.ts

@@ -0,0 +1,68 @@
+import {
+  type AnyPgColumn,
+  index,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { issues } from "./issues.js";
+import { projectWorkspaces } from "./project_workspaces.js";
+import { projects } from "./projects.js";
+
+export const executionWorkspaces = pgTable(
+  "execution_workspaces",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    projectWorkspaceId: uuid("project_workspace_id").references(() => projectWorkspaces.id, { onDelete: "set null" }),
+    sourceIssueId: uuid("source_issue_id").references((): AnyPgColumn => issues.id, { onDelete: "set null" }),
+    mode: text("mode").notNull(),
+    strategyType: text("strategy_type").notNull(),
+    name: text("name").notNull(),
+    status: text("status").notNull().default("active"),
+    cwd: text("cwd"),
+    repoUrl: text("repo_url"),
+    baseRef: text("base_ref"),
+    branchName: text("branch_name"),
+    providerType: text("provider_type").notNull().default("local_fs"),
+    providerRef: text("provider_ref"),
+    derivedFromExecutionWorkspaceId: uuid("derived_from_execution_workspace_id")
+      .references((): AnyPgColumn => executionWorkspaces.id, { onDelete: "set null" }),
+    lastUsedAt: timestamp("last_used_at", { withTimezone: true }).notNull().defaultNow(),
+    openedAt: timestamp("opened_at", { withTimezone: true }).notNull().defaultNow(),
+    closedAt: timestamp("closed_at", { withTimezone: true }),
+    cleanupEligibleAt: timestamp("cleanup_eligible_at", { withTimezone: true }),
+    cleanupReason: text("cleanup_reason"),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyProjectStatusIdx: index("execution_workspaces_company_project_status_idx").on(
+      table.companyId,
+      table.projectId,
+      table.status,
+    ),
+    companyProjectWorkspaceStatusIdx: index("execution_workspaces_company_project_workspace_status_idx").on(
+      table.companyId,
+      table.projectWorkspaceId,
+      table.status,
+    ),
+    companySourceIssueIdx: index("execution_workspaces_company_source_issue_idx").on(
+      table.companyId,
+      table.sourceIssueId,
+    ),
+    companyLastUsedIdx: index("execution_workspaces_company_last_used_idx").on(
+      table.companyId,
+      table.lastUsedAt,
+    ),
+    companyBranchIdx: index("execution_workspaces_company_branch_idx").on(
+      table.companyId,
+      table.branchName,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/finance_events.ts

@@ -0,0 +1,67 @@
+import { pgTable, uuid, text, timestamp, integer, index, boolean, jsonb } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+import { issues } from "./issues.js";
+import { projects } from "./projects.js";
+import { goals } from "./goals.js";
+import { heartbeatRuns } from "./heartbeat_runs.js";
+import { costEvents } from "./cost_events.js";
+
+export const financeEvents = pgTable(
+  "finance_events",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    agentId: uuid("agent_id").references(() => agents.id),
+    issueId: uuid("issue_id").references(() => issues.id),
+    projectId: uuid("project_id").references(() => projects.id),
+    goalId: uuid("goal_id").references(() => goals.id),
+    heartbeatRunId: uuid("heartbeat_run_id").references(() => heartbeatRuns.id),
+    costEventId: uuid("cost_event_id").references(() => costEvents.id),
+    billingCode: text("billing_code"),
+    description: text("description"),
+    eventKind: text("event_kind").notNull(),
+    direction: text("direction").notNull().default("debit"),
+    biller: text("biller").notNull(),
+    provider: text("provider"),
+    executionAdapterType: text("execution_adapter_type"),
+    pricingTier: text("pricing_tier"),
+    region: text("region"),
+    model: text("model"),
+    quantity: integer("quantity"),
+    unit: text("unit"),
+    amountCents: integer("amount_cents").notNull(),
+    currency: text("currency").notNull().default("USD"),
+    estimated: boolean("estimated").notNull().default(false),
+    externalInvoiceId: text("external_invoice_id"),
+    metadataJson: jsonb("metadata_json").$type<Record<string, unknown> | null>(),
+    occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyOccurredIdx: index("finance_events_company_occurred_idx").on(table.companyId, table.occurredAt),
+    companyBillerOccurredIdx: index("finance_events_company_biller_occurred_idx").on(
+      table.companyId,
+      table.biller,
+      table.occurredAt,
+    ),
+    companyKindOccurredIdx: index("finance_events_company_kind_occurred_idx").on(
+      table.companyId,
+      table.eventKind,
+      table.occurredAt,
+    ),
+    companyDirectionOccurredIdx: index("finance_events_company_direction_occurred_idx").on(
+      table.companyId,
+      table.direction,
+      table.occurredAt,
+    ),
+    companyHeartbeatRunIdx: index("finance_events_company_heartbeat_run_idx").on(
+      table.companyId,
+      table.heartbeatRunId,
+    ),
+    companyCostEventIdx: index("finance_events_company_cost_event_idx").on(
+      table.companyId,
+      table.costEventId,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/goals.ts

@@ -0,0 +1,29 @@
+import {
+  type AnyPgColumn,
+  pgTable,
+  uuid,
+  text,
+  timestamp,
+  index,
+} from "drizzle-orm/pg-core";
+import { agents } from "./agents.js";
+import { companies } from "./companies.js";
+
+export const goals = pgTable(
+  "goals",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    title: text("title").notNull(),
+    description: text("description"),
+    level: text("level").notNull().default("task"),
+    status: text("status").notNull().default("planned"),
+    parentId: uuid("parent_id").references((): AnyPgColumn => goals.id),
+    ownerAgentId: uuid("owner_agent_id").references(() => agents.id),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyIdx: index("goals_company_idx").on(table.companyId),
+  }),
+);

paperclip-reference/packages/db/src/schema/heartbeat_run_events.ts

@@ -0,0 +1,28 @@
+import { pgTable, uuid, text, timestamp, integer, jsonb, index, bigserial } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+import { heartbeatRuns } from "./heartbeat_runs.js";
+
+export const heartbeatRunEvents = pgTable(
+  "heartbeat_run_events",
+  {
+    id: bigserial("id", { mode: "number" }).primaryKey(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    runId: uuid("run_id").notNull().references(() => heartbeatRuns.id),
+    agentId: uuid("agent_id").notNull().references(() => agents.id),
+    seq: integer("seq").notNull(),
+    eventType: text("event_type").notNull(),
+    stream: text("stream"),
+    level: text("level"),
+    color: text("color"),
+    message: text("message"),
+    payload: jsonb("payload").$type<Record<string, unknown>>(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    runSeqIdx: index("heartbeat_run_events_run_seq_idx").on(table.runId, table.seq),
+    companyRunIdx: index("heartbeat_run_events_company_run_idx").on(table.companyId, table.runId),
+    companyCreatedIdx: index("heartbeat_run_events_company_created_idx").on(table.companyId, table.createdAt),
+  }),
+);
+

paperclip-reference/packages/db/src/schema/heartbeat_runs.ts

@@ -0,0 +1,51 @@
+import { type AnyPgColumn, pgTable, uuid, text, timestamp, jsonb, index, integer, bigint, boolean } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { agents } from "./agents.js";
+import { agentWakeupRequests } from "./agent_wakeup_requests.js";
+
+export const heartbeatRuns = pgTable(
+  "heartbeat_runs",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    agentId: uuid("agent_id").notNull().references(() => agents.id),
+    invocationSource: text("invocation_source").notNull().default("on_demand"),
+    triggerDetail: text("trigger_detail"),
+    status: text("status").notNull().default("queued"),
+    startedAt: timestamp("started_at", { withTimezone: true }),
+    finishedAt: timestamp("finished_at", { withTimezone: true }),
+    error: text("error"),
+    wakeupRequestId: uuid("wakeup_request_id").references(() => agentWakeupRequests.id),
+    exitCode: integer("exit_code"),
+    signal: text("signal"),
+    usageJson: jsonb("usage_json").$type<Record<string, unknown>>(),
+    resultJson: jsonb("result_json").$type<Record<string, unknown>>(),
+    sessionIdBefore: text("session_id_before"),
+    sessionIdAfter: text("session_id_after"),
+    logStore: text("log_store"),
+    logRef: text("log_ref"),
+    logBytes: bigint("log_bytes", { mode: "number" }),
+    logSha256: text("log_sha256"),
+    logCompressed: boolean("log_compressed").notNull().default(false),
+    stdoutExcerpt: text("stdout_excerpt"),
+    stderrExcerpt: text("stderr_excerpt"),
+    errorCode: text("error_code"),
+    externalRunId: text("external_run_id"),
+    processPid: integer("process_pid"),
+    processStartedAt: timestamp("process_started_at", { withTimezone: true }),
+    retryOfRunId: uuid("retry_of_run_id").references((): AnyPgColumn => heartbeatRuns.id, {
+      onDelete: "set null",
+    }),
+    processLossRetryCount: integer("process_loss_retry_count").notNull().default(0),
+    contextSnapshot: jsonb("context_snapshot").$type<Record<string, unknown>>(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyAgentStartedIdx: index("heartbeat_runs_company_agent_started_idx").on(
+      table.companyId,
+      table.agentId,
+      table.startedAt,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/index.ts

@@ -0,0 +1,57 @@
+export { companies } from "./companies.js";
+export { companyLogos } from "./company_logos.js";
+export { authUsers, authSessions, authAccounts, authVerifications } from "./auth.js";
+export { instanceSettings } from "./instance_settings.js";
+export { instanceUserRoles } from "./instance_user_roles.js";
+export { agents } from "./agents.js";
+export { boardApiKeys } from "./board_api_keys.js";
+export { cliAuthChallenges } from "./cli_auth_challenges.js";
+export { companyMemberships } from "./company_memberships.js";
+export { principalPermissionGrants } from "./principal_permission_grants.js";
+export { invites } from "./invites.js";
+export { joinRequests } from "./join_requests.js";
+export { budgetPolicies } from "./budget_policies.js";
+export { budgetIncidents } from "./budget_incidents.js";
+export { agentConfigRevisions } from "./agent_config_revisions.js";
+export { agentApiKeys } from "./agent_api_keys.js";
+export { agentRuntimeState } from "./agent_runtime_state.js";
+export { agentTaskSessions } from "./agent_task_sessions.js";
+export { agentWakeupRequests } from "./agent_wakeup_requests.js";
+export { projects } from "./projects.js";
+export { projectWorkspaces } from "./project_workspaces.js";
+export { executionWorkspaces } from "./execution_workspaces.js";
+export { workspaceOperations } from "./workspace_operations.js";
+export { workspaceRuntimeServices } from "./workspace_runtime_services.js";
+export { projectGoals } from "./project_goals.js";
+export { goals } from "./goals.js";
+export { issues } from "./issues.js";
+export { routines, routineTriggers, routineRuns } from "./routines.js";
+export { issueWorkProducts } from "./issue_work_products.js";
+export { labels } from "./labels.js";
+export { issueLabels } from "./issue_labels.js";
+export { issueApprovals } from "./issue_approvals.js";
+export { issueComments } from "./issue_comments.js";
+export { issueReadStates } from "./issue_read_states.js";
+export { assets } from "./assets.js";
+export { issueAttachments } from "./issue_attachments.js";
+export { documents } from "./documents.js";
+export { documentRevisions } from "./document_revisions.js";
+export { issueDocuments } from "./issue_documents.js";
+export { heartbeatRuns } from "./heartbeat_runs.js";
+export { heartbeatRunEvents } from "./heartbeat_run_events.js";
+export { costEvents } from "./cost_events.js";
+export { financeEvents } from "./finance_events.js";
+export { approvals } from "./approvals.js";
+export { approvalComments } from "./approval_comments.js";
+export { activityLog } from "./activity_log.js";
+export { companySecrets } from "./company_secrets.js";
+export { companySecretVersions } from "./company_secret_versions.js";
+export { companySkills } from "./company_skills.js";
+export { plugins } from "./plugins.js";
+export { pluginConfig } from "./plugin_config.js";
+export { pluginCompanySettings } from "./plugin_company_settings.js";
+export { pluginState } from "./plugin_state.js";
+export { pluginEntities } from "./plugin_entities.js";
+export { pluginJobs, pluginJobRuns } from "./plugin_jobs.js";
+export { pluginWebhookDeliveries } from "./plugin_webhooks.js";
+export { pluginLogs } from "./plugin_logs.js";

paperclip-reference/packages/db/src/schema/instance_settings.ts

@@ -0,0 +1,16 @@
+import { pgTable, uuid, text, timestamp, jsonb, uniqueIndex } from "drizzle-orm/pg-core";
+
+export const instanceSettings = pgTable(
+  "instance_settings",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    singletonKey: text("singleton_key").notNull().default("default"),
+    general: jsonb("general").$type<Record<string, unknown>>().notNull().default({}),
+    experimental: jsonb("experimental").$type<Record<string, unknown>>().notNull().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    singletonKeyIdx: uniqueIndex("instance_settings_singleton_key_idx").on(table.singletonKey),
+  }),
+);

paperclip-reference/packages/db/src/schema/instance_user_roles.ts

@@ -0,0 +1,16 @@
+import { pgTable, uuid, text, timestamp, uniqueIndex, index } from "drizzle-orm/pg-core";
+
+export const instanceUserRoles = pgTable(
+  "instance_user_roles",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    userId: text("user_id").notNull(),
+    role: text("role").notNull().default("instance_admin"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    userRoleUniqueIdx: uniqueIndex("instance_user_roles_user_role_unique_idx").on(table.userId, table.role),
+    roleIdx: index("instance_user_roles_role_idx").on(table.role),
+  }),
+);

paperclip-reference/packages/db/src/schema/invites.ts

@@ -0,0 +1,29 @@
+import { pgTable, uuid, text, timestamp, jsonb, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+
+export const invites = pgTable(
+  "invites",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").references(() => companies.id),
+    inviteType: text("invite_type").notNull().default("company_join"),
+    tokenHash: text("token_hash").notNull(),
+    allowedJoinTypes: text("allowed_join_types").notNull().default("both"),
+    defaultsPayload: jsonb("defaults_payload").$type<Record<string, unknown> | null>(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    invitedByUserId: text("invited_by_user_id"),
+    revokedAt: timestamp("revoked_at", { withTimezone: true }),
+    acceptedAt: timestamp("accepted_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    tokenHashUniqueIdx: uniqueIndex("invites_token_hash_unique_idx").on(table.tokenHash),
+    companyInviteStateIdx: index("invites_company_invite_state_idx").on(
+      table.companyId,
+      table.inviteType,
+      table.revokedAt,
+      table.expiresAt,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/issue_approvals.ts

@@ -0,0 +1,23 @@
+import { pgTable, uuid, text, timestamp, index, primaryKey } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { issues } from "./issues.js";
+import { approvals } from "./approvals.js";
+import { agents } from "./agents.js";
+
+export const issueApprovals = pgTable(
+  "issue_approvals",
+  {
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    issueId: uuid("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+    approvalId: uuid("approval_id").notNull().references(() => approvals.id, { onDelete: "cascade" }),
+    linkedByAgentId: uuid("linked_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    linkedByUserId: text("linked_by_user_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    pk: primaryKey({ columns: [table.issueId, table.approvalId], name: "issue_approvals_pk" }),
+    issueIdx: index("issue_approvals_issue_idx").on(table.issueId),
+    approvalIdx: index("issue_approvals_approval_idx").on(table.approvalId),
+    companyIdx: index("issue_approvals_company_idx").on(table.companyId),
+  }),
+);

paperclip-reference/packages/db/src/schema/issue_attachments.ts

@@ -0,0 +1,23 @@
+import { pgTable, uuid, timestamp, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { issues } from "./issues.js";
+import { assets } from "./assets.js";
+import { issueComments } from "./issue_comments.js";
+
+export const issueAttachments = pgTable(
+  "issue_attachments",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    issueId: uuid("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+    assetId: uuid("asset_id").notNull().references(() => assets.id, { onDelete: "cascade" }),
+    issueCommentId: uuid("issue_comment_id").references(() => issueComments.id, { onDelete: "set null" }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyIssueIdx: index("issue_attachments_company_issue_idx").on(table.companyId, table.issueId),
+    issueCommentIdx: index("issue_attachments_issue_comment_idx").on(table.issueCommentId),
+    assetUq: uniqueIndex("issue_attachments_asset_uq").on(table.assetId),
+  }),
+);

paperclip-reference/packages/db/src/schema/issue_comments.ts

@@ -0,0 +1,33 @@
+import { pgTable, uuid, text, timestamp, index } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { issues } from "./issues.js";
+import { agents } from "./agents.js";
+
+export const issueComments = pgTable(
+  "issue_comments",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    issueId: uuid("issue_id").notNull().references(() => issues.id),
+    authorAgentId: uuid("author_agent_id").references(() => agents.id),
+    authorUserId: text("author_user_id"),
+    body: text("body").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    issueIdx: index("issue_comments_issue_idx").on(table.issueId),
+    companyIdx: index("issue_comments_company_idx").on(table.companyId),
+    companyIssueCreatedAtIdx: index("issue_comments_company_issue_created_at_idx").on(
+      table.companyId,
+      table.issueId,
+      table.createdAt,
+    ),
+    companyAuthorIssueCreatedAtIdx: index("issue_comments_company_author_issue_created_at_idx").on(
+      table.companyId,
+      table.authorUserId,
+      table.issueId,
+      table.createdAt,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/issue_documents.ts

@@ -0,0 +1,30 @@
+import { pgTable, uuid, text, timestamp, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { issues } from "./issues.js";
+import { documents } from "./documents.js";
+
+export const issueDocuments = pgTable(
+  "issue_documents",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    issueId: uuid("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+    documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+    key: text("key").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyIssueKeyUq: uniqueIndex("issue_documents_company_issue_key_uq").on(
+      table.companyId,
+      table.issueId,
+      table.key,
+    ),
+    documentUq: uniqueIndex("issue_documents_document_uq").on(table.documentId),
+    companyIssueUpdatedIdx: index("issue_documents_company_issue_updated_idx").on(
+      table.companyId,
+      table.issueId,
+      table.updatedAt,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/issue_labels.ts

@@ -0,0 +1,20 @@
+import { pgTable, uuid, timestamp, index, primaryKey } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { issues } from "./issues.js";
+import { labels } from "./labels.js";
+
+export const issueLabels = pgTable(
+  "issue_labels",
+  {
+    issueId: uuid("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+    labelId: uuid("label_id").notNull().references(() => labels.id, { onDelete: "cascade" }),
+    companyId: uuid("company_id").notNull().references(() => companies.id, { onDelete: "cascade" }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    pk: primaryKey({ columns: [table.issueId, table.labelId], name: "issue_labels_pk" }),
+    issueIdx: index("issue_labels_issue_idx").on(table.issueId),
+    labelIdx: index("issue_labels_label_idx").on(table.labelId),
+    companyIdx: index("issue_labels_company_idx").on(table.companyId),
+  }),
+);

paperclip-reference/packages/db/src/schema/issue_read_states.ts

@@ -0,0 +1,25 @@
+import { pgTable, uuid, text, timestamp, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { issues } from "./issues.js";
+
+export const issueReadStates = pgTable(
+  "issue_read_states",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    issueId: uuid("issue_id").notNull().references(() => issues.id),
+    userId: text("user_id").notNull(),
+    lastReadAt: timestamp("last_read_at", { withTimezone: true }).notNull().defaultNow(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyIssueIdx: index("issue_read_states_company_issue_idx").on(table.companyId, table.issueId),
+    companyUserIdx: index("issue_read_states_company_user_idx").on(table.companyId, table.userId),
+    companyIssueUserUnique: uniqueIndex("issue_read_states_company_issue_user_idx").on(
+      table.companyId,
+      table.issueId,
+      table.userId,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/issue_work_products.ts

@@ -0,0 +1,64 @@
+import {
+  boolean,
+  index,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { executionWorkspaces } from "./execution_workspaces.js";
+import { heartbeatRuns } from "./heartbeat_runs.js";
+import { issues } from "./issues.js";
+import { projects } from "./projects.js";
+import { workspaceRuntimeServices } from "./workspace_runtime_services.js";
+
+export const issueWorkProducts = pgTable(
+  "issue_work_products",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    projectId: uuid("project_id").references(() => projects.id, { onDelete: "set null" }),
+    issueId: uuid("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+    executionWorkspaceId: uuid("execution_workspace_id")
+      .references(() => executionWorkspaces.id, { onDelete: "set null" }),
+    runtimeServiceId: uuid("runtime_service_id")
+      .references(() => workspaceRuntimeServices.id, { onDelete: "set null" }),
+    type: text("type").notNull(),
+    provider: text("provider").notNull(),
+    externalId: text("external_id"),
+    title: text("title").notNull(),
+    url: text("url"),
+    status: text("status").notNull(),
+    reviewState: text("review_state").notNull().default("none"),
+    isPrimary: boolean("is_primary").notNull().default(false),
+    healthStatus: text("health_status").notNull().default("unknown"),
+    summary: text("summary"),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>(),
+    createdByRunId: uuid("created_by_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyIssueTypeIdx: index("issue_work_products_company_issue_type_idx").on(
+      table.companyId,
+      table.issueId,
+      table.type,
+    ),
+    companyExecutionWorkspaceTypeIdx: index("issue_work_products_company_execution_workspace_type_idx").on(
+      table.companyId,
+      table.executionWorkspaceId,
+      table.type,
+    ),
+    companyProviderExternalIdIdx: index("issue_work_products_company_provider_external_id_idx").on(
+      table.companyId,
+      table.provider,
+      table.externalId,
+    ),
+    companyUpdatedIdx: index("issue_work_products_company_updated_idx").on(
+      table.companyId,
+      table.updatedAt,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/issues.ts

@@ -0,0 +1,89 @@
+import { sql } from "drizzle-orm";
+import {
+  type AnyPgColumn,
+  pgTable,
+  uuid,
+  text,
+  timestamp,
+  integer,
+  jsonb,
+  index,
+  uniqueIndex,
+} from "drizzle-orm/pg-core";
+import { agents } from "./agents.js";
+import { projects } from "./projects.js";
+import { goals } from "./goals.js";
+import { companies } from "./companies.js";
+import { heartbeatRuns } from "./heartbeat_runs.js";
+import { projectWorkspaces } from "./project_workspaces.js";
+import { executionWorkspaces } from "./execution_workspaces.js";
+
+export const issues = pgTable(
+  "issues",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    projectId: uuid("project_id").references(() => projects.id),
+    projectWorkspaceId: uuid("project_workspace_id").references(() => projectWorkspaces.id, { onDelete: "set null" }),
+    goalId: uuid("goal_id").references(() => goals.id),
+    parentId: uuid("parent_id").references((): AnyPgColumn => issues.id),
+    title: text("title").notNull(),
+    description: text("description"),
+    status: text("status").notNull().default("backlog"),
+    priority: text("priority").notNull().default("medium"),
+    assigneeAgentId: uuid("assignee_agent_id").references(() => agents.id),
+    assigneeUserId: text("assignee_user_id"),
+    checkoutRunId: uuid("checkout_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
+    executionRunId: uuid("execution_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
+    executionAgentNameKey: text("execution_agent_name_key"),
+    executionLockedAt: timestamp("execution_locked_at", { withTimezone: true }),
+    createdByAgentId: uuid("created_by_agent_id").references(() => agents.id),
+    createdByUserId: text("created_by_user_id"),
+    issueNumber: integer("issue_number"),
+    identifier: text("identifier"),
+    originKind: text("origin_kind").notNull().default("manual"),
+    originId: text("origin_id"),
+    originRunId: text("origin_run_id"),
+    requestDepth: integer("request_depth").notNull().default(0),
+    billingCode: text("billing_code"),
+    assigneeAdapterOverrides: jsonb("assignee_adapter_overrides").$type<Record<string, unknown>>(),
+    executionWorkspaceId: uuid("execution_workspace_id")
+      .references((): AnyPgColumn => executionWorkspaces.id, { onDelete: "set null" }),
+    executionWorkspacePreference: text("execution_workspace_preference"),
+    executionWorkspaceSettings: jsonb("execution_workspace_settings").$type<Record<string, unknown>>(),
+    startedAt: timestamp("started_at", { withTimezone: true }),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    cancelledAt: timestamp("cancelled_at", { withTimezone: true }),
+    hiddenAt: timestamp("hidden_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyStatusIdx: index("issues_company_status_idx").on(table.companyId, table.status),
+    assigneeStatusIdx: index("issues_company_assignee_status_idx").on(
+      table.companyId,
+      table.assigneeAgentId,
+      table.status,
+    ),
+    assigneeUserStatusIdx: index("issues_company_assignee_user_status_idx").on(
+      table.companyId,
+      table.assigneeUserId,
+      table.status,
+    ),
+    parentIdx: index("issues_company_parent_idx").on(table.companyId, table.parentId),
+    projectIdx: index("issues_company_project_idx").on(table.companyId, table.projectId),
+    originIdx: index("issues_company_origin_idx").on(table.companyId, table.originKind, table.originId),
+    projectWorkspaceIdx: index("issues_company_project_workspace_idx").on(table.companyId, table.projectWorkspaceId),
+    executionWorkspaceIdx: index("issues_company_execution_workspace_idx").on(table.companyId, table.executionWorkspaceId),
+    identifierIdx: uniqueIndex("issues_identifier_idx").on(table.identifier),
+    openRoutineExecutionIdx: uniqueIndex("issues_open_routine_execution_uq")
+      .on(table.companyId, table.originKind, table.originId)
+      .where(
+        sql`${table.originKind} = 'routine_execution'
+          and ${table.originId} is not null
+          and ${table.hiddenAt} is null
+          and ${table.executionRunId} is not null
+          and ${table.status} in ('backlog', 'todo', 'in_progress', 'in_review', 'blocked')`,
+      ),
+  }),
+);

paperclip-reference/packages/db/src/schema/join_requests.ts

@@ -0,0 +1,41 @@
+import { pgTable, uuid, text, timestamp, jsonb, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { invites } from "./invites.js";
+import { agents } from "./agents.js";
+
+export const joinRequests = pgTable(
+  "join_requests",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    inviteId: uuid("invite_id").notNull().references(() => invites.id),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    requestType: text("request_type").notNull(),
+    status: text("status").notNull().default("pending_approval"),
+    requestIp: text("request_ip").notNull(),
+    requestingUserId: text("requesting_user_id"),
+    requestEmailSnapshot: text("request_email_snapshot"),
+    agentName: text("agent_name"),
+    adapterType: text("adapter_type"),
+    capabilities: text("capabilities"),
+    agentDefaultsPayload: jsonb("agent_defaults_payload").$type<Record<string, unknown> | null>(),
+    claimSecretHash: text("claim_secret_hash"),
+    claimSecretExpiresAt: timestamp("claim_secret_expires_at", { withTimezone: true }),
+    claimSecretConsumedAt: timestamp("claim_secret_consumed_at", { withTimezone: true }),
+    createdAgentId: uuid("created_agent_id").references(() => agents.id),
+    approvedByUserId: text("approved_by_user_id"),
+    approvedAt: timestamp("approved_at", { withTimezone: true }),
+    rejectedByUserId: text("rejected_by_user_id"),
+    rejectedAt: timestamp("rejected_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    inviteUniqueIdx: uniqueIndex("join_requests_invite_unique_idx").on(table.inviteId),
+    companyStatusTypeCreatedIdx: index("join_requests_company_status_type_created_idx").on(
+      table.companyId,
+      table.status,
+      table.requestType,
+      table.createdAt,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/labels.ts

@@ -0,0 +1,18 @@
+import { pgTable, uuid, text, timestamp, index, uniqueIndex } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+
+export const labels = pgTable(
+  "labels",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    color: text("color").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyIdx: index("labels_company_idx").on(table.companyId),
+    companyNameIdx: uniqueIndex("labels_company_name_idx").on(table.companyId, table.name),
+  }),
+);

paperclip-reference/packages/db/src/schema/plugin_company_settings.ts

@@ -0,0 +1,41 @@
+import { pgTable, uuid, text, timestamp, jsonb, index, uniqueIndex, boolean } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { plugins } from "./plugins.js";
+
+/**
+ * `plugin_company_settings` table — stores operator-managed plugin settings
+ * scoped to a specific company.
+ *
+ * This is distinct from `plugin_config`, which stores instance-wide plugin
+ * configuration. Each company can have at most one settings row per plugin.
+ *
+ * Rows represent explicit overrides from the default company behavior:
+ * - no row => plugin is enabled for the company by default
+ * - row with `enabled = false` => plugin is disabled for that company
+ * - row with `enabled = true` => plugin remains enabled and stores company settings
+ */
+export const pluginCompanySettings = pgTable(
+  "plugin_company_settings",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id")
+      .notNull()
+      .references(() => companies.id, { onDelete: "cascade" }),
+    pluginId: uuid("plugin_id")
+      .notNull()
+      .references(() => plugins.id, { onDelete: "cascade" }),
+    enabled: boolean("enabled").notNull().default(true),
+    settingsJson: jsonb("settings_json").$type<Record<string, unknown>>().notNull().default({}),
+    lastError: text("last_error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyIdx: index("plugin_company_settings_company_idx").on(table.companyId),
+    pluginIdx: index("plugin_company_settings_plugin_idx").on(table.pluginId),
+    companyPluginUq: uniqueIndex("plugin_company_settings_company_plugin_uq").on(
+      table.companyId,
+      table.pluginId,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/plugin_config.ts

@@ -0,0 +1,30 @@
+import { pgTable, uuid, text, timestamp, jsonb, uniqueIndex } from "drizzle-orm/pg-core";
+import { plugins } from "./plugins.js";
+
+/**
+ * `plugin_config` table — stores operator-provided instance configuration
+ * for each plugin (one row per plugin, enforced by a unique index on
+ * `plugin_id`).
+ *
+ * The `config_json` column holds the values that the operator enters in the
+ * plugin settings UI. These values are validated at runtime against the
+ * plugin's `instanceConfigSchema` from the manifest.
+ *
+ * @see PLUGIN_SPEC.md §21.3
+ */
+export const pluginConfig = pgTable(
+  "plugin_config",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    pluginId: uuid("plugin_id")
+      .notNull()
+      .references(() => plugins.id, { onDelete: "cascade" }),
+    configJson: jsonb("config_json").$type<Record<string, unknown>>().notNull().default({}),
+    lastError: text("last_error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    pluginIdIdx: uniqueIndex("plugin_config_plugin_id_idx").on(table.pluginId),
+  }),
+);

paperclip-reference/packages/db/src/schema/plugin_entities.ts

@@ -0,0 +1,54 @@
+import {
+  pgTable,
+  uuid,
+  text,
+  timestamp,
+  jsonb,
+  index,
+  uniqueIndex,
+} from "drizzle-orm/pg-core";
+import { plugins } from "./plugins.js";
+import type { PluginStateScopeKind } from "@paperclipai/shared";
+
+/**
+ * `plugin_entities` table — persistent high-level mapping between Paperclip
+ * objects and external plugin-defined entities.
+ *
+ * This table is used by plugins (e.g. `linear`, `github`) to store pointers
+ * to their respective external IDs for projects, issues, etc. and to store
+ * their custom data.
+ *
+ * Unlike `plugin_state`, which is for raw K-V persistence, `plugin_entities`
+ * is intended for structured object mappings that the host can understand
+ * and query for cross-plugin UI integration.
+ *
+ * @see PLUGIN_SPEC.md §21.3
+ */
+export const pluginEntities = pgTable(
+  "plugin_entities",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    pluginId: uuid("plugin_id")
+      .notNull()
+      .references(() => plugins.id, { onDelete: "cascade" }),
+    entityType: text("entity_type").notNull(),
+    scopeKind: text("scope_kind").$type<PluginStateScopeKind>().notNull(),
+    scopeId: text("scope_id"), // NULL for global scope (text to match plugin_state.scope_id)
+    externalId: text("external_id"), // ID in the external system
+    title: text("title"),
+    status: text("status"),
+    data: jsonb("data").$type<Record<string, unknown>>().notNull().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    pluginIdx: index("plugin_entities_plugin_idx").on(table.pluginId),
+    typeIdx: index("plugin_entities_type_idx").on(table.entityType),
+    scopeIdx: index("plugin_entities_scope_idx").on(table.scopeKind, table.scopeId),
+    externalIdx: uniqueIndex("plugin_entities_external_idx").on(
+      table.pluginId,
+      table.entityType,
+      table.externalId,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/plugin_jobs.ts

@@ -0,0 +1,102 @@
+import {
+  pgTable,
+  uuid,
+  text,
+  integer,
+  timestamp,
+  jsonb,
+  index,
+  uniqueIndex,
+} from "drizzle-orm/pg-core";
+import { plugins } from "./plugins.js";
+import type { PluginJobStatus, PluginJobRunStatus, PluginJobRunTrigger } from "@paperclipai/shared";
+
+/**
+ * `plugin_jobs` table — registration and runtime configuration for
+ * scheduled jobs declared by plugins in their manifests.
+ *
+ * Each row represents one scheduled job entry for a plugin. The
+ * `job_key` matches the key declared in the manifest's `jobs` array.
+ * The `schedule` column stores the cron expression or interval string
+ * used by the job scheduler to decide when to fire the job.
+ *
+ * Status values:
+ * - `active` — job is enabled and will run on schedule
+ * - `paused` — job is temporarily disabled by the operator
+ * - `error` — job has been disabled due to repeated failures
+ *
+ * @see PLUGIN_SPEC.md §21.3 — `plugin_jobs`
+ */
+export const pluginJobs = pgTable(
+  "plugin_jobs",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    /** FK to the owning plugin. Cascades on delete. */
+    pluginId: uuid("plugin_id")
+      .notNull()
+      .references(() => plugins.id, { onDelete: "cascade" }),
+    /** Identifier matching the key in the plugin manifest's `jobs` array. */
+    jobKey: text("job_key").notNull(),
+    /** Cron expression (e.g. `"0 * * * *"`) or interval string. */
+    schedule: text("schedule").notNull(),
+    /** Current scheduling state. */
+    status: text("status").$type<PluginJobStatus>().notNull().default("active"),
+    /** Timestamp of the most recent successful execution. */
+    lastRunAt: timestamp("last_run_at", { withTimezone: true }),
+    /** Pre-computed timestamp of the next scheduled execution. */
+    nextRunAt: timestamp("next_run_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    pluginIdx: index("plugin_jobs_plugin_idx").on(table.pluginId),
+    nextRunIdx: index("plugin_jobs_next_run_idx").on(table.nextRunAt),
+    uniqueJobIdx: uniqueIndex("plugin_jobs_unique_idx").on(table.pluginId, table.jobKey),
+  }),
+);
+
+/**
+ * `plugin_job_runs` table — immutable execution history for plugin-owned jobs.
+ *
+ * Each row is created when a job run begins and updated when it completes.
+ * Rows are never modified after `status` reaches a terminal value
+ * (`succeeded` | `failed` | `cancelled`).
+ *
+ * Trigger values:
+ * - `scheduled` — fired automatically by the cron/interval scheduler
+ * - `manual` — triggered by an operator via the admin UI or API
+ *
+ * @see PLUGIN_SPEC.md §21.3 — `plugin_job_runs`
+ */
+export const pluginJobRuns = pgTable(
+  "plugin_job_runs",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    /** FK to the parent job definition. Cascades on delete. */
+    jobId: uuid("job_id")
+      .notNull()
+      .references(() => pluginJobs.id, { onDelete: "cascade" }),
+    /** Denormalized FK to the owning plugin for efficient querying. Cascades on delete. */
+    pluginId: uuid("plugin_id")
+      .notNull()
+      .references(() => plugins.id, { onDelete: "cascade" }),
+    /** What caused this run to start (`"scheduled"` or `"manual"`). */
+    trigger: text("trigger").$type<PluginJobRunTrigger>().notNull(),
+    /** Current lifecycle state of this run. */
+    status: text("status").$type<PluginJobRunStatus>().notNull().default("pending"),
+    /** Wall-clock duration in milliseconds. Null until the run finishes. */
+    durationMs: integer("duration_ms"),
+    /** Error message if `status === "failed"`. */
+    error: text("error"),
+    /** Ordered list of log lines emitted during this run. */
+    logs: jsonb("logs").$type<string[]>().notNull().default([]),
+    startedAt: timestamp("started_at", { withTimezone: true }),
+    finishedAt: timestamp("finished_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    jobIdx: index("plugin_job_runs_job_idx").on(table.jobId),
+    pluginIdx: index("plugin_job_runs_plugin_idx").on(table.pluginId),
+    statusIdx: index("plugin_job_runs_status_idx").on(table.status),
+  }),
+);

paperclip-reference/packages/db/src/schema/plugin_logs.ts

@@ -0,0 +1,43 @@
+import {
+  pgTable,
+  uuid,
+  text,
+  timestamp,
+  jsonb,
+  index,
+} from "drizzle-orm/pg-core";
+import { plugins } from "./plugins.js";
+
+/**
+ * `plugin_logs` table — structured log storage for plugin workers.
+ *
+ * Each row stores a single log entry emitted by a plugin worker via
+ * `ctx.logger.info(...)` etc. Logs are queryable by plugin, level, and
+ * time range to support the operator logs panel and debugging workflows.
+ *
+ * Rows are inserted by the host when handling `log` notifications from
+ * the worker process. A capped retention policy can be applied via
+ * periodic cleanup (e.g. delete rows older than 7 days).
+ *
+ * @see PLUGIN_SPEC.md §26 — Observability
+ */
+export const pluginLogs = pgTable(
+  "plugin_logs",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    pluginId: uuid("plugin_id")
+      .notNull()
+      .references(() => plugins.id, { onDelete: "cascade" }),
+    level: text("level").notNull().default("info"),
+    message: text("message").notNull(),
+    meta: jsonb("meta").$type<Record<string, unknown>>(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    pluginTimeIdx: index("plugin_logs_plugin_time_idx").on(
+      table.pluginId,
+      table.createdAt,
+    ),
+    levelIdx: index("plugin_logs_level_idx").on(table.level),
+  }),
+);

paperclip-reference/packages/db/src/schema/plugin_state.ts

@@ -0,0 +1,90 @@
+import {
+  pgTable,
+  uuid,
+  text,
+  timestamp,
+  jsonb,
+  index,
+  unique,
+} from "drizzle-orm/pg-core";
+import type { PluginStateScopeKind } from "@paperclipai/shared";
+import { plugins } from "./plugins.js";
+
+/**
+ * `plugin_state` table — scoped key-value storage for plugin workers.
+ *
+ * Each row stores a single JSON value identified by
+ * `(plugin_id, scope_kind, scope_id, namespace, state_key)`. Plugins use
+ * this table through `ctx.state.get()`, `ctx.state.set()`, and
+ * `ctx.state.delete()` in the SDK.
+ *
+ * Scope kinds determine the granularity of isolation:
+ * - `instance` — one value shared across the whole Paperclip instance
+ * - `company` — one value per company
+ * - `project` — one value per project
+ * - `project_workspace` — one value per project workspace
+ * - `agent` — one value per agent
+ * - `issue` — one value per issue
+ * - `goal` — one value per goal
+ * - `run` — one value per agent run
+ *
+ * The `namespace` column defaults to `"default"` and can be used to
+ * logically group keys without polluting the root namespace.
+ *
+ * @see PLUGIN_SPEC.md §21.3 — `plugin_state`
+ */
+export const pluginState = pgTable(
+  "plugin_state",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    /** FK to the owning plugin. Cascades on delete. */
+    pluginId: uuid("plugin_id")
+      .notNull()
+      .references(() => plugins.id, { onDelete: "cascade" }),
+    /** Granularity of the scope (e.g. `"instance"`, `"project"`, `"issue"`). */
+    scopeKind: text("scope_kind").$type<PluginStateScopeKind>().notNull(),
+    /**
+     * UUID or text identifier for the scoped object.
+     * Null for `instance` scope (which has no associated entity).
+     */
+    scopeId: text("scope_id"),
+    /**
+     * Sub-namespace to avoid key collisions within a scope.
+     * Defaults to `"default"` if the plugin does not specify one.
+     */
+    namespace: text("namespace").notNull().default("default"),
+    /** The key identifying this state entry within the namespace. */
+    stateKey: text("state_key").notNull(),
+    /** JSON-serializable value stored by the plugin. */
+    valueJson: jsonb("value_json").notNull(),
+    /** Timestamp of the most recent write. */
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    /**
+     * Unique constraint enforces that there is at most one value per
+     * (plugin, scope kind, scope id, namespace, key) tuple.
+     *
+     * `nullsNotDistinct()` is required so that `scope_id IS NULL` entries
+     * (used by `instance` scope) are treated as equal by PostgreSQL rather
+     * than as distinct nulls — otherwise the upsert target in `set()` would
+     * fail to match existing rows and create duplicates.
+     *
+     * Requires PostgreSQL 15+.
+     */
+    uniqueEntry: unique("plugin_state_unique_entry_idx")
+      .on(
+        table.pluginId,
+        table.scopeKind,
+        table.scopeId,
+        table.namespace,
+        table.stateKey,
+      )
+      .nullsNotDistinct(),
+    /** Speed up lookups by plugin + scope kind (most common access pattern). */
+    pluginScopeIdx: index("plugin_state_plugin_scope_idx").on(
+      table.pluginId,
+      table.scopeKind,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/plugin_webhooks.ts

@@ -0,0 +1,65 @@
+import {
+  pgTable,
+  uuid,
+  text,
+  integer,
+  timestamp,
+  jsonb,
+  index,
+} from "drizzle-orm/pg-core";
+import { plugins } from "./plugins.js";
+import type { PluginWebhookDeliveryStatus } from "@paperclipai/shared";
+
+/**
+ * `plugin_webhook_deliveries` table — inbound webhook delivery history for plugins.
+ *
+ * When an external system sends an HTTP POST to a plugin's registered webhook
+ * endpoint (e.g. `/api/plugins/:pluginKey/webhooks/:webhookKey`), the server
+ * creates a row in this table before dispatching the payload to the plugin
+ * worker. This provides an auditable log of every delivery attempt.
+ *
+ * The `webhook_key` matches the key declared in the plugin manifest's
+ * `webhooks` array. `external_id` is an optional identifier supplied by the
+ * remote system (e.g. a GitHub delivery GUID) that can be used to detect
+ * and reject duplicate deliveries.
+ *
+ * Status values:
+ * - `pending` — received but not yet dispatched to the worker
+ * - `processing` — currently being handled by the plugin worker
+ * - `succeeded` — worker processed the payload successfully
+ * - `failed` — worker returned an error or timed out
+ *
+ * @see PLUGIN_SPEC.md §21.3 — `plugin_webhook_deliveries`
+ */
+export const pluginWebhookDeliveries = pgTable(
+  "plugin_webhook_deliveries",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    /** FK to the owning plugin. Cascades on delete. */
+    pluginId: uuid("plugin_id")
+      .notNull()
+      .references(() => plugins.id, { onDelete: "cascade" }),
+    /** Identifier matching the key in the plugin manifest's `webhooks` array. */
+    webhookKey: text("webhook_key").notNull(),
+    /** Optional de-duplication ID provided by the external system. */
+    externalId: text("external_id"),
+    /** Current delivery state. */
+    status: text("status").$type<PluginWebhookDeliveryStatus>().notNull().default("pending"),
+    /** Wall-clock processing duration in milliseconds. Null until delivery finishes. */
+    durationMs: integer("duration_ms"),
+    /** Error message if `status === "failed"`. */
+    error: text("error"),
+    /** Raw JSON body of the inbound HTTP request. */
+    payload: jsonb("payload").$type<Record<string, unknown>>().notNull(),
+    /** Relevant HTTP headers from the inbound request (e.g. signature headers). */
+    headers: jsonb("headers").$type<Record<string, string>>().notNull().default({}),
+    startedAt: timestamp("started_at", { withTimezone: true }),
+    finishedAt: timestamp("finished_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    pluginIdx: index("plugin_webhook_deliveries_plugin_idx").on(table.pluginId),
+    statusIdx: index("plugin_webhook_deliveries_status_idx").on(table.status),
+    keyIdx: index("plugin_webhook_deliveries_key_idx").on(table.webhookKey),
+  }),
+);

paperclip-reference/packages/db/src/schema/plugins.ts

@@ -0,0 +1,45 @@
+import {
+  pgTable,
+  uuid,
+  text,
+  integer,
+  timestamp,
+  jsonb,
+  index,
+  uniqueIndex,
+} from "drizzle-orm/pg-core";
+import type { PluginCategory, PluginStatus, PaperclipPluginManifestV1 } from "@paperclipai/shared";
+
+/**
+ * `plugins` table — stores one row per installed plugin.
+ *
+ * Each plugin is uniquely identified by `plugin_key` (derived from
+ * the manifest `id`). The full manifest is persisted as JSONB in
+ * `manifest_json` so the host can reconstruct capability and UI
+ * slot information without loading the plugin package.
+ *
+ * @see PLUGIN_SPEC.md §21.3
+ */
+export const plugins = pgTable(
+  "plugins",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    pluginKey: text("plugin_key").notNull(),
+    packageName: text("package_name").notNull(),
+    version: text("version").notNull(),
+    apiVersion: integer("api_version").notNull().default(1),
+    categories: jsonb("categories").$type<PluginCategory[]>().notNull().default([]),
+    manifestJson: jsonb("manifest_json").$type<PaperclipPluginManifestV1>().notNull(),
+    status: text("status").$type<PluginStatus>().notNull().default("installed"),
+    installOrder: integer("install_order"),
+    /** Resolved package path for local-path installs; used to find worker entrypoint. */
+    packagePath: text("package_path"),
+    lastError: text("last_error"),
+    installedAt: timestamp("installed_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    pluginKeyIdx: uniqueIndex("plugins_plugin_key_idx").on(table.pluginKey),
+    statusIdx: index("plugins_status_idx").on(table.status),
+  }),
+);

paperclip-reference/packages/db/src/schema/principal_permission_grants.ts

@@ -0,0 +1,29 @@
+import { pgTable, uuid, text, timestamp, jsonb, uniqueIndex, index } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+
+export const principalPermissionGrants = pgTable(
+  "principal_permission_grants",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    principalType: text("principal_type").notNull(),
+    principalId: text("principal_id").notNull(),
+    permissionKey: text("permission_key").notNull(),
+    scope: jsonb("scope").$type<Record<string, unknown> | null>(),
+    grantedByUserId: text("granted_by_user_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    uniqueGrantIdx: uniqueIndex("principal_permission_grants_unique_idx").on(
+      table.companyId,
+      table.principalType,
+      table.principalId,
+      table.permissionKey,
+    ),
+    companyPermissionIdx: index("principal_permission_grants_company_permission_idx").on(
+      table.companyId,
+      table.permissionKey,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/project_goals.ts

@@ -0,0 +1,21 @@
+import { pgTable, uuid, timestamp, index, primaryKey } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { projects } from "./projects.js";
+import { goals } from "./goals.js";
+
+export const projectGoals = pgTable(
+  "project_goals",
+  {
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    goalId: uuid("goal_id").notNull().references(() => goals.id, { onDelete: "cascade" }),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    pk: primaryKey({ columns: [table.projectId, table.goalId] }),
+    projectIdx: index("project_goals_project_idx").on(table.projectId),
+    goalIdx: index("project_goals_goal_idx").on(table.goalId),
+    companyIdx: index("project_goals_company_idx").on(table.companyId),
+  }),
+);

paperclip-reference/packages/db/src/schema/project_workspaces.ts

@@ -0,0 +1,45 @@
+import {
+  boolean,
+  index,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { projects } from "./projects.js";
+
+export const projectWorkspaces = pgTable(
+  "project_workspaces",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    sourceType: text("source_type").notNull().default("local_path"),
+    cwd: text("cwd"),
+    repoUrl: text("repo_url"),
+    repoRef: text("repo_ref"),
+    defaultRef: text("default_ref"),
+    visibility: text("visibility").notNull().default("default"),
+    setupCommand: text("setup_command"),
+    cleanupCommand: text("cleanup_command"),
+    remoteProvider: text("remote_provider"),
+    remoteWorkspaceRef: text("remote_workspace_ref"),
+    sharedWorkspaceKey: text("shared_workspace_key"),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>(),
+    isPrimary: boolean("is_primary").notNull().default(false),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyProjectIdx: index("project_workspaces_company_project_idx").on(table.companyId, table.projectId),
+    projectPrimaryIdx: index("project_workspaces_project_primary_idx").on(table.projectId, table.isPrimary),
+    projectSourceTypeIdx: index("project_workspaces_project_source_type_idx").on(table.projectId, table.sourceType),
+    companySharedKeyIdx: index("project_workspaces_company_shared_key_idx").on(table.companyId, table.sharedWorkspaceKey),
+    projectRemoteRefIdx: uniqueIndex("project_workspaces_project_remote_ref_idx")
+      .on(table.projectId, table.remoteProvider, table.remoteWorkspaceRef),
+  }),
+);

paperclip-reference/packages/db/src/schema/projects.ts

@@ -0,0 +1,28 @@
+import { pgTable, uuid, text, timestamp, date, index, jsonb } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { goals } from "./goals.js";
+import { agents } from "./agents.js";
+
+export const projects = pgTable(
+  "projects",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    goalId: uuid("goal_id").references(() => goals.id),
+    name: text("name").notNull(),
+    description: text("description"),
+    status: text("status").notNull().default("backlog"),
+    leadAgentId: uuid("lead_agent_id").references(() => agents.id),
+    targetDate: date("target_date"),
+    color: text("color"),
+    pauseReason: text("pause_reason"),
+    pausedAt: timestamp("paused_at", { withTimezone: true }),
+    executionWorkspacePolicy: jsonb("execution_workspace_policy").$type<Record<string, unknown>>(),
+    archivedAt: timestamp("archived_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyIdx: index("projects_company_idx").on(table.companyId),
+  }),
+);

paperclip-reference/packages/db/src/schema/routines.ts

@@ -0,0 +1,110 @@
+import {
+  boolean,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { agents } from "./agents.js";
+import { companies } from "./companies.js";
+import { companySecrets } from "./company_secrets.js";
+import { issues } from "./issues.js";
+import { projects } from "./projects.js";
+import { goals } from "./goals.js";
+
+export const routines = pgTable(
+  "routines",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id, { onDelete: "cascade" }),
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    goalId: uuid("goal_id").references(() => goals.id, { onDelete: "set null" }),
+    parentIssueId: uuid("parent_issue_id").references(() => issues.id, { onDelete: "set null" }),
+    title: text("title").notNull(),
+    description: text("description"),
+    assigneeAgentId: uuid("assignee_agent_id").notNull().references(() => agents.id),
+    priority: text("priority").notNull().default("medium"),
+    status: text("status").notNull().default("active"),
+    concurrencyPolicy: text("concurrency_policy").notNull().default("coalesce_if_active"),
+    catchUpPolicy: text("catch_up_policy").notNull().default("skip_missed"),
+    createdByAgentId: uuid("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    createdByUserId: text("created_by_user_id"),
+    updatedByAgentId: uuid("updated_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    updatedByUserId: text("updated_by_user_id"),
+    lastTriggeredAt: timestamp("last_triggered_at", { withTimezone: true }),
+    lastEnqueuedAt: timestamp("last_enqueued_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyStatusIdx: index("routines_company_status_idx").on(table.companyId, table.status),
+    companyAssigneeIdx: index("routines_company_assignee_idx").on(table.companyId, table.assigneeAgentId),
+    companyProjectIdx: index("routines_company_project_idx").on(table.companyId, table.projectId),
+  }),
+);
+
+export const routineTriggers = pgTable(
+  "routine_triggers",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id, { onDelete: "cascade" }),
+    routineId: uuid("routine_id").notNull().references(() => routines.id, { onDelete: "cascade" }),
+    kind: text("kind").notNull(),
+    label: text("label"),
+    enabled: boolean("enabled").notNull().default(true),
+    cronExpression: text("cron_expression"),
+    timezone: text("timezone"),
+    nextRunAt: timestamp("next_run_at", { withTimezone: true }),
+    lastFiredAt: timestamp("last_fired_at", { withTimezone: true }),
+    publicId: text("public_id"),
+    secretId: uuid("secret_id").references(() => companySecrets.id, { onDelete: "set null" }),
+    signingMode: text("signing_mode"),
+    replayWindowSec: integer("replay_window_sec"),
+    lastRotatedAt: timestamp("last_rotated_at", { withTimezone: true }),
+    lastResult: text("last_result"),
+    createdByAgentId: uuid("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    createdByUserId: text("created_by_user_id"),
+    updatedByAgentId: uuid("updated_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    updatedByUserId: text("updated_by_user_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyRoutineIdx: index("routine_triggers_company_routine_idx").on(table.companyId, table.routineId),
+    companyKindIdx: index("routine_triggers_company_kind_idx").on(table.companyId, table.kind),
+    nextRunIdx: index("routine_triggers_next_run_idx").on(table.nextRunAt),
+    publicIdIdx: index("routine_triggers_public_id_idx").on(table.publicId),
+    publicIdUq: uniqueIndex("routine_triggers_public_id_uq").on(table.publicId),
+  }),
+);
+
+export const routineRuns = pgTable(
+  "routine_runs",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id, { onDelete: "cascade" }),
+    routineId: uuid("routine_id").notNull().references(() => routines.id, { onDelete: "cascade" }),
+    triggerId: uuid("trigger_id").references(() => routineTriggers.id, { onDelete: "set null" }),
+    source: text("source").notNull(),
+    status: text("status").notNull().default("received"),
+    triggeredAt: timestamp("triggered_at", { withTimezone: true }).notNull().defaultNow(),
+    idempotencyKey: text("idempotency_key"),
+    triggerPayload: jsonb("trigger_payload").$type<Record<string, unknown>>(),
+    linkedIssueId: uuid("linked_issue_id").references(() => issues.id, { onDelete: "set null" }),
+    coalescedIntoRunId: uuid("coalesced_into_run_id"),
+    failureReason: text("failure_reason"),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyRoutineIdx: index("routine_runs_company_routine_idx").on(table.companyId, table.routineId, table.createdAt),
+    triggerIdx: index("routine_runs_trigger_idx").on(table.triggerId, table.createdAt),
+    linkedIssueIdx: index("routine_runs_linked_issue_idx").on(table.linkedIssueId),
+    idempotencyIdx: index("routine_runs_trigger_idempotency_idx").on(table.triggerId, table.idempotencyKey),
+  }),
+);

paperclip-reference/packages/db/src/schema/workspace_operations.ts

@@ -0,0 +1,57 @@
+import {
+  bigint,
+  boolean,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { executionWorkspaces } from "./execution_workspaces.js";
+import { heartbeatRuns } from "./heartbeat_runs.js";
+
+export const workspaceOperations = pgTable(
+  "workspace_operations",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    executionWorkspaceId: uuid("execution_workspace_id").references(() => executionWorkspaces.id, {
+      onDelete: "set null",
+    }),
+    heartbeatRunId: uuid("heartbeat_run_id").references(() => heartbeatRuns.id, {
+      onDelete: "set null",
+    }),
+    phase: text("phase").notNull(),
+    command: text("command"),
+    cwd: text("cwd"),
+    status: text("status").notNull().default("running"),
+    exitCode: integer("exit_code"),
+    logStore: text("log_store"),
+    logRef: text("log_ref"),
+    logBytes: bigint("log_bytes", { mode: "number" }),
+    logSha256: text("log_sha256"),
+    logCompressed: boolean("log_compressed").notNull().default(false),
+    stdoutExcerpt: text("stdout_excerpt"),
+    stderrExcerpt: text("stderr_excerpt"),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>(),
+    startedAt: timestamp("started_at", { withTimezone: true }).notNull().defaultNow(),
+    finishedAt: timestamp("finished_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyRunStartedIdx: index("workspace_operations_company_run_started_idx").on(
+      table.companyId,
+      table.heartbeatRunId,
+      table.startedAt,
+    ),
+    companyWorkspaceStartedIdx: index("workspace_operations_company_workspace_started_idx").on(
+      table.companyId,
+      table.executionWorkspaceId,
+      table.startedAt,
+    ),
+  }),
+);

paperclip-reference/packages/db/src/schema/workspace_runtime_services.ts

@@ -0,0 +1,71 @@
+import {
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { projects } from "./projects.js";
+import { projectWorkspaces } from "./project_workspaces.js";
+import { executionWorkspaces } from "./execution_workspaces.js";
+import { issues } from "./issues.js";
+import { agents } from "./agents.js";
+import { heartbeatRuns } from "./heartbeat_runs.js";
+
+export const workspaceRuntimeServices = pgTable(
+  "workspace_runtime_services",
+  {
+    id: uuid("id").primaryKey(),
+    companyId: uuid("company_id").notNull().references(() => companies.id),
+    projectId: uuid("project_id").references(() => projects.id, { onDelete: "set null" }),
+    projectWorkspaceId: uuid("project_workspace_id").references(() => projectWorkspaces.id, { onDelete: "set null" }),
+    executionWorkspaceId: uuid("execution_workspace_id").references(() => executionWorkspaces.id, { onDelete: "set null" }),
+    issueId: uuid("issue_id").references(() => issues.id, { onDelete: "set null" }),
+    scopeType: text("scope_type").notNull(),
+    scopeId: text("scope_id"),
+    serviceName: text("service_name").notNull(),
+    status: text("status").notNull(),
+    lifecycle: text("lifecycle").notNull(),
+    reuseKey: text("reuse_key"),
+    command: text("command"),
+    cwd: text("cwd"),
+    port: integer("port"),
+    url: text("url"),
+    provider: text("provider").notNull(),
+    providerRef: text("provider_ref"),
+    ownerAgentId: uuid("owner_agent_id").references(() => agents.id, { onDelete: "set null" }),
+    startedByRunId: uuid("started_by_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
+    lastUsedAt: timestamp("last_used_at", { withTimezone: true }).notNull().defaultNow(),
+    startedAt: timestamp("started_at", { withTimezone: true }).notNull().defaultNow(),
+    stoppedAt: timestamp("stopped_at", { withTimezone: true }),
+    stopPolicy: jsonb("stop_policy").$type<Record<string, unknown>>(),
+    healthStatus: text("health_status").notNull().default("unknown"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    companyWorkspaceStatusIdx: index("workspace_runtime_services_company_workspace_status_idx").on(
+      table.companyId,
+      table.projectWorkspaceId,
+      table.status,
+    ),
+    companyExecutionWorkspaceStatusIdx: index("workspace_runtime_services_company_execution_workspace_status_idx").on(
+      table.companyId,
+      table.executionWorkspaceId,
+      table.status,
+    ),
+    companyProjectStatusIdx: index("workspace_runtime_services_company_project_status_idx").on(
+      table.companyId,
+      table.projectId,
+      table.status,
+    ),
+    runIdx: index("workspace_runtime_services_run_idx").on(table.startedByRunId),
+    companyUpdatedIdx: index("workspace_runtime_services_company_updated_idx").on(
+      table.companyId,
+      table.updatedAt,
+    ),
+  }),
+);