@defrex/autobuild-postgres-store 0.11.0 → 0.13.0

package/src/schema.ts

@@ -1,3 +1,11 @@
+import { PostgresProjectRegistry } from './projects'
+import type { PostgresEnv } from './env'
+import type { BlobStore } from '@defrex/autobuild/plugin-sdk'
+import {
+  migrateLegacyTickets,
+  migrateReadableTickets,
+  READABLE_TICKET_CONSTRAINTS,
+} from './ticket-migration'
 import { SQL } from 'bun'
 import {
   AUTH_SCHEMA_CHECKSUM,
@@ -8,7 +16,7 @@ import {
   assertAuthSchema,
 } from './auth-schema'
 
-export const SCHEMA_VERSION = 9
+export const SCHEMA_VERSION = 13
 export const MIGRATE_COMMAND = 'bun run postgres:migrate (from a pinned Autobuild release checkout)'
 
 /** The frozen v3 DDL, kept verbatim so a deployed v3 marker's checksum can be
@@ -666,7 +674,7 @@ CREATE INDEX IF NOT EXISTS events_type_build_seq ON events (type, build, seq);
 CREATE INDEX IF NOT EXISTS repo_events_type_repo_seq ON repo_events (repo, type, seq);`.trim()
 export const SCHEMA_V8_CHECKSUM = new Bun.CryptoHasher('sha256').update(SCHEMA_V8_DDL).digest('hex')
 
-export const SCHEMA_DDL = `
+export const SCHEMA_V9_DDL = `
 CREATE TABLE IF NOT EXISTS ab_schema_migrations (
   singleton boolean PRIMARY KEY DEFAULT true CHECK (singleton),
   version integer NOT NULL,
@@ -773,12 +781,68 @@ CREATE TABLE IF NOT EXISTS ticket_assets (
   PRIMARY KEY (repo, ticket_id, kind, name, revision)
 );`.trim()
 
+export const SCHEMA_V9_CHECKSUM = new Bun.CryptoHasher('sha256').update(SCHEMA_V9_DDL).digest('hex')
+
+export const PROJECT_SCHEMA_DDL = `
+CREATE SEQUENCE IF NOT EXISTS project_journal_seq;
+CREATE TABLE IF NOT EXISTS project_journal (
+  seq bigint PRIMARY KEY, repo text NOT NULL,
+  action text NOT NULL CHECK (action IN ('added','removed')),
+  actor text NOT NULL CHECK (length(btrim(actor)) > 0),
+  ts timestamptz NOT NULL
+);
+CREATE TABLE IF NOT EXISTS project_registry_state (
+  singleton boolean PRIMARY KEY DEFAULT true CHECK (singleton),
+  legacy_imported boolean NOT NULL
+);`.trim()
+export const SCHEMA_V10_DDL = `${SCHEMA_V9_DDL}\n${PROJECT_SCHEMA_DDL}`
+export const SCHEMA_V10_CHECKSUM = new Bun.CryptoHasher('sha256')
+  .update(SCHEMA_V10_DDL)
+  .digest('hex')
+export const CREDENTIAL_SCHEMA_DDL = `
+CREATE TABLE IF NOT EXISTS project_credentials (
+  id text PRIMARY KEY, digest text NOT NULL, repo text NOT NULL,
+  created_at timestamptz NOT NULL, created_by text NOT NULL,
+  last_used_at timestamptz, revoked_at timestamptz, expires_at timestamptz,
+  purpose text NOT NULL CHECK (purpose IN ('project-owner','dispatcher'))
+);`.trim()
+export const SCHEMA_V11_DDL = `${SCHEMA_V10_DDL}\n${CREDENTIAL_SCHEMA_DDL}`
+export const SCHEMA_V11_CHECKSUM = new Bun.CryptoHasher('sha256')
+  .update(SCHEMA_V11_DDL)
+  .digest('hex')
+export const CONNECTION_SCHEMA_DDL = `
+CREATE TABLE IF NOT EXISTS project_connections (
+  id text PRIMARY KEY, repo text NOT NULL, credential_id text NOT NULL,
+  digest text NOT NULL, capability_hash text NOT NULL, code text NOT NULL UNIQUE,
+  created_at timestamptz NOT NULL, expires_at timestamptz NOT NULL,
+  status text NOT NULL CHECK (status IN ('pending','approved','denied','expired')),
+  approved_by text, polled_at timestamptz, poll_attempts integer NOT NULL DEFAULT 0
+);
+CREATE TABLE IF NOT EXISTS connection_lookup_limits (
+  actor text PRIMARY KEY, started_at timestamptz NOT NULL, attempts integer NOT NULL
+);`.trim()
+export const SCHEMA_V12_DDL = `${SCHEMA_V11_DDL}\n${CONNECTION_SCHEMA_DDL}`
+export const SCHEMA_V12_CHECKSUM = new Bun.CryptoHasher('sha256')
+  .update(SCHEMA_V12_DDL)
+  .digest('hex')
+export const TICKET_POLICY_SCHEMA_DDL = `
+CREATE TABLE IF NOT EXISTS project_ticket_policy (
+  repo text PRIMARY KEY, registration bigint NOT NULL, policy jsonb NOT NULL,
+  writer text NOT NULL, updated_at timestamptz NOT NULL
+);`
+export const TICKET_GRANT_SCHEMA_DDL = `
+CREATE TABLE IF NOT EXISTS ticket_grants (
+ id text PRIMARY KEY, digest text NOT NULL UNIQUE, repo text NOT NULL, registration bigint NOT NULL,
+ execution text NOT NULL, kind text NOT NULL CHECK (kind IN ('runner','phase')),
+ parent text REFERENCES ticket_grants(id), expires_at timestamptz NOT NULL, revoked_at timestamptz
+);`
+export const SCHEMA_DDL = `${SCHEMA_V12_DDL}\n${TICKET_POLICY_SCHEMA_DDL}\n${TICKET_GRANT_SCHEMA_DDL}`
 export const SCHEMA_CHECKSUM = new Bun.CryptoHasher('sha256').update(SCHEMA_DDL).digest('hex')
 
 /** Ticket persistence evolves independently so deployed v1 BuildStore markers
  * remain valid while the hosted ticket tables are added. */
-export const TICKET_SCHEMA_VERSION = 1
-export const TICKET_SCHEMA_DDL = `
+export const TICKET_SCHEMA_VERSION = 5
+export const TICKET_SCHEMA_V1_DDL = `
 CREATE TABLE IF NOT EXISTS ab_ticket_schema_migrations (
   singleton boolean PRIMARY KEY DEFAULT true CHECK (singleton),
   version integer NOT NULL, checksum text NOT NULL, applied_at timestamptz NOT NULL
@@ -803,6 +867,38 @@ CREATE TABLE IF NOT EXISTS ab_ticket_blockers (
   FOREIGN KEY (team, blocker_id) REFERENCES ab_tickets(team, id) ON DELETE CASCADE,
   CHECK (ticket_id <> blocker_id)
 );`.trim()
+export const TICKET_SCHEMA_V1_CHECKSUM = new Bun.CryptoHasher('sha256')
+  .update(TICKET_SCHEMA_V1_DDL)
+  .digest('hex')
+export const TICKET_SCHEMA_V2_DDL = TICKET_SCHEMA_V1_DDL.replaceAll('team', 'repo')
+export const TICKET_SCHEMA_V2_CHECKSUM = new Bun.CryptoHasher('sha256')
+  .update(TICKET_SCHEMA_V2_DDL)
+  .digest('hex')
+export const TICKET_SCHEMA_V3_DDL = TICKET_SCHEMA_V2_DDL.replace(
+  'updated_at timestamptz NOT NULL,',
+  'updated_at timestamptz NOT NULL, revision bigint NOT NULL DEFAULT 1,',
+)
+export const TICKET_SCHEMA_V3_CHECKSUM = new Bun.CryptoHasher('sha256')
+  .update(TICKET_SCHEMA_V3_DDL)
+  .digest('hex')
+export const TICKET_STATES_DDL = `CREATE TABLE IF NOT EXISTS ab_ticket_states (
+  repo text NOT NULL, name text NOT NULL, about text,
+  PRIMARY KEY (repo, name),
+  CHECK (length(btrim(name)) > 0),
+  CHECK (about IS NULL OR (length(btrim(about)) > 0 AND position(chr(10) in about) = 0 AND position(chr(13) in about) = 0))
+);`
+export const TICKET_SCHEMA_V4_DDL = `${TICKET_SCHEMA_V3_DDL}\n${TICKET_STATES_DDL}`
+export const TICKET_SCHEMA_V4_CHECKSUM = new Bun.CryptoHasher('sha256')
+  .update(TICKET_SCHEMA_V4_DDL)
+  .digest('hex')
+export const TICKET_SCHEMA_DDL =
+  TICKET_SCHEMA_V4_DDL +
+  `
+ALTER TABLE ab_tickets ADD COLUMN IF NOT EXISTS readable_id text;
+ALTER TABLE ab_tickets ADD COLUMN IF NOT EXISTS ticket_number bigint;
+CREATE TABLE IF NOT EXISTS ab_ticket_counters (repo text PRIMARY KEY, last_number bigint NOT NULL CHECK (last_number >= 0));
+` +
+  READABLE_TICKET_CONSTRAINTS.trim()
 export const TICKET_SCHEMA_CHECKSUM = new Bun.CryptoHasher('sha256')
   .update(TICKET_SCHEMA_DDL)
   .digest('hex')
@@ -825,6 +921,65 @@ CREATE TABLE IF NOT EXISTS reducer_snapshots (
 type ExpectedColumn = readonly [name: string, type: string, notNull: boolean, defaultValue?: string]
 
 const EXPECTED_COLUMNS: Record<string, readonly ExpectedColumn[]> = {
+  project_connections: [
+    ['id', 'text', true],
+    ['repo', 'text', true],
+    ['credential_id', 'text', true],
+    ['digest', 'text', true],
+    ['capability_hash', 'text', true],
+    ['code', 'text', true],
+    ['created_at', 'timestamp with time zone', true],
+    ['expires_at', 'timestamp with time zone', true],
+    ['status', 'text', true],
+    ['approved_by', 'text', false],
+    ['polled_at', 'timestamp with time zone', false],
+    ['poll_attempts', 'integer', true, '0'],
+  ],
+  connection_lookup_limits: [
+    ['actor', 'text', true],
+    ['started_at', 'timestamp with time zone', true],
+    ['attempts', 'integer', true],
+  ],
+  project_ticket_policy: [
+    ['repo', 'text', true],
+    ['registration', 'bigint', true],
+    ['policy', 'jsonb', true],
+    ['writer', 'text', true],
+    ['updated_at', 'timestamp with time zone', true],
+  ],
+  ticket_grants: [
+    ['id', 'text', true],
+    ['digest', 'text', true],
+    ['repo', 'text', true],
+    ['registration', 'bigint', true],
+    ['execution', 'text', true],
+    ['kind', 'text', true],
+    ['parent', 'text', false],
+    ['expires_at', 'timestamp with time zone', true],
+    ['revoked_at', 'timestamp with time zone', false],
+  ],
+  project_credentials: [
+    ['id', 'text', true],
+    ['digest', 'text', true],
+    ['repo', 'text', true],
+    ['created_at', 'timestamp with time zone', true],
+    ['created_by', 'text', true],
+    ['last_used_at', 'timestamp with time zone', false],
+    ['revoked_at', 'timestamp with time zone', false],
+    ['expires_at', 'timestamp with time zone', false],
+    ['purpose', 'text', true],
+  ],
+  project_journal: [
+    ['seq', 'bigint', true],
+    ['repo', 'text', true],
+    ['action', 'text', true],
+    ['actor', 'text', true],
+    ['ts', 'timestamp with time zone', true],
+  ],
+  project_registry_state: [
+    ['singleton', 'boolean', true, 'true'],
+    ['legacy_imported', 'boolean', true],
+  ],
   ab_schema_migrations: [
     ['singleton', 'boolean', true, 'true'],
     ['version', 'integer', true],
@@ -958,6 +1113,20 @@ const EXPECTED_COLUMNS: Record<string, readonly ExpectedColumn[]> = {
 }
 
 const EXPECTED_CONSTRAINTS = [
+  'project_ticket_policy|p|repo||||',
+  'ticket_grants|p|id||||',
+  'ticket_grants|c|||||',
+  'ticket_grants|f|parent|ticket_grants|id|a|',
+  'project_connections|p|id||||',
+  'project_connections|c|||||',
+  'connection_lookup_limits|p|actor||||',
+  'project_credentials|p|id||||',
+  'project_credentials|c|||||',
+  'project_journal|p|seq||||',
+  'project_journal|c|||||',
+  'project_journal|c|||||',
+  'project_registry_state|p|singleton||||',
+  'project_registry_state|c|||||',
   // CHECK constraints are compared by presence only (their pg_get_expr text
   // is version-sensitive); PK/FK rows compare fully.
   'ab_schema_migrations|c|||||',
@@ -1112,7 +1281,7 @@ async function assertCatalogShape(sql: SQL): Promise<void> {
           ].join('|'),
     )
     .sort()
-  if (JSON.stringify(actualConstraints) !== JSON.stringify(EXPECTED_CONSTRAINTS)) {
+  if (JSON.stringify(actualConstraints) !== JSON.stringify([...EXPECTED_CONSTRAINTS].sort())) {
     throw schemaError('constraints are missing or mismatched')
   }
 }
@@ -1170,7 +1339,7 @@ export async function assertTicketSchema(sql: SQL): Promise<void> {
       ['applied_at', 'timestamp with time zone', true],
     ],
     ab_tickets: [
-      ['team', 'text', true],
+      ['repo', 'text', true],
       ['id', 'text', true],
       ['creation_key', 'text', false],
       ['title', 'text', true],
@@ -1179,16 +1348,28 @@ export async function assertTicketSchema(sql: SQL): Promise<void> {
       ['labels', 'text[]', true],
       ['created_at', 'timestamp with time zone', true],
       ['updated_at', 'timestamp with time zone', true],
+      ['revision', 'bigint', true],
+      ['readable_id', 'text', true],
+      ['ticket_number', 'bigint', true],
+    ],
+    ab_ticket_counters: [
+      ['repo', 'text', true],
+      ['last_number', 'bigint', true],
+    ],
+    ab_ticket_states: [
+      ['repo', 'text', true],
+      ['name', 'text', true],
+      ['about', 'text', false],
     ],
     ab_ticket_comments: [
-      ['team', 'text', true],
+      ['repo', 'text', true],
       ['ticket_id', 'text', true],
       ['seq', 'bigint', true],
       ['body', 'text', true],
       ['created_at', 'timestamp with time zone', true],
     ],
     ab_ticket_blockers: [
-      ['team', 'text', true],
+      ['repo', 'text', true],
       ['ticket_id', 'text', true],
       ['blocker_id', 'text', true],
     ],
@@ -1203,7 +1384,7 @@ export async function assertTicketSchema(sql: SQL): Promise<void> {
     WHERE n.nspname = current_schema() AND c.relkind IN ('r', 'p')
       AND a.attnum > 0 AND NOT a.attisdropped
       AND c.relname = ANY(ARRAY['ab_ticket_schema_migrations', 'ab_tickets',
-        'ab_ticket_comments', 'ab_ticket_blockers'])
+        'ab_ticket_comments', 'ab_ticket_blockers', 'ab_ticket_counters', 'ab_ticket_states'])
     ORDER BY c.relname, a.attnum`
   for (const [table, shape] of Object.entries(expected)) {
     const actual = columns
@@ -1213,6 +1394,51 @@ export async function assertTicketSchema(sql: SQL): Promise<void> {
       throw schemaError(`ticket table ${table} is missing or mismatched`)
     }
   }
+  const indexes =
+    await sql`SELECT indexdef FROM pg_indexes WHERE schemaname = current_schema() AND tablename = 'ab_tickets' AND indexname = 'ab_tickets_readable_id_key'`
+  if (
+    !indexes[0] ||
+    !String(indexes[0].indexdef).includes('UNIQUE INDEX') ||
+    !String(indexes[0].indexdef).endsWith('(repo, lower(readable_id))')
+  )
+    throw schemaError('ticket readable id unique index is missing or mismatched')
+  const constraints: { table_name: string; definition: string }[] = await sql`
+    SELECT c.relname AS table_name, pg_get_constraintdef(k.oid) AS definition
+    FROM pg_constraint k JOIN pg_class c ON c.oid = k.conrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE n.nspname = current_schema() AND k.contype IN ('p', 'u', 'f', 'c') AND c.relname IN ('ab_tickets', 'ab_ticket_comments', 'ab_ticket_blockers', 'ab_ticket_counters', 'ab_ticket_states')`
+  const expectedConstraints: Record<string, string[]> = {
+    ab_ticket_states: [
+      'PRIMARY KEY (repo, name)',
+      'CHECK ((length(btrim(name)) > 0))',
+      'CHECK (((about IS NULL) OR ((length(btrim(about)) > 0) AND (POSITION((chr(10)) IN (about)) = 0) AND (POSITION((chr(13)) IN (about)) = 0))))',
+    ],
+    ab_tickets: [
+      'PRIMARY KEY (repo, id)',
+      'UNIQUE (repo, creation_key)',
+      'UNIQUE (repo, ticket_number)',
+      'CHECK ((ticket_number > 0))',
+    ],
+    ab_ticket_counters: ['PRIMARY KEY (repo)', 'CHECK ((last_number >= 0))'],
+    ab_ticket_comments: [
+      'PRIMARY KEY (repo, ticket_id, seq)',
+      'FOREIGN KEY (repo, ticket_id) REFERENCES ab_tickets(repo, id) ON DELETE CASCADE',
+    ],
+    ab_ticket_blockers: [
+      'PRIMARY KEY (repo, ticket_id, blocker_id)',
+      'FOREIGN KEY (repo, ticket_id) REFERENCES ab_tickets(repo, id) ON DELETE CASCADE',
+      'FOREIGN KEY (repo, blocker_id) REFERENCES ab_tickets(repo, id) ON DELETE CASCADE',
+      'CHECK ((ticket_id <> blocker_id))',
+    ],
+  }
+  for (const [table, definitions] of Object.entries(expectedConstraints)) {
+    const actual = constraints
+      .filter((row) => row.table_name === table)
+      .map((row) => row.definition)
+      .sort()
+    if (JSON.stringify(actual) !== JSON.stringify(definitions.sort()))
+      throw schemaError(`ticket table ${table} constraints are missing or mismatched`)
+  }
 }
 
 /** The guarded streams.creation_seq upgrade, shared by every pre-v7 marker
@@ -1243,13 +1469,20 @@ const STREAMS_CREATION_SEQ_MIGRATION = `
   END $$;
 `
 
-export async function migratePostgres(url: string): Promise<void> {
+export async function migratePostgres(
+  url: string,
+  options: {
+    openBlobs?: () => BlobStore | Promise<BlobStore>
+    legacyProjectEnv?: PostgresEnv
+  } = {},
+): Promise<void> {
   const sql = new SQL(url)
   try {
     await sql.begin(async (tx) => {
       await tx`SELECT pg_advisory_xact_lock(470281941)`
       await tx.unsafe(SCHEMA_DDL)
-      await tx.unsafe(TICKET_SCHEMA_DDL)
+      await tx.unsafe(TICKET_SCHEMA_V2_DDL)
+      await tx.unsafe(TICKET_STATES_DDL)
       await tx.unsafe(SNAPSHOT_SCHEMA_DDL)
       await tx.unsafe(AUTH_SCHEMA_DDL)
       const rows: { version: number; checksum: string }[] =
@@ -1427,6 +1660,21 @@ export async function migratePostgres(url: string): Promise<void> {
             SET version = ${SCHEMA_VERSION}, checksum = ${SCHEMA_CHECKSUM},
               applied_at = ${new Date().toISOString()}
             WHERE singleton = true`
+        } else if (version === 12 && marker.checksum === SCHEMA_V12_CHECKSUM) {
+          await tx`UPDATE ab_schema_migrations SET version = ${SCHEMA_VERSION}, checksum = ${SCHEMA_CHECKSUM},
+            applied_at = ${new Date().toISOString()} WHERE singleton = true`
+        } else if (version === 11 && marker.checksum === SCHEMA_V11_CHECKSUM) {
+          await tx`UPDATE ab_schema_migrations SET version = ${SCHEMA_VERSION}, checksum = ${SCHEMA_CHECKSUM},
+            applied_at = ${new Date().toISOString()} WHERE singleton = true`
+        } else if (version === 10 && marker.checksum === SCHEMA_V10_CHECKSUM) {
+          await tx`UPDATE ab_schema_migrations
+            SET version = ${SCHEMA_VERSION}, checksum = ${SCHEMA_CHECKSUM},
+              applied_at = ${new Date().toISOString()} WHERE singleton = true`
+        } else if (version === 9 && marker.checksum === SCHEMA_V9_CHECKSUM) {
+          await tx`UPDATE ab_schema_migrations
+            SET version = ${SCHEMA_VERSION}, checksum = ${SCHEMA_CHECKSUM},
+              applied_at = ${new Date().toISOString()}
+            WHERE singleton = true`
         } else if (version === 8 && marker.checksum === SCHEMA_V8_CHECKSUM) {
           // v8 → v9: the idempotent full DDL above created the ticket_assets
           // table, which is the entire delta (no pre-existing table changes).
@@ -1442,10 +1690,47 @@ export async function migratePostgres(url: string): Promise<void> {
         await tx`INSERT INTO ab_schema_migrations (singleton, version, checksum, applied_at)
           VALUES (true, ${SCHEMA_VERSION}, ${SCHEMA_CHECKSUM}, ${new Date().toISOString()})`
       }
+      if (options.legacyProjectEnv !== undefined) {
+        await new PostgresProjectRegistry(tx as SQL).initializeFromEnvInTransaction(
+          options.legacyProjectEnv,
+        )
+      }
       const ticketRows: { version: number; checksum: string }[] =
         await tx`SELECT version, checksum FROM ab_ticket_schema_migrations WHERE singleton = true FOR UPDATE`
       const ticketMarker = ticketRows[0]
-      if (ticketMarker) {
+      if (
+        ticketMarker &&
+        Number(ticketMarker.version) === 1 &&
+        ticketMarker.checksum === TICKET_SCHEMA_V1_CHECKSUM
+      ) {
+        await migrateLegacyTickets(tx as SQL, options.openBlobs)
+        await tx`ALTER TABLE ab_tickets ADD COLUMN IF NOT EXISTS revision bigint NOT NULL DEFAULT 1`
+        await migrateReadableTickets(tx as SQL, options.openBlobs)
+        await tx`UPDATE ab_ticket_schema_migrations SET version = ${TICKET_SCHEMA_VERSION},
+          checksum = ${TICKET_SCHEMA_CHECKSUM}, applied_at = ${new Date().toISOString()} WHERE singleton = true`
+      } else if (
+        ticketMarker &&
+        Number(ticketMarker.version) === 2 &&
+        ticketMarker.checksum === TICKET_SCHEMA_V2_CHECKSUM
+      ) {
+        await tx`ALTER TABLE ab_tickets ADD COLUMN revision bigint NOT NULL DEFAULT 1`
+        await migrateReadableTickets(tx as SQL, options.openBlobs)
+        await tx`UPDATE ab_ticket_schema_migrations SET version = ${TICKET_SCHEMA_VERSION}, checksum = ${TICKET_SCHEMA_CHECKSUM}, applied_at = ${new Date().toISOString()} WHERE singleton = true`
+      } else if (
+        ticketMarker &&
+        Number(ticketMarker.version) === 3 &&
+        ticketMarker.checksum === TICKET_SCHEMA_V3_CHECKSUM
+      ) {
+        await migrateReadableTickets(tx as SQL, options.openBlobs)
+        await tx`UPDATE ab_ticket_schema_migrations SET version = ${TICKET_SCHEMA_VERSION}, checksum = ${TICKET_SCHEMA_CHECKSUM}, applied_at = ${new Date().toISOString()} WHERE singleton = true`
+      } else if (
+        ticketMarker &&
+        Number(ticketMarker.version) === 4 &&
+        ticketMarker.checksum === TICKET_SCHEMA_V4_CHECKSUM
+      ) {
+        await migrateReadableTickets(tx as SQL, options.openBlobs)
+        await tx`UPDATE ab_ticket_schema_migrations SET version = ${TICKET_SCHEMA_VERSION}, checksum = ${TICKET_SCHEMA_CHECKSUM}, applied_at = ${new Date().toISOString()} WHERE singleton = true`
+      } else if (ticketMarker) {
         if (Number(ticketMarker.version) !== TICKET_SCHEMA_VERSION) {
           throw schemaError(
             `ticket marker is incompatible: version ${ticketMarker.version} does not match ` +
@@ -1458,10 +1743,19 @@ export async function migratePostgres(url: string): Promise<void> {
           )
         }
       } else {
+        await tx`ALTER TABLE ab_tickets ADD COLUMN IF NOT EXISTS revision bigint NOT NULL DEFAULT 1`
+        await migrateReadableTickets(tx as SQL, options.openBlobs)
         await tx`INSERT INTO ab_ticket_schema_migrations
           (singleton, version, checksum, applied_at)
           VALUES (true, ${TICKET_SCHEMA_VERSION}, ${TICKET_SCHEMA_CHECKSUM}, ${new Date().toISOString()})`
       }
+      await tx`INSERT INTO ab_ticket_states (repo, name)
+        SELECT DISTINCT repo, state FROM ab_tickets ON CONFLICT DO NOTHING`
+      await tx`INSERT INTO ab_ticket_states (repo, name)
+        SELECT p.repo, value FROM project_ticket_policy p,
+          LATERAL jsonb_each_text(p.policy->'tickets') AS field(key, value)
+        WHERE key IN ('triageState', 'readyState', 'claimedState', 'doneState', 'createState', 'proposalState')
+        ON CONFLICT DO NOTHING`
       const authRows: { version: number; checksum: string }[] =
         await tx`SELECT version, checksum FROM ab_auth_schema_migrations WHERE singleton = true FOR UPDATE`
       const authMarker = authRows[0]

package/src/store.ts

@@ -248,23 +248,48 @@ export class PostgresBuildStore implements BuildStore {
         ON CONFLICT (slug) DO NOTHING RETURNING slug`
       const row = await this.lockBuild(q, input.slug)
       if (!inserted[0]) throw new Error(`build "${input.slug}" already exists`)
-      if (created === undefined) return this.record(row)
+      if (created === undefined) return this.currentRecord(q, row)
       await this.appendLocked(q, input.slug, created, true)
-      return this.record(await this.lockBuild(q, input.slug))
+      return this.currentRecord(q, await this.lockBuild(q, input.slug))
     })
   }
 
+  /** Current ticket identity is a read projection; event/artifact bytes remain historical. */
+  private async currentRecord(q: Exec, row: Row): Promise<BuildRecord> {
+    const record = this.record(row)
+    if (record.ticket?.source !== 'hosted') return record
+    const ticket = await this.hostedTicketRow(q, record.repo, record.ticket.id)
+    const id = ticket?.readable_id
+    return id ? { ...record, ticket: { ...record.ticket, id: String(id) } } : record
+  }
+
   async getBuild(slug: string): Promise<BuildRecord | null> {
     return this.run(async (q) => {
       const rows: Row[] = await q`SELECT * FROM builds WHERE slug = ${slug}`
-      return rows[0] ? this.record(rows[0]) : null
+      return rows[0] ? this.currentRecord(q, rows[0]) : null
     })
   }
 
   async listBuilds(): Promise<BuildRecord[]> {
     return this.run(async (q) => {
-      const rows: Row[] = await q`SELECT * FROM builds ORDER BY created_at, slug`
-      return rows.map((row) => this.record(row))
+      if (!(await this.hasReadableTicketSchema(q))) {
+        const rows: Row[] = await q`SELECT * FROM builds ORDER BY created_at, slug`
+        return rows.map((row) => this.record(row))
+      }
+      const rows: Row[] = await q`SELECT b.*, t.readable_id AS projected_ticket_id FROM builds b
+        LEFT JOIN LATERAL (
+          SELECT readable_id FROM ab_tickets
+          WHERE b.ticket->>'source' = 'hosted' AND repo = b.repo
+            AND (id = b.ticket->>'id' OR lower(readable_id) = lower(b.ticket->>'id'))
+          LIMIT 1
+        ) t ON true
+        ORDER BY b.created_at, b.slug`
+      return rows.map((row) => {
+        const record = this.record(row)
+        return record.ticket && row.projected_ticket_id
+          ? { ...record, ticket: { ...record.ticket, id: String(row.projected_ticket_id) } }
+          : record
+      })
     })
   }
 
@@ -1209,6 +1234,39 @@ export class PostgresBuildStore implements BuildStore {
     }
   }
 
+  private readableTicketSchema = false
+
+  /** Ticket tables are an independently migrated, optional store extension. */
+  private async hasReadableTicketSchema(q: Exec): Promise<boolean> {
+    if (!this.readableTicketSchema) {
+      const tables: Row[] = await q`SELECT to_regclass('ab_ticket_schema_migrations') AS tickets`
+      if (!tables[0]?.tickets) return false
+      const markers: Row[] =
+        await q`SELECT version FROM ab_ticket_schema_migrations WHERE singleton = true`
+      if (Number(markers[0]?.version ?? 0) < 3) return false
+      // Cache only presence: a store opened before migration must discover a later upgrade.
+      this.readableTicketSchema = true
+    }
+    return true
+  }
+
+  private async hostedTicketRow(q: Exec, repo: string, id: string): Promise<Row | undefined> {
+    if (!(await this.hasReadableTicketSchema(q))) return undefined
+    const rows: Row[] = await q`SELECT id, readable_id FROM ab_tickets
+      WHERE repo = ${repo} AND (id = ${id} OR lower(readable_id) = lower(${id}))`
+    return rows[0]
+  }
+
+  private async currentAssetMeta(q: Exec, row: Row): Promise<TicketAssetMeta> {
+    const meta = this.ticketAssetMeta(row)
+    const ticket = await this.hostedTicketRow(q, meta.repo, meta.ticketId)
+    return ticket?.readable_id ? { ...meta, ticketId: String(ticket.readable_id) } : meta
+  }
+
+  private async ticketStorageKey(q: Exec, repo: string, id: string): Promise<string> {
+    return String((await this.hostedTicketRow(q, repo, id))?.id ?? id)
+  }
+
   async putTicketAsset(
     repo: string,
     ticketId: string,
@@ -1218,16 +1276,28 @@ export class PostgresBuildStore implements BuildStore {
     const entries = await storeTicketAssetBlobs(this.blobs, asset.entries)
     const manifest = JSON.stringify(entries)
     return this.tx(async (q) => {
+      const key = await this.ticketStorageKey(q, repo, ticketId)
       // Serialize revision assignment per (repo, ticket, kind, name).
-      await q`SELECT pg_advisory_xact_lock(hashtextextended(${JSON.stringify([repo, ticketId, asset.kind, asset.name])}, 0))`
+      await q`SELECT pg_advisory_xact_lock(hashtextextended(${JSON.stringify([repo, key, asset.kind, asset.name])}, 0))`
       const tails: Row[] =
-        await q`SELECT COALESCE(MAX(revision), -1) AS revision FROM ticket_assets WHERE repo=${repo} AND ticket_id=${ticketId} AND kind=${asset.kind} AND name=${asset.name}`
+        await q`SELECT COALESCE(MAX(revision), -1) AS revision FROM ticket_assets WHERE repo=${repo} AND ticket_id=${key} AND kind=${asset.kind} AND name=${asset.name}`
       const revision = num(tails[0]?.revision) + 1
       const createdAt = this.now()
-      await q`INSERT INTO ticket_assets (repo,ticket_id,kind,name,revision,layout,manifest,size,removed,created_at) VALUES (${repo},${ticketId},${asset.kind},${asset.name},${revision},${asset.layout},${manifest}::jsonb,${size},false,${createdAt})`
+      await q`INSERT INTO ticket_assets (repo,ticket_id,kind,name,revision,layout,manifest,size,removed,created_at) VALUES (${repo},${key},${asset.kind},${asset.name},${revision},${asset.layout},${manifest}::jsonb,${size},false,${createdAt})`
+      const display = await this.currentAssetMeta(q, {
+        repo,
+        ticket_id: key,
+        kind: asset.kind,
+        name: asset.name,
+        revision,
+        layout: asset.layout,
+        size,
+        manifest: entries,
+        created_at: createdAt,
+      })
       return {
         repo,
-        ticketId,
+        ticketId: display.ticketId,
         kind: asset.kind,
         name: asset.name,
         revision,
@@ -1246,14 +1316,15 @@ export class PostgresBuildStore implements BuildStore {
     name: string,
     rev?: number,
   ): Promise<TicketAsset | null> {
-    const rows: Row[] = await this.run((q) =>
-      rev === undefined
-        ? q`SELECT * FROM ticket_assets WHERE repo=${repo} AND ticket_id=${ticketId} AND kind=${kind} AND name=${name} ORDER BY revision DESC LIMIT 1`
-        : q`SELECT * FROM ticket_assets WHERE repo=${repo} AND ticket_id=${ticketId} AND kind=${kind} AND name=${name} AND revision=${rev}`,
-    )
+    const rows: Row[] = await this.run(async (q) => {
+      const key = await this.ticketStorageKey(q, repo, ticketId)
+      return rev === undefined
+        ? q`SELECT * FROM ticket_assets WHERE repo=${repo} AND ticket_id=${key} AND kind=${kind} AND name=${name} ORDER BY revision DESC LIMIT 1`
+        : q`SELECT * FROM ticket_assets WHERE repo=${repo} AND ticket_id=${key} AND kind=${kind} AND name=${name} AND revision=${rev}`
+    })
     const row = rows[0]
     if (!row || row.removed === true) return null
-    return loadTicketAsset(this.blobs, this.ticketAssetMeta(row))
+    return loadTicketAsset(this.blobs, await this.run((q) => this.currentAssetMeta(q, row)))
   }
 
   async getPinnedTicketAsset(
@@ -1270,10 +1341,15 @@ export class PostgresBuildStore implements BuildStore {
     ticketId: string,
     opts?: { revisions?: boolean },
   ): Promise<TicketAssetSummary[]> {
-    const rows: Row[] = await this.run(
-      (q) =>
-        q`SELECT * FROM ticket_assets WHERE repo=${repo} AND ticket_id=${ticketId} ORDER BY kind, name, revision`,
-    )
+    const rows: Row[] = await this.run(async (q) => {
+      const key = await this.ticketStorageKey(q, repo, ticketId)
+      const rows: Row[] =
+        await q`SELECT * FROM ticket_assets WHERE repo=${repo} AND ticket_id=${key} ORDER BY kind, name, revision`
+      const projected: Row[] = []
+      for (const row of rows)
+        projected.push({ ...row, ticket_id: (await this.currentAssetMeta(q, row)).ticketId })
+      return projected
+    })
     if (opts?.revisions) {
       return rows
         .filter((row) => row.removed !== true)
@@ -1293,13 +1369,14 @@ export class PostgresBuildStore implements BuildStore {
     name: string,
   ): Promise<TicketAssetMeta | null> {
     return this.tx(async (q) => {
-      await q`SELECT pg_advisory_xact_lock(hashtextextended(${JSON.stringify([repo, ticketId, kind, name])}, 0))`
+      const key = await this.ticketStorageKey(q, repo, ticketId)
+      await q`SELECT pg_advisory_xact_lock(hashtextextended(${JSON.stringify([repo, key, kind, name])}, 0))`
       const rows: Row[] =
-        await q`SELECT * FROM ticket_assets WHERE repo=${repo} AND ticket_id=${ticketId} AND kind=${kind} AND name=${name} ORDER BY revision DESC LIMIT 1`
+        await q`SELECT * FROM ticket_assets WHERE repo=${repo} AND ticket_id=${key} AND kind=${kind} AND name=${name} ORDER BY revision DESC LIMIT 1`
       const latest = rows[0]
       if (!latest || latest.removed === true) return null
-      await q`INSERT INTO ticket_assets (repo,ticket_id,kind,name,revision,layout,manifest,size,removed,created_at) VALUES (${repo},${ticketId},${kind},${name},${num(latest.revision) + 1},${String(latest.layout)},${'[]'}::jsonb,0,true,${this.now()})`
-      return this.ticketAssetMeta(latest)
+      await q`INSERT INTO ticket_assets (repo,ticket_id,kind,name,revision,layout,manifest,size,removed,created_at) VALUES (${repo},${key},${kind},${name},${num(latest.revision) + 1},${String(latest.layout)},${'[]'}::jsonb,0,true,${this.now()})`
+      return this.currentAssetMeta(q, latest)
     })
   }
 

package/src/ticket-assignments.ts

@@ -0,0 +1,39 @@
+import { SQL } from 'bun'
+import { normalizeProjectRepository, initializeProjectRegistryForRecovery } from './projects'
+import { resolvePostgresUrl, type PostgresEnv } from './env'
+
+export const TICKET_ASSIGNMENTS_DDL = `CREATE TABLE IF NOT EXISTS ticket_team_assignments (
+  seq bigserial PRIMARY KEY, team text NOT NULL, repo text NOT NULL,
+  actor text NOT NULL, ts timestamptz NOT NULL
+)`
+export interface TicketAssignments {
+  assign(team: string, repo: string, actor: string): Promise<void>
+  close(): Promise<void>
+}
+/** Deliberately independent of v2 ticket schema assertion: this is the recovery
+ * path for a migration whose ownership preflight has stopped. */
+export async function openTicketAssignmentsFromEnv(env: PostgresEnv): Promise<TicketAssignments> {
+  const sql = new SQL(resolvePostgresUrl(env))
+  try {
+    await initializeProjectRegistryForRecovery(sql, env)
+    await sql.unsafe(TICKET_ASSIGNMENTS_DDL)
+    return {
+      async assign(team, rawRepo, actor) {
+        const repo = normalizeProjectRepository(rawRepo)
+        if (!team.trim() || !actor.trim()) throw new Error('team and actor must be nonblank')
+        await sql.begin(async (tx) => {
+          await tx`LOCK TABLE project_journal, ticket_team_assignments IN SHARE ROW EXCLUSIVE MODE`
+          const [entry] =
+            await tx`SELECT action FROM project_journal WHERE repo = ${repo} ORDER BY seq DESC LIMIT 1`
+          if (entry?.action !== 'added') throw new Error(`project not registered: ${repo}`)
+          await tx`INSERT INTO ticket_team_assignments (team, repo, actor, ts)
+            VALUES (${team}, ${repo}, ${actor.trim()}, ${new Date().toISOString()})`
+        })
+      },
+      close: () => sql.close(),
+    }
+  } catch (error) {
+    await sql.close()
+    throw error
+  }
+}