@defrex/autobuild 0.12.0 → 0.13.0

package/packages/core/src/processes/harvest.ts

@@ -327,12 +327,17 @@ export async function reconcileHarvestLedger(
   )
   if (entries.length === 0) return []
 
-  const ids = entries.map((entry) => entry.ticket.id)
+  const ids = entries
+    .filter((entry) => entry.ticket.source === tickets.name)
+    .map((entry) => entry.ticket.id)
   const states = await tickets.dependencyStates(ids)
+  const byId = new Map(states.map((state) => [state.id, state]))
   const out: HarvestLedgerTicket[] = []
   for (let index = 0; index < entries.length; index += 1) {
     const entry = entries[index]!
-    const dependency = states[index] ?? {
+    const dependency = (entry.ticket.source === tickets.name
+      ? byId.get(entry.ticket.id)
+      : undefined) ?? {
       id: entry.ticket.id,
       exists: false,
       resolved: false,
@@ -341,7 +346,7 @@ export async function reconcileHarvestLedger(
     const current = dependency.exists ? await tickets.get(entry.ticket.id) : null
     out.push({
       proposalKey: entry.proposalKey,
-      ticket: structuredClone(entry.ticket),
+      ticket: structuredClone(current?.ref ?? entry.ticket),
       exists: dependency.exists,
       resolved: dependency.resolved,
       ...(current?.title !== undefined ? { title: current.title } : {}),
@@ -371,15 +376,25 @@ export async function reconcileOriginatingTickets(
   const states = matchingIds.length > 0 ? await tickets.dependencyStates(matchingIds) : []
   const byId = new Map(states.map((state) => [state.id, state]))
 
-  return refs.map((ticket) => {
-    const sourceMatches = ticket.source === tickets.name
-    const state = sourceMatches ? byId.get(ticket.id) : undefined
-    return {
-      ticket,
-      sourceMatches,
-      exists: state?.exists ?? false,
-      resolved: state?.resolved ?? false,
-    }
+  const identity = new Set<string>()
+  const projected = await Promise.all(
+    refs.map(async (ticket) => {
+      const sourceMatches = ticket.source === tickets.name
+      const state = sourceMatches ? byId.get(ticket.id) : undefined
+      const current = sourceMatches && state?.exists ? await tickets.get(ticket.id) : null
+      return {
+        ticket: current?.ref ?? ticket,
+        sourceMatches,
+        exists: state?.exists ?? false,
+        resolved: state?.resolved ?? false,
+      }
+    }),
+  )
+  return projected.filter((entry) => {
+    const key = `${entry.ticket.source}:${entry.ticket.id}`
+    if (identity.has(key)) return false
+    identity.add(key)
+    return true
   })
 }
 
@@ -536,9 +551,14 @@ export async function resolveHarvestCreateBlockers(
     const state = byId.get(id)
     return state?.exists === true && !state.resolved
   })
+  const canonical = new Map<string, string>()
+  for (const id of candidates) {
+    if (byId.get(id)?.exists) canonical.set(id, (await tickets.get(id))?.ref.id ?? id)
+  }
+  const project = (ids: string[]) => [...new Set(ids.map((id) => canonical.get(id) ?? id))]
   return {
-    blockedBy: [...new Set([...declared, ...derived])],
-    provenance: { declared, derived },
+    blockedBy: project([...declared, ...derived]),
+    provenance: { declared: project(declared), derived: project(derived) },
   }
 }
 

package/packages/core/src/processes/phase-failure-budget.ts

@@ -12,6 +12,7 @@ export const POLICY_PHASE_FAILURE_RESET_SCOPES = {
   'verify-failure-limit': 'all-phase-rounds',
   'reconcile-no-progress': 'none',
   'dispatch-failure-limit': 'none',
+  'execution-no-progress': 'none',
   'setup-failure-limit': 'none',
   'infrastructure-failure-limit': 'none',
   'phase-attempt-limit': 'matching-round',

package/packages/core/src/processes/repo-view.ts

@@ -1,3 +1,4 @@
+import { executionNoProgressReducer } from './execution-no-progress'
 /**
  * The dispatcher's in-process repository view (AUT-647): a `BuildStore`
  * decorator that builds the state a tick needs once, at the first refresh, and
@@ -154,6 +155,7 @@ const EXTRA_REDUCERS = {
     finish: buildDigestReducer.finish,
   },
   logIndex: logIndexReducer,
+  executionNoProgress: executionNoProgressReducer,
   openExecution: openExecutionReducer,
   openBuildWorkspace: openBuildWorkspaceReducer,
   publicationState: publicationStateReducer,
@@ -186,6 +188,7 @@ const WORK_BUNDLE_REDUCER = { version: WORK_BUNDLE_VERSION }
 /** The facts a quiet-path stage needs about one build, without its event array. */
 export interface BuildFacts {
   state: BuildState
+  executionNoProgress: ReturnType<typeof executionNoProgressReducer.finish>
   log: LogIndex
   open: OpenExecution | null
   /** The open workspace (the latest provisioned, not yet released). */
@@ -279,6 +282,37 @@ function retainedShape(retained: unknown[], cursor: number): boolean {
 /** Structural checks on the small accumulators a later fold dereferences. */
 function extraAccsShape(extra: ExtraAccs): boolean {
   const field = (acc: unknown, key: string): unknown => (isObject(acc) ? acc[key] : undefined)
+  const emptyCount = field(extra.executionNoProgress, 'count')
+  const emptyOpen = field(extra.executionNoProgress, 'open')
+  if (
+    typeof emptyCount !== 'number' ||
+    !Number.isSafeInteger(emptyCount) ||
+    emptyCount < 0 ||
+    !Array.isArray(emptyOpen) ||
+    !emptyOpen.every((id) => typeof id === 'string')
+  )
+    return false
+  const emptyLatest = field(extra.executionNoProgress, 'latest')
+  if (
+    emptyLatest !== null &&
+    !(
+      isObject(emptyLatest) &&
+      typeof emptyLatest.instance === 'string' &&
+      typeof emptyLatest.seq === 'number'
+    )
+  )
+    return false
+  const active = field(extra.executionNoProgress, 'active')
+  if (
+    active !== null &&
+    !(
+      isObject(active) &&
+      typeof active.instance === 'string' &&
+      typeof active.seq === 'number' &&
+      typeof active.eligible === 'boolean'
+    )
+  )
+    return false
   const open = field(extra.openExecution, 'open')
   if (open !== null && !(isObject(open) && typeof open.instance === 'string')) return false
   const workspace = field(extra.openBuildWorkspace, 'open')
@@ -914,6 +948,7 @@ export class RepoViewStore implements BuildStore {
       const extra = log.extra!
       return {
         state: buildReducer.finish(log.acc!),
+        executionNoProgress: executionNoProgressReducer.finish(extra.executionNoProgress as never),
         log: logIndexReducer.finish(extra.logIndex as never),
         open: openExecutionReducer.finish(extra.openExecution as never),
         workspace: openBuildWorkspaceReducer.finish(extra.openBuildWorkspace as never),

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

@@ -1,3 +1,5 @@
+import { prepareAssetSnapshots } from './ticket-asset-snapshots'
+import { MemoryBuildStore } from './memory'
 /**
  * Reusable contract suites for the BuildStore seam (SPEC §7). The in-memory
  * adapter's behavior *is* the contract; every adapter — SQLite (§7.2.1),
@@ -2514,7 +2516,7 @@ export function describeBuildStoreContract(name: string, factory: BuildStoreFact
       async function pinnedBuild(
         store: BuildStore,
         slug: string,
-        assets: ReturnType<typeof pinOf>[],
+        assets: import('../events/payloads').PinnedAsset[],
       ): Promise<void> {
         const created = buildCreatedWrite()
         await store.createBuild({
@@ -2523,6 +2525,35 @@ export function describeBuildStoreContract(name: string, factory: BuildStoreFact
         })
       }
 
+      test('snapshot pins read independent bytes, historical revisions and scoped access', async () => {
+        await withStore(factory, undefined, async (store) => {
+          const source = new MemoryBuildStore()
+          await source.putTicketAsset(REPO, 'TICK-1', file('a.txt', 'remote one'))
+          await store.putTicketAsset(REPO, 'TICK-1', file('a.txt', 'local conflict'))
+          const pins = await prepareAssetSnapshots(source, store, REPO, 'TICK-1')
+          await pinnedBuild(store, 'snapshot-pin', pins)
+          await source.putTicketAsset(REPO, 'TICK-1', file('a.txt', 'remote two'))
+          const newer = await prepareAssetSnapshots(source, store, REPO, 'TICK-1')
+          await store.append('snapshot-pin', {
+            actor: KERNEL,
+            type: 'spec.revised',
+            payload: { artifact: { kind: 'spec', rev: 1 }, escalation: 1, assets: newer },
+          })
+          await source.removeTicketAsset(REPO, 'TICK-1', 'design', 'a.txt')
+          expect(text(await store.getPinnedTicketAsset('snapshot-pin', 'design', 'a.txt'))).toBe(
+            'remote two',
+          )
+          expect(text(await store.getPinnedTicketAsset('snapshot-pin', 'design', 'a.txt', 0))).toBe(
+            'remote one',
+          )
+          expect(await store.getPinnedTicketAsset('snapshot-pin', 'design', 'a.txt', 2)).toBeNull()
+          const scoped = store.scopeBuild('snapshot-pin')
+          expect(text(await scoped.getPinnedTicketAsset('snapshot-pin', 'design', 'a.txt'))).toBe(
+            'remote two',
+          )
+        })
+      })
+
       test('reads the pinned revision after the ticket replaces and then removes the asset', async () => {
         await withStore(factory, undefined, async (store) => {
           const v0 = await store.putTicketAsset(REPO, 'TICK-1', file('a.txt', 'one'))

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

@@ -2036,7 +2036,7 @@ export class SqliteBuildStore implements BuildStore {
             return { stale: false, record: this.toStreamRecord(this.requireStream(streamId)) }
           },
         )
-        if (!committed.stale) return committed.record
+        if (committed.stale === false) return committed.record
         // A foreign appender landed inside the prepare window; loop and
         // re-prepare from the newer chunk set so its acknowledged chunk is
         // not omitted from the finalized artifact.

package/packages/core/src/store/ticket-asset-snapshots.ts

@@ -0,0 +1,192 @@
+import { randomUUID } from 'node:crypto'
+import { gzipSync, gunzipSync } from 'node:zlib'
+import { z } from 'zod'
+import type { TicketAssetStore } from '../ports/types'
+import type { PinnedAsset } from '../events/payloads'
+import { contentHash, type BuildStore } from './types'
+import {
+  pinnedAssetOf,
+  summarizeTicketAsset,
+  validateTicketAssetInput,
+  validateTicketAssetStructure,
+  type TicketAsset,
+} from './ticket-assets'
+
+const CHUNK_BYTES = 256 * 1024
+const refSchema = z.strictObject({
+  kind: z.string().regex(/^ticket-snapshot-[a-f0-9-]+$/),
+  revision: z.number().int().nonnegative(),
+})
+const manifestSchema = z.strictObject({
+  version: z.literal(1),
+  meta: z.strictObject({
+    repo: z.string(),
+    ticketId: z.string(),
+    kind: z.string(),
+    name: z.string(),
+    revision: z.number().int().nonnegative(),
+    layout: z.enum(['file', 'tree']),
+    size: z.number().int().nonnegative(),
+    createdAt: z.string(),
+    entries: z.array(
+      z.discriminatedUnion('type', [
+        z.strictObject({ type: z.literal('dir'), path: z.string() }),
+        z.strictObject({
+          type: z.literal('file'),
+          path: z.string(),
+          size: z.number().int().nonnegative(),
+          blobRef: z.string(),
+        }),
+      ]),
+    ),
+  }),
+  files: z.array(
+    z.strictObject({
+      path: z.string(),
+      chunks: z.array(
+        refSchema.extend({ hash: z.string(), size: z.number().int().min(1).max(CHUNK_BYTES) }),
+      ),
+    }),
+  ),
+})
+
+function verifyMetadata(
+  meta: TicketAsset['meta'],
+  repo: string,
+  ticketId: string,
+  pin: PinnedAsset,
+): void {
+  const summary = pinnedAssetOf(summarizeTicketAsset(meta))
+  if (
+    meta.repo !== repo ||
+    meta.ticketId !== ticketId ||
+    Object.entries(summary).some(([key, value]) => pin[key as keyof typeof summary] !== value) ||
+    validateTicketAssetStructure(meta) !== meta.size
+  )
+    throw new Error('inconsistent ticket asset snapshot metadata')
+}
+
+function verify(asset: TicketAsset, repo: string, ticketId: string, pin: PinnedAsset): void {
+  const { meta, entries } = asset
+  verifyMetadata(meta, repo, ticketId, pin)
+  if (
+    validateTicketAssetInput({ ...meta, entries }) !== meta.size ||
+    entries.length !== meta.entries.length
+  ) {
+    throw new Error('inconsistent ticket asset snapshot metadata')
+  }
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i]!
+    const stored = meta.entries[i]!
+    if (
+      entry.path !== stored.path ||
+      entry.type !== stored.type ||
+      (entry.type === 'file' &&
+        stored.type === 'file' &&
+        (entry.content.length !== stored.size || contentHash(entry.content) !== stored.blobRef))
+    ) {
+      throw new Error('inconsistent ticket asset snapshot content')
+    }
+  }
+}
+
+/** Copy exact sampled revisions before publishing any pins. No current ticket rows
+ * are written to the destination; their revision sequences remain independent. */
+export async function prepareAssetSnapshots(
+  source: Pick<TicketAssetStore, 'listTicketAssets' | 'getTicketAsset'>,
+  store: Pick<BuildStore, 'putRepoArtifact' | 'ensureRepo'>,
+  repo: string,
+  ticketId: string,
+  canonicalTicketId: string = ticketId,
+): Promise<PinnedAsset[]> {
+  const pins = (await source.listTicketAssets(repo, ticketId)).map(pinnedAssetOf)
+  if (pins.length > 0) await store.ensureRepo(repo)
+  for (const pin of pins) {
+    const asset = await source.getTicketAsset(repo, ticketId, pin.kind, pin.name, pin.revision)
+    if (!asset) throw new Error('sampled ticket asset revision is missing')
+    manifestSchema.shape.meta.parse(asset.meta)
+    verify(asset, repo, canonicalTicketId, pin)
+    const files = []
+    for (const entry of asset.entries) {
+      if (entry.type !== 'file') continue
+      const chunks = []
+      for (let start = 0; start < entry.content.length; start += CHUNK_BYTES) {
+        const bytes = entry.content.slice(start, start + CHUNK_BYTES)
+        const meta = await store.putRepoArtifact(repo, {
+          kind: `ticket-snapshot-${randomUUID()}`,
+          content: bytes,
+        })
+        chunks.push({
+          kind: meta.kind,
+          revision: meta.revision,
+          size: bytes.length,
+          hash: contentHash(bytes),
+        })
+      }
+      files.push({ path: entry.path, chunks })
+    }
+    const meta = await store.putRepoArtifact(repo, {
+      kind: `ticket-snapshot-${randomUUID()}`,
+      // Compression also bounds manifests with many maximum-length escaped paths.
+      content: gzipSync(JSON.stringify({ version: 1, meta: { ...asset.meta, ticketId }, files })),
+    })
+    pin.snapshot = { kind: meta.kind, revision: meta.revision }
+  }
+  return pins
+}
+
+export async function readAssetSnapshot(
+  store: Pick<BuildStore, 'getRepoArtifact'>,
+  repo: string,
+  ticketId: string,
+  pin: PinnedAsset,
+  historicalTicketId?: string,
+): Promise<TicketAsset> {
+  if (!pin.snapshot) throw new Error('missing snapshot reference')
+  const artifact = await store.getRepoArtifact(repo, pin.snapshot.kind, pin.snapshot.revision)
+  if (!artifact) throw new Error('ticket asset snapshot manifest is missing')
+  const manifest = manifestSchema.parse(
+    JSON.parse(gunzipSync(artifact.content, { maxOutputLength: 4 * 1024 * 1024 }).toString('utf8')),
+  )
+  // BuildStore projections can display a readable ID while the immutable
+  // build.created event and its older snapshots retain the storage alias.
+  const snapshotTicketId =
+    manifest.meta.ticketId === historicalTicketId ? historicalTicketId : ticketId
+  verifyMetadata(manifest.meta, repo, snapshotTicketId, pin)
+  const entries: TicketAsset['entries'] = []
+  const files = new Map(manifest.files.map((file) => [file.path, file]))
+  if (
+    files.size !== manifest.files.length ||
+    files.size !== manifest.meta.entries.filter((entry) => entry.type === 'file').length
+  ) {
+    throw new Error('inconsistent ticket asset snapshot files')
+  }
+  for (const entry of manifest.meta.entries) {
+    if (entry.type === 'dir') {
+      entries.push(entry)
+      continue
+    }
+    const file = files.get(entry.path)
+    if (!file || file.chunks.reduce((size, chunk) => size + chunk.size, 0) !== entry.size) {
+      throw new Error('inconsistent ticket asset snapshot chunks')
+    }
+    const content = new Uint8Array(entry.size)
+    let offset = 0
+    for (const chunk of file.chunks) {
+      const artifact = await store.getRepoArtifact(repo, chunk.kind, chunk.revision)
+      if (
+        !artifact ||
+        artifact.content.length !== chunk.size ||
+        contentHash(artifact.content) !== chunk.hash
+      ) {
+        throw new Error('ticket asset snapshot chunk is missing or corrupt')
+      }
+      content.set(artifact.content, offset)
+      offset += chunk.size
+    }
+    entries.push({ type: 'file', path: entry.path, content })
+  }
+  const asset = { meta: manifest.meta, entries }
+  verify(asset, repo, snapshotTicketId, pin)
+  return asset
+}

package/packages/core/src/store/ticket-assets.ts

@@ -1,13 +1,15 @@
 /**
  * Ticket assets (SPEC §7.1): named, versioned bundles of files attached to a
- * ticket and kept in the BuildStore, keyed by `(repo, ticketId, kind, name)`.
- * The ticket source never stores the contents; it only gets a note through
+ * ticket and kept in its service (hosted) or BuildStore (other sources), keyed by `(repo, ticketId, kind, name)`.
+ * Sources also get a human-readable note through
  * `TicketSource.comment()` (SPEC §13).
  *
  * This module is the shared, adapter-independent half: the types, the limits,
  * and the one validator every adapter calls before any write.
  */
 
+import { readAssetSnapshot, prepareAssetSnapshots } from './ticket-asset-snapshots'
+import type { TicketSource, TicketAssetStore } from '../ports/types'
 import type { AbEvent } from '../events/catalog'
 import type { PinnedAsset } from '../events/payloads'
 import { defineReducer } from '../kernel/incremental'
@@ -56,7 +58,8 @@ export interface TicketAssetMeta {
   ticketId: string
   kind: string
   name: string
-  /** 0-based per `(repo, ticketId, kind, name)`. A removal consumes a number
+  /** Increasing per `(repo, ticketId, kind, name)` (normally from zero; native
+   * file revisions reserve a separate range for legacy compatibility). A removal consumes a number
    * too (a tombstone), so revisions may skip. */
   revision: number
   layout: TicketAssetLayout
@@ -380,7 +383,27 @@ export async function samplePinnedAssets(
   return (await store.listTicketAssets(repo, ticketId)).map(pinnedAssetOf)
 }
 
-export const PINNED_ASSETS_REDUCER_VERSION = 1
+export async function preparePinnedAssets(
+  source: TicketSource,
+  store: BuildStore,
+  repo: string,
+  ticketId: string,
+): Promise<PinnedAsset[]> {
+  if (!source.assets) {
+    if (source.name === 'hosted') throw new Error('hosted ticket source has no asset capability')
+    return samplePinnedAssets(store, repo, ticketId)
+  }
+  const ticket = await source.get(ticketId)
+  return prepareAssetSnapshots(
+    composeTicketAssets(source, store),
+    store,
+    repo,
+    ticketId,
+    ticket?.ref.id ?? ticketId,
+  )
+}
+
+export const PINNED_ASSETS_REDUCER_VERSION = 2
 
 /** The asset sets recorded by every `build.created`/`spec.revised` pin event
  * that carries one, in array order. Each pin event replaces the set, so the
@@ -443,7 +466,7 @@ export function findPinnedRevision(
  * needed, so a finished build still answers. Null when the build never pinned
  * `kind/name` (or the revision). Rejects an unknown build. */
 export async function resolvePinnedAsset(
-  store: Pick<BuildStore, 'getBuild' | 'getEvents' | 'getTicketAsset'>,
+  store: Pick<BuildStore, 'getBuild' | 'getEvents' | 'getTicketAsset' | 'getRepoArtifact'>,
   slug: string,
   kind: string,
   name: string,
@@ -452,7 +475,62 @@ export async function resolvePinnedAsset(
   const record = await store.getBuild(slug)
   if (record === null) throw new Error(`unknown build "${slug}"`)
   if (record.ticket === undefined) return null
-  const revision = findPinnedRevision(await store.getEvents(slug), kind, name, rev)
-  if (revision === undefined) return null
-  return store.getTicketAsset(record.repo, record.ticket.id, kind, name, revision)
+  const events = await store.getEvents(slug)
+  const sets = pinnedAssetsReducer.reduce(events).pins
+  const pin =
+    rev === undefined
+      ? sets.at(-1)?.find((a) => a.kind === kind && a.name === name)
+      : sets.flat().find((a) => a.kind === kind && a.name === name && a.revision === rev)
+  if (!pin) return null
+  if (pin.snapshot) {
+    const created = events.find((event) => event.type === 'build.created')
+    const asset = await readAssetSnapshot(
+      store,
+      record.repo,
+      record.ticket.id,
+      pin,
+      created?.type === 'build.created' ? created.payload.ticket?.id : undefined,
+    )
+    return { ...asset, meta: { ...asset.meta, ticketId: record.ticket.id } }
+  }
+  return store.getTicketAsset(record.repo, record.ticket.id, kind, name, pin.revision)
+}
+
+/** Native writes; merged reads preserve legacy file attachments and recorded revisions. */
+export function composeTicketAssets(
+  source: TicketSource,
+  legacy: TicketAssetStore,
+): TicketAssetStore {
+  const native = source.assets
+  if (!native) return legacy
+  if (!native.hasTicketAssetHistory) return native
+  const owns = (repo: string, id: string, kind: string, name: string) =>
+    native.hasTicketAssetHistory!(repo, id, kind, name)
+  return {
+    ticketAssetLimits: native.ticketAssetLimits.bind(native),
+    putTicketAsset: native.putTicketAsset.bind(native),
+    async getTicketAsset(repo, id, kind, name, rev) {
+      if (rev !== undefined)
+        return (
+          (await native.getTicketAsset(repo, id, kind, name, rev)) ??
+          legacy.getTicketAsset(repo, id, kind, name, rev)
+        )
+      return (await owns(repo, id, kind, name))
+        ? native.getTicketAsset(repo, id, kind, name)
+        : legacy.getTicketAsset(repo, id, kind, name)
+    },
+    async listTicketAssets(repo, id) {
+      const current = await native.listTicketAssets(repo, id)
+      for (const item of await legacy.listTicketAssets(repo, id)) {
+        if (!(await owns(repo, id, item.kind, item.name))) current.push(item)
+      }
+      return current
+    },
+    async removeTicketAsset(repo, id, kind, name) {
+      const previous = await this.getTicketAsset(repo, id, kind, name)
+      if (!previous) return null
+      await native.removeTicketAsset(repo, id, kind, name)
+      return previous?.meta ?? null
+    },
+  }
 }

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

@@ -412,7 +412,7 @@ export interface BuildStore {
   listRepoArtifacts(repo: string, kind?: string): Promise<RepositoryArtifactMeta[]>
   // ── Ticket assets (SPEC §7.1 — files attached to a ticket) ─────────────
   // Keyed by (repo, ticketId, kind, name); revisions are 0-based. The store
-  // owns the bytes, the ticket source only ever gets a note (SPEC §13).
+  // owns these bytes; hosted current assets use the ticket service store (SPEC §13).
   /** The effective ceilings this store accepts for `repo` (a remote
    * deployment may advertise lower ones than the defaults). */
   ticketAssetLimits(repo: string): Promise<TicketAssetLimits>