@defrex/autobuild 0.12.0 → 0.14.0

package/packages/core/src/kernel/auto-merge.ts

@@ -1,3 +1,4 @@
+import { readDeferralLedger } from '../store/reduced-reads'
 import type { AbEvent, EventEnvelope, EventWrite } from '../events/catalog'
 import { KERNEL } from '../events/envelope'
 import { autoMergeDeferralClasses, type AutoMergeDeferralReason } from '../ports/types'
@@ -322,10 +323,10 @@ export async function recordAutoMergeDeferralObservation(
 ): Promise<EventEnvelope<'observation.recorded'> | null> {
   if (autoMergeDeferralClasses[reason.code] === 'pipeline-resolved') return null
   while (true) {
-    const events = await store.getEvents(slug)
-    if (hasAutoMergeDeferralObservation(events, prNumber, commandSeq)) return null
+    const current = await readDeferralLedger(store, slug)
+    if (deferralObservationFrom(current.value, prNumber, commandSeq)) return null
 
-    const expectedSeq = events.at(-1)?.seq ?? 0
+    const expectedSeq = current.cursor
     const appended = await store.appendIfCurrent(
       slug,
       expectedSeq,
@@ -334,3 +335,18 @@ export async function recordAutoMergeDeferralObservation(
     if (appended !== null) return appended
   }
 }
+
+/** Clock-independent merge attention shared by persisted seeds and CLI output. */
+export function mergeAttentionFromFacts(state: BuildState, ledger: DeferralLedger) {
+  if (
+    !state.finalizeCompletedSeq ||
+    !state.pr ||
+    state.prState !== 'open' ||
+    state.status === 'done' ||
+    state.status === 'aborted'
+  )
+    return null
+  const deferral = currentAutoMergeDeferralFrom(ledger, state)
+  if (state.autoMerge.requested && deferral === undefined) return null
+  return { pr: state.pr, reason: deferral ?? 'Auto-merge is not armed' }
+}

package/packages/core/src/kernel/dispatcher-liveness.ts

@@ -18,6 +18,9 @@ export function projectDispatcherLiveness(
         (e.type === 'dispatcher.tick-completed' || e.type === 'dispatcher.tick-failed') &&
         e.payload.run === id,
     )
+    const finished = record?.tick?.finished?.run === id ? record.tick.finished : undefined
+    const useSample = finished !== undefined && (!tick || finished.completedAt >= tick.ts)
+    const lastTickAt = useSample ? finished.completedAt : (tick?.ts ?? null)
     const heartbeatAt =
       record?.lease?.holder === id && start && record.heartbeatAt && record.heartbeatAt >= start.ts
         ? record.heartbeatAt
@@ -30,10 +33,13 @@ export function projectDispatcherLiveness(
       heartbeatAt,
       heartbeatAgeMs: heartbeatAt === null ? null : age(heartbeatAt),
       leaseExpiresAt: record?.lease?.holder === id ? record.lease.expiresAt : null,
-      lastTickAt: tick?.ts ?? null,
-      lastTickAgeMs: tick ? age(tick.ts) : null,
-      lastTick:
-        tick?.type === 'dispatcher.tick-completed'
+      lastTickAt,
+      lastTickAgeMs: lastTickAt ? age(lastTickAt) : null,
+      lastTick: useSample
+        ? finished.outcome === 'completed'
+          ? { outcome: 'completed' as const, counters: finished.counters }
+          : { outcome: 'failed' as const, error: finished.error }
+        : tick?.type === 'dispatcher.tick-completed'
           ? { outcome: 'completed' as const, counters: tick.payload.counters }
           : tick?.type === 'dispatcher.tick-failed'
             ? { outcome: 'failed' as const, error: tick.payload.error }

package/packages/core/src/kernel/generators/build-log.ts

@@ -151,7 +151,7 @@ function randomWrite(rand: () => number): EventWrite {
         id,
         phase: 'plan',
         source: 'policy',
-        policyCause: 'infrastructure-failure-limit',
+        policyCause: round % 2 === 0 ? 'execution-no-progress' : 'infrastructure-failure-limit',
         question: 'q',
       }),
     () =>

package/packages/core/src/kernel/generators/repository-journals.ts

@@ -119,13 +119,24 @@ export function randomSettingsJournal(seed: number, length: number): RepositoryE
 }
 
 const counters = {
-  claimed: 0,
-  launched: 0,
   merged: 0,
   closed: 0,
   conflicted: 0,
-  reconciled: 0,
+  abandoned: 0,
+  discarded: 0,
+  janitorFailed: 0,
+  recovered: 0,
+  dispatchFailed: 0,
+  resumed: 0,
+  swept: 0,
+  dispatched: 0,
+  authored: 0,
+  bounced: 0,
+  claimRaces: 0,
+  invalidTickets: 0,
+  dependencyBlocked: 0,
   harvestStarted: 0,
+  harvestResumed: 0,
   harvestCompleted: 0,
   harvestEscalated: 0,
   harvestFailed: 0,

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

@@ -741,32 +741,34 @@ export function harvestCreationsDuringReadyScan(
   beforeEvents: readonly RepositoryEvent[],
   afterEvents: readonly RepositoryEvent[],
 ): InFlightHarvestCreation[] {
-  const before = reduceHarvest(beforeEvents)
-  // Validate the complete second snapshot before using its event suffix.
-  reduceHarvest(afterEvents)
+  return harvestCreationsFromStates(reduceHarvest(beforeEvents), reduceHarvest(afterEvents))
+}
+
+export function harvestCreationsFromStates(
+  before: HarvestState,
+  after: HarvestState,
+): InFlightHarvestCreation[] {
   const creations = new Map<string, InFlightHarvestCreation>()
-  const keyOf = (run: string, proposalKey: string): string => `${run}\0${proposalKey}`
-  const known = new Set<string>()
-  for (const run of before.runs) {
+  const keyOf = (run: string, proposalKey: string) => `${run}\0${proposalKey}`
+  const known = new Set(
+    before.runs.flatMap((run) =>
+      run.reservations.map((entry) => keyOf(run.run, entry.proposalKey)),
+    ),
+  )
+  for (const creation of inFlightHarvestCreations(before))
+    creations.set(keyOf(creation.run, creation.proposalKey), creation)
+  for (const run of after.runs)
     for (const reservation of run.reservations) {
-      known.add(keyOf(run.run, reservation.proposalKey))
+      const key = keyOf(run.run, reservation.proposalKey)
+      if (known.has(key) || reservation.seq <= before.lastSeq) continue
+      known.add(key)
+      creations.set(key, {
+        run: run.run,
+        proposalKey: reservation.proposalKey,
+        creationKey: reservation.id,
+        reservationSeq: reservation.seq,
+      })
     }
-  }
-  for (const creation of inFlightHarvestCreations(before)) {
-    creations.set(keyOf(creation.run, creation.proposalKey), creation)
-  }
-  for (const event of afterEvents) {
-    if (event.seq <= before.lastSeq || event.type !== 'harvest.proposal.id-reserved') continue
-    const key = keyOf(event.payload.run, event.payload.proposalKey)
-    if (known.has(key)) continue
-    known.add(key)
-    creations.set(key, {
-      run: event.payload.run,
-      proposalKey: event.payload.proposalKey,
-      creationKey: event.payload.id,
-      reservationSeq: event.seq,
-    })
-  }
   return [...creations.values()]
 }
 

package/packages/core/src/kernel/incremental-fixtures.ts

@@ -99,7 +99,12 @@ export function randomBuildItem(rand: Rand): readonly [string, Record<string, un
     ],
     () => [
       'execution.ended',
-      { instance, workspaceRef: ref, outcome: pick(rand, ['completed', 'stopped', 'lost']) },
+      {
+        instance,
+        workspaceRef: ref,
+        outcome: pick(rand, ['completed', 'stopped', 'lost']),
+        ...(rand() < 0.5 ? { exitCode: pick(rand, [0, 1, null]) } : {}),
+      },
     ],
     () => [
       'workspace.provisioned',
@@ -132,7 +137,13 @@ export function randomBuildItem(rand: Rand): readonly [string, Record<string, un
         phase: pick(rand, ['setup', 'plan', 'implement', 'verify:unit']),
         source: pick(rand, ['policy', 'agent']),
         ...(rand() < 0.7
-          ? { policyCause: pick(rand, ['infrastructure-failure-limit', 'setup-failure-limit']) }
+          ? {
+              policyCause: pick(rand, [
+                'infrastructure-failure-limit',
+                'setup-failure-limit',
+                'execution-no-progress',
+              ]),
+            }
           : {}),
         ...(rand() < 0.5 ? { round: 1 } : {}),
         question: 'q',

package/packages/core/src/kernel/log-index-value.ts

@@ -0,0 +1,38 @@
+import type { LogIndex, LoopIndex, RoundRecord } from './log-index'
+type JsonLoop = Omit<LoopIndex, 'rounds'> & {
+  rounds: [number, RoundRecord][]
+}
+export type JsonLogIndex = Omit<LogIndex, 'plan' | 'code' | 'finalizeStepsDone'> & {
+  plan: JsonLoop
+  code: JsonLoop
+  finalizeStepsDone: string[]
+}
+export function encodeLog(log: LogIndex): JsonLogIndex {
+  return {
+    ...log,
+    plan: { ...log.plan, rounds: [...log.plan.rounds] },
+    code: { ...log.code, rounds: [...log.code.rounds] },
+    finalizeStepsDone: [...log.finalizeStepsDone],
+  }
+}
+export function decodeLog(log: JsonLogIndex): LogIndex {
+  const loop = (value: JsonLoop): LoopIndex => {
+    for (const entry of value.rounds) {
+      if (
+        entry.length !== 2 ||
+        !Number.isSafeInteger(entry[0]) ||
+        entry[1] === null ||
+        typeof entry[1] !== 'object' ||
+        Array.isArray(entry[1])
+      )
+        throw new Error('invalid persisted log-index round entry')
+    }
+    return { ...value, rounds: new Map(value.rounds) }
+  }
+  return {
+    ...log,
+    plan: loop(log.plan),
+    code: loop(log.code),
+    finalizeStepsDone: new Set(log.finalizeStepsDone),
+  }
+}