@defrex/autobuild 0.8.0 → 0.9.0

package/packages/core/src/store/digest.ts

@@ -0,0 +1,49 @@
+/**
+ * The shared build-digest derivation (AUT-487): every BuildStore adapter
+ * answers `getRepoBuildDigests` by fetching only the digest-relevant event
+ * types from its existing event table and running this one pure function per
+ * build — identical results by construction, and the digest's `terminal` can
+ * never drift from `reduceBuild`'s terminal rule because this is the same
+ * in-order-overwrite of the latest terminal fact (§15.5). AUT-521 widens the
+ * projection with the observation timestamps and merge facts the harvest
+ * pressure gate needs, keeping that gate's cost flat in accumulated build
+ * history.
+ */
+import type { AbEvent } from '../events/catalog'
+import type { BuildDigest } from './types'
+
+/** The event types a digest is derived from. Adapters filter their event
+ * rows to exactly these, so a per-build type-filtered index keeps the scan's
+ * cost growing with the actual signal, not with total history. */
+export const DIGEST_EVENT_TYPES = [
+  'build.completed',
+  'build.aborted',
+  'observation.recorded',
+  'pr.merged',
+] as const
+
+/** The digest-relevant projection of one build's events, in log order.
+ * `terminal` follows `reduceBuild` exactly: `build.completed` sets `done`,
+ * `build.aborted` sets `aborted`, latest wins (in-order overwrite) — and
+ * `merged` follows the same overwrite pattern for `pr.merged` timestamps.
+ * The events carry no slug, so the result is slug-less; every adapter attaches
+ * `slug` itself when grouping its per-build event rows. */
+export function reduceBuildDigest(
+  events: Pick<AbEvent, 'type' | 'seq' | 'ts'>[],
+): Omit<BuildDigest, 'slug'> {
+  let terminal: BuildDigest['terminal']
+  let merged: string | undefined
+  const observations: { seq: number; ts: string }[] = []
+  for (const event of events) {
+    if (event.type === 'build.completed') terminal = 'done'
+    else if (event.type === 'build.aborted') terminal = 'aborted'
+    else if (event.type === 'pr.merged') merged = event.ts
+    else if (event.type === 'observation.recorded')
+      observations.push({ seq: event.seq, ts: event.ts })
+  }
+  return {
+    observations,
+    ...(merged !== undefined ? { merged } : {}),
+    ...(terminal !== undefined ? { terminal } : {}),
+  }
+}

package/packages/core/src/store/local/schema.ts

@@ -9,9 +9,10 @@
  * be kept in lockstep with this schema (this file is the drizzle-kit source
  * of truth).
  */
-import { integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { index, integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core'
 import type { Actor } from '../../events/envelope'
 import type { TicketRef } from '../../ontology'
+import type { TicketAssetEntry } from '../ticket-assets'
 import type { StreamPart } from '../streams/types'
 
 export const builds = sqliteTable('builds', {
@@ -39,7 +40,12 @@ export const events = sqliteTable(
     type: text('type').notNull(),
     payload: text('payload', { mode: 'json' }).notNull(),
   },
-  (t) => [primaryKey({ columns: [t.build, t.seq] })],
+  // Mirrors the BOOTSTRAP_DDL digest-scan index (AUT-487), type-leading so the
+  // digest query's cost grows with digest-relevant events, not total history.
+  (t) => [
+    primaryKey({ columns: [t.build, t.seq] }),
+    index('events_type_build_seq').on(t.type, t.build, t.seq),
+  ],
 )
 
 export const repoStreams = sqliteTable('repo_streams', {
@@ -78,6 +84,27 @@ export const repoArtifacts = sqliteTable(
   (t) => [primaryKey({ columns: [t.repo, t.kind, t.revision] })],
 )
 
+/** Ticket assets (SPEC §7.1): one row per revision, manifest as JSON, file
+ * bytes in the BlobStore. A removal is a tombstone row (`removed`, empty
+ * manifest) taking the next revision. No FK to `repo_streams`: assets can
+ * precede any repo-journal row. */
+export const ticketAssets = sqliteTable(
+  'ticket_assets',
+  {
+    repo: text('repo').notNull(),
+    ticketId: text('ticket_id').notNull(),
+    kind: text('kind').notNull(),
+    name: text('name').notNull(),
+    revision: integer('revision').notNull(),
+    layout: text('layout').notNull().$type<'file' | 'tree'>(),
+    manifest: text('manifest', { mode: 'json' }).notNull().$type<TicketAssetEntry[]>(),
+    size: integer('size').notNull(),
+    removed: integer('removed').notNull(),
+    createdAt: text('created_at').notNull(),
+  },
+  (t) => [primaryKey({ columns: [t.repo, t.ticketId, t.kind, t.name, t.revision] })],
+)
+
 /** Operator sessions (SPEC §7.1.1): hosted-only durable orchestrator
  * conversation state. Adapters implement the contract uniformly; nothing
  * local creates one. */

package/packages/core/src/store/local/store.ts

@@ -11,7 +11,7 @@
  * content-addressed.
  */
 import { Database } from 'bun:sqlite'
-import { and, asc, desc, eq, gt, inArray, sql } from 'drizzle-orm'
+import { and, asc, desc, eq, gt, gte, inArray, or, sql } from 'drizzle-orm'
 import { drizzle, type BunSQLiteDatabase } from 'drizzle-orm/bun-sqlite'
 import { mkdirSync } from 'node:fs'
 import { access, copyFile, mkdtemp, rm } from 'node:fs/promises'
@@ -40,7 +40,13 @@ import {
   type SessionEventWrite,
 } from '../../events/sessions'
 import { createBuildScopedStore } from '../build-scope'
+import { validateCreatedEvent } from '../new-build'
 import { createSessionScopedStore } from '../session-handle'
+import { DIGEST_EVENT_TYPES, reduceBuildDigest } from '../digest'
+import {
+  REPOSITORY_STATE_EVENT_TYPES,
+  readRepoStateEventsWithAnchorRecheck,
+} from '../repo-state-events'
 import {
   DEFAULT_ARTIFACT_RETENTION_MAX_REVISIONS,
   isRetentionManagedKind,
@@ -49,7 +55,7 @@ import {
 import { pollingSubscribe } from '../subscribe'
 import { StreamLocks } from '../streams/lock'
 import { assembleUIMessageDocument } from '../streams/assemble'
-import { readEventsWithWait, readStreamWithWait } from '../streams/wait'
+import { EVENT_WAIT_POLL_MS, readEventsWithWait, readStreamWithWait } from '../streams/wait'
 import {
   serializedBatchSize,
   STREAM_BATCH_MAX_BYTES,
@@ -76,6 +82,7 @@ import {
   type ArtifactMeta,
   type BlobStore,
   type BuildRecord,
+  type BuildDigest,
   type BuildScopedStore,
   type BuildStore,
   type Clock,
@@ -91,6 +98,19 @@ import {
   type SubscribeOptions,
   type Unsubscribe,
 } from '../types'
+import {
+  DEFAULT_TICKET_ASSET_LIMITS,
+  loadTicketAsset,
+  storeTicketAssetBlobs,
+  resolvePinnedAsset,
+  summarizeTicketAsset,
+  validateTicketAssetInput,
+  type TicketAsset,
+  type TicketAssetInput,
+  type TicketAssetLimits,
+  type TicketAssetMeta,
+  type TicketAssetSummary,
+} from '../ticket-assets'
 import { DirBlobStore } from './blobs'
 import {
   artifacts,
@@ -102,6 +122,7 @@ import {
   sessionArtifacts,
   sessionEvents,
   sessions,
+  ticketAssets,
   streamChunks,
   streams,
 } from './schema'
@@ -111,7 +132,9 @@ import {
  * the drizzle schema is the source of truth; this is its inlined form so
  * opening a store never needs a migration step.
  */
-const BOOTSTRAP_DDL = [
+// Exported for the schema-parity test, which pins this DDL against the
+// drizzle schema; schema.ts stays the source of truth, this is its inlined form.
+export const BOOTSTRAP_DDL = [
   `CREATE TABLE IF NOT EXISTS builds (
     slug TEXT PRIMARY KEY,
     repo TEXT NOT NULL,
@@ -134,6 +157,10 @@ const BOOTSTRAP_DDL = [
     payload TEXT NOT NULL,
     PRIMARY KEY (build, seq)
   )`,
+  // The build-digest scan (AUT-487): type-leading so the digest query's cost
+  // grows with the observation/terminal events themselves, not with total
+  // history. Idempotent at open, so pre-existing databases gain it too.
+  `CREATE INDEX IF NOT EXISTS events_type_build_seq ON events (type, build, seq)`,
   `CREATE TABLE IF NOT EXISTS artifacts (
     build TEXT NOT NULL,
     kind TEXT NOT NULL,
@@ -170,6 +197,19 @@ const BOOTSTRAP_DDL = [
     created_at TEXT NOT NULL,
     PRIMARY KEY (repo, kind, revision)
   )`,
+  `CREATE TABLE IF NOT EXISTS ticket_assets (
+    repo TEXT NOT NULL,
+    ticket_id TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    name TEXT NOT NULL,
+    revision INTEGER NOT NULL,
+    layout TEXT NOT NULL,
+    manifest TEXT NOT NULL,
+    size INTEGER NOT NULL,
+    removed INTEGER NOT NULL,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (repo, ticket_id, kind, name, revision)
+  )`,
   `CREATE TABLE IF NOT EXISTS sessions (
     id TEXT PRIMARY KEY,
     repo TEXT NOT NULL,
@@ -248,6 +288,15 @@ export interface SqliteBuildStoreOptions {
   retention?: { maxRevisions?: number }
 }
 
+function ticketAssetKey(repo: string, ticketId: string, kind: string, name: string) {
+  return and(
+    eq(ticketAssets.repo, repo),
+    eq(ticketAssets.ticketId, ticketId),
+    eq(ticketAssets.kind, kind),
+    eq(ticketAssets.name, name),
+  )
+}
+
 export class SqliteBuildStore implements BuildStore {
   private readonly sqlite: Database
   private readonly db: BunSQLiteDatabase
@@ -399,6 +448,7 @@ export class SqliteBuildStore implements BuildStore {
   }
 
   async createBuild(input: NewBuildInput): Promise<BuildRecord> {
+    const created = validateCreatedEvent(input)
     const ts = this.now()
     return this.writeTx(() => {
       if (this.buildRow(input.slug)) {
@@ -416,6 +466,7 @@ export class SqliteBuildStore implements BuildStore {
           updatedAt: ts,
         })
         .run()
+      if (created !== undefined) this.appendInTx(input.slug, created)
       return this.toRecord(this.requireBuild(input.slug))
     })
   }
@@ -430,6 +481,47 @@ export class SqliteBuildStore implements BuildStore {
     return rows.map((row) => this.toRecord(row))
   }
 
+  async getRepoBuildDigests(repo: string): Promise<Map<string, BuildDigest>> {
+    // From the builds side (AUT-487): the type filter lives in the ON clause
+    // so a build whose log holds none of the digest-relevant event
+    // types still yields its row — a join that starts from `events` would
+    // silently drop such builds and break the operation's completeness
+    // contract. Only the digest-relevant types are fetched, then one shared
+    // derivation
+    // per build, so the answer cannot drift from `reduceBuild`.
+    const rows = this.sqlite
+      .query(
+        `SELECT b.slug AS slug, e.seq AS seq, e.ts AS ts, e.type AS type
+         FROM builds b
+         LEFT JOIN events e
+           ON e.build = b.slug AND e.type IN (${DIGEST_EVENT_TYPES.map(() => '?').join(', ')})
+         WHERE b.repo = ?
+         ORDER BY b.slug, e.seq`,
+      )
+      .all(...DIGEST_EVENT_TYPES, repo) as {
+      slug: string
+      seq: number | null
+      ts: string | null
+      type: string | null
+    }[]
+    const eventsByBuild = new Map<string, Pick<AbEvent, 'type' | 'seq' | 'ts'>[]>()
+    for (const row of rows) {
+      if (row.seq === null || row.ts === null || row.type === null) continue
+      const events = eventsByBuild.get(row.slug) ?? []
+      events.push({ type: row.type as AbEvent['type'], seq: row.seq, ts: row.ts })
+      eventsByBuild.set(row.slug, events)
+    }
+    const digests = new Map<string, BuildDigest>()
+    for (const row of rows) {
+      if (digests.has(row.slug)) continue
+      digests.set(row.slug, {
+        slug: row.slug,
+        ...reduceBuildDigest(eventsByBuild.get(row.slug) ?? []),
+      })
+    }
+    return digests
+  }
+
   /** Current build-stream tail inside an open transaction. */
   private currentSeqInTx(slug: string): number {
     this.requireBuild(slug)
@@ -664,6 +756,10 @@ export class SqliteBuildStore implements BuildStore {
       },
       waitSeconds: opts?.waitSeconds,
       signal: opts?.signal,
+      // Hosted budget: held build-event reads poll at most once per second
+      // (AUT-394) — not the 25 ms stream default, which is presentation
+      // content's cadence.
+      pollMs: EVENT_WAIT_POLL_MS,
     })
   }
 
@@ -935,9 +1031,81 @@ export class SqliteBuildStore implements BuildStore {
       },
       waitSeconds: opts?.waitSeconds,
       signal: opts?.signal,
+      // Hosted budget: held repository-event reads poll at most once per
+      // second (AUT-394) — not the 25 ms stream default, which is
+      // presentation content's cadence.
+      pollMs: EVENT_WAIT_POLL_MS,
     })
   }
 
+  async getRepoStateEvents(repo: string): Promise<RepositoryEvent[]> {
+    this.requireRepo(repo)
+    // Two queries, mirroring the oracle's derivation: the latest
+    // run-started anchor, then one select of durable types plus the tail
+    // from that anchor. No new index: local journals are small and the
+    // existing (repo, seq) PK index keeps the anchor scan acceptable.
+    //
+    // The two drizzle reads are synchronous, so there is no in-process await
+    // point between them — but a concurrent writer from another process can
+    // still land between the two statements in real time (AUT-551): a
+    // first-ever `dispatcher.run-started` appended between them would be
+    // invisible to the probe, absent from the durable-only selection, yet
+    // present in the journal by the time this method returns. The shared
+    // helper below closes that window with a one-shot anchor re-check on the
+    // durable-only outcome: a durable-only result is returned only when the
+    // journal was anchor-free as of the final probe. When the probe *does*
+    // find an anchor, the anchored select's `gte(seq, anchor)` arm is
+    // monotone-inclusive, so any later run-started is picked up by that same
+    // select; an append after the final re-probe is an ordinary post-read
+    // concurrent append, not this race.
+    return readRepoStateEventsWithAnchorRecheck(
+      async () => {
+        // This probe is a LIMIT 1 select, not an aggregate: it returns zero or
+        // one rows, so row absence is the deliberate empty-journal signal — no
+        // MAX() NULL semantics involved (contrast the Postgres adapter's
+        // MAX(seq) probe, which always returns one row and must test the NULL
+        // explicitly). The `anchor === undefined` branch in the select below is
+        // the explicit durable-only path; a null anchor must never reach the
+        // gte(repoEvents.seq, anchor) arm (in either dialect the comparison is
+        // never true, so the durable-only outcome would then survive only by
+        // accident), and the no-anchor case must not degenerate into
+        // gte(repoEvents.seq, 0), which would select the whole journal.
+        const anchorRows = this.db
+          .select({ seq: repoEvents.seq })
+          .from(repoEvents)
+          .where(and(eq(repoEvents.repo, repo), eq(repoEvents.type, 'dispatcher.run-started')))
+          .orderBy(desc(repoEvents.seq))
+          .limit(1)
+          .all()
+        return anchorRows[0]?.seq
+      },
+      async (anchor) => {
+        const durable = inArray(repoEvents.type, [...REPOSITORY_STATE_EVENT_TYPES])
+        const rows = this.db
+          .select()
+          .from(repoEvents)
+          .where(
+            anchor === undefined
+              ? and(eq(repoEvents.repo, repo), durable)
+              : and(eq(repoEvents.repo, repo), or(gte(repoEvents.seq, anchor), durable)),
+          )
+          .orderBy(asc(repoEvents.seq))
+          .all()
+        return rows.map(
+          (row) =>
+            ({
+              repo: row.repo,
+              seq: row.seq,
+              ts: row.ts,
+              actor: row.actor,
+              type: row.type,
+              payload: row.payload,
+            }) as RepositoryEvent,
+        )
+      },
+    )
+  }
+
   async putRepoArtifact(repo: string, artifact: ArtifactInput): Promise<RepositoryArtifactMeta> {
     const prepared = await this.prepareArtifact(artifact)
     return this.writeTx(() => this.depositRepoInTx(repo, prepared))
@@ -994,6 +1162,144 @@ export class SqliteBuildStore implements BuildStore {
       .map((row) => this.toRepoMeta(row))
   }
 
+  async ticketAssetLimits(_repo: string): Promise<TicketAssetLimits> {
+    return { ...DEFAULT_TICKET_ASSET_LIMITS }
+  }
+
+  private toTicketAssetMeta(row: typeof ticketAssets.$inferSelect): TicketAssetMeta {
+    return {
+      repo: row.repo,
+      ticketId: row.ticketId,
+      kind: row.kind,
+      name: row.name,
+      revision: row.revision,
+      layout: row.layout,
+      size: row.size,
+      entries: row.manifest,
+      createdAt: row.createdAt,
+    }
+  }
+
+  async putTicketAsset(
+    repo: string,
+    ticketId: string,
+    asset: TicketAssetInput,
+  ): Promise<TicketAssetMeta> {
+    const size = validateTicketAssetInput(asset)
+    const entries = await storeTicketAssetBlobs(this.blobs, asset.entries)
+    return this.writeTx(() => {
+      const latest = this.db
+        .select({ revision: ticketAssets.revision })
+        .from(ticketAssets)
+        .where(ticketAssetKey(repo, ticketId, asset.kind, asset.name))
+        .orderBy(desc(ticketAssets.revision))
+        .limit(1)
+        .get()
+      const row: typeof ticketAssets.$inferInsert = {
+        repo,
+        ticketId,
+        kind: asset.kind,
+        name: asset.name,
+        revision: (latest?.revision ?? -1) + 1,
+        layout: asset.layout,
+        manifest: entries,
+        size,
+        removed: 0,
+        createdAt: this.clock().toISOString(),
+      }
+      this.db.insert(ticketAssets).values(row).run()
+      return this.toTicketAssetMeta(row as typeof ticketAssets.$inferSelect)
+    })
+  }
+
+  async getTicketAsset(
+    repo: string,
+    ticketId: string,
+    kind: string,
+    name: string,
+    rev?: number,
+  ): Promise<TicketAsset | null> {
+    const scoped = ticketAssetKey(repo, ticketId, kind, name)
+    const row =
+      rev === undefined
+        ? this.db
+            .select()
+            .from(ticketAssets)
+            .where(scoped)
+            .orderBy(desc(ticketAssets.revision))
+            .limit(1)
+            .get()
+        : this.db
+            .select()
+            .from(ticketAssets)
+            .where(and(scoped, eq(ticketAssets.revision, rev)))
+            .get()
+    if (!row || row.removed) return null
+    return loadTicketAsset(this.blobs, this.toTicketAssetMeta(row))
+  }
+
+  async getPinnedTicketAsset(
+    slug: string,
+    kind: string,
+    name: string,
+    rev?: number,
+  ): Promise<TicketAsset | null> {
+    return resolvePinnedAsset(this, slug, kind, name, rev)
+  }
+
+  async listTicketAssets(
+    repo: string,
+    ticketId: string,
+    opts?: { revisions?: boolean },
+  ): Promise<TicketAssetSummary[]> {
+    const rows = this.db
+      .select()
+      .from(ticketAssets)
+      .where(and(eq(ticketAssets.repo, repo), eq(ticketAssets.ticketId, ticketId)))
+      .orderBy(asc(ticketAssets.kind), asc(ticketAssets.name), asc(ticketAssets.revision))
+      .all()
+    if (opts?.revisions) {
+      return rows
+        .filter((row) => !row.removed)
+        .map((row) => summarizeTicketAsset(this.toTicketAssetMeta(row)))
+    }
+    const latest = new Map<string, typeof ticketAssets.$inferSelect>()
+    for (const row of rows) latest.set(JSON.stringify([row.kind, row.name]), row)
+    return [...latest.values()]
+      .filter((row) => !row.removed)
+      .map((row) => summarizeTicketAsset(this.toTicketAssetMeta(row)))
+  }
+
+  async removeTicketAsset(
+    repo: string,
+    ticketId: string,
+    kind: string,
+    name: string,
+  ): Promise<TicketAssetMeta | null> {
+    return this.writeTx(() => {
+      const latest = this.db
+        .select()
+        .from(ticketAssets)
+        .where(ticketAssetKey(repo, ticketId, kind, name))
+        .orderBy(desc(ticketAssets.revision))
+        .limit(1)
+        .get()
+      if (!latest || latest.removed) return null
+      this.db
+        .insert(ticketAssets)
+        .values({
+          ...latest,
+          revision: latest.revision + 1,
+          manifest: [],
+          size: 0,
+          removed: 1,
+          createdAt: this.clock().toISOString(),
+        })
+        .run()
+      return this.toTicketAssetMeta(latest)
+    })
+  }
+
   async claimRepoLease(repo: string, holder: string, ttlMs: number): Promise<boolean> {
     return this.writeTx(() => {
       const row = this.requireRepo(repo)
@@ -1189,6 +1495,26 @@ export class SqliteBuildStore implements BuildStore {
     return this.writeTx(() => this.appendSessionInTx(id, validated) as SessionEventEnvelope<T>)
   }
 
+  async appendSessionEventIfCurrent<T extends SessionEventType>(
+    id: string,
+    expectedSeq: number,
+    event: SessionEventWrite<T>,
+  ): Promise<SessionEventEnvelope<T> | null> {
+    validateExpectedSeq(expectedSeq)
+    const validated = validateSessionEventWrite(event)
+    return this.writeTx(() => {
+      // BEGIN IMMEDIATE serializes this comparison and append across every
+      // SQLite connection/process using the same store file.
+      const row = this.db
+        .select({ count: sql<number>`count(*)` })
+        .from(sessionEvents)
+        .where(eq(sessionEvents.session, id))
+        .get()
+      if ((row?.count ?? 0) !== expectedSeq) return null
+      return this.appendSessionInTx(id, validated) as SessionEventEnvelope<T>
+    })
+  }
+
   async getSessionEvents(
     id: string,
     sinceSeq = 0,
@@ -1214,7 +1540,15 @@ export class SqliteBuildStore implements BuildStore {
           }) as SessionEvent,
       )
     }
-    return readEventsWithWait({ read, waitSeconds: opts?.waitSeconds, signal: opts?.signal })
+    return readEventsWithWait({
+      read,
+      waitSeconds: opts?.waitSeconds,
+      signal: opts?.signal,
+      // Hosted budget: held session-event reads poll at most once per second
+      // (AUT-394), matching the build and repository event reads — not the
+      // 25 ms stream default, which is presentation content's cadence.
+      pollMs: EVENT_WAIT_POLL_MS,
+    })
   }
 
   /** Runs inside an open transaction — see `depositInTx` for `prune`. */