@defrex/autobuild 0.10.1 → 0.11.0

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

@@ -0,0 +1,70 @@
+import type { RepositoryEvent } from '../events/repository'
+import type { RepositoryRecord } from '../store/types'
+
+export function projectDispatcherLiveness(
+  record: RepositoryRecord | null,
+  events: RepositoryEvent[],
+  now: Date,
+) {
+  const ordered = [...events].sort((a, b) => a.seq - b.seq)
+  const age = (at: string) => Math.max(0, now.getTime() - Date.parse(at))
+  const run = (id: string) => {
+    const start = ordered.find((e) => e.type === 'dispatcher.run-started' && e.payload.run === id)
+    const stop = ordered.findLast(
+      (e) => e.type === 'dispatcher.run-stopped' && e.payload.run === id,
+    )
+    const tick = ordered.findLast(
+      (e) =>
+        (e.type === 'dispatcher.tick-completed' || e.type === 'dispatcher.tick-failed') &&
+        e.payload.run === id,
+    )
+    const heartbeatAt =
+      record?.lease?.holder === id && start && record.heartbeatAt && record.heartbeatAt >= start.ts
+        ? record.heartbeatAt
+        : null
+    return {
+      run: id,
+      pid: start?.type === 'dispatcher.run-started' ? start.payload.pid : null,
+      host: start?.type === 'dispatcher.run-started' ? (start.payload.host ?? null) : null,
+      startedAt: start?.ts ?? null,
+      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'
+          ? { outcome: 'completed' as const, counters: tick.payload.counters }
+          : tick?.type === 'dispatcher.tick-failed'
+            ? { outcome: 'failed' as const, error: tick.payload.error }
+            : null,
+      stoppedAt: stop?.ts ?? null,
+      stop: stop?.type === 'dispatcher.run-stopped' ? stop.payload : null,
+    }
+  }
+  const latest = ordered.findLast((e) => e.type === 'dispatcher.run-started')
+  const latestStop = ordered.findLast((e) => e.type === 'dispatcher.run-stopped')
+  const owner = record?.lease ? run(record.lease.holder) : null
+  const held =
+    owner !== null && owner.stop === null && Date.parse(record!.lease!.expiresAt) > now.getTime()
+  return {
+    state: held
+      ? ('held' as const)
+      : owner && !owner.stop
+        ? ('lost' as const)
+        : latestStop
+          ? ('stopped' as const)
+          : ('absent' as const),
+    holder: held ? owner : null,
+    expiredHolder: !held && owner && !owner.stop ? owner : null,
+    latestRun: latest?.type === 'dispatcher.run-started' ? run(latest.payload.run) : null,
+    latestStoppedRun:
+      latestStop?.type === 'dispatcher.run-stopped' ? run(latestStop.payload.run) : null,
+  }
+}
+export type DispatcherLiveness = ReturnType<typeof projectDispatcherLiveness>
+export function formatDispatcherIdentity(
+  run: NonNullable<DispatcherLiveness['latestRun']>,
+): string {
+  return `${run.run}; pid ${run.pid ?? 'unknown'}; host ${run.host ?? 'unknown'}; started ${run.startedAt ?? 'unknown'}; ${run.heartbeatAgeMs === null ? 'heartbeat unknown (no renewal attributable to this run)' : `heartbeat ${run.heartbeatAgeMs}ms ago`}`
+}

package/packages/core/src/kernel/reducer-registry.ts

@@ -1,3 +1,4 @@
+import { ticketSourceHealthReducer } from './ticket-source-health'
 /**
  * Every incremental reducer, with its published version and the whole-array
  * functions it backs. `reducer-registry.test.ts` snapshots the versions and
@@ -57,6 +58,7 @@ export interface RegisteredReducer {
 /** Parameterized reducers are registered with representative arguments; the
  * accumulator shape does not depend on them. */
 export const REDUCERS: Record<string, RegisteredReducer> = {
+  ticketSourceHealth: { reducer: ticketSourceHealthReducer, covers: ['reduceTicketSourceHealth'] },
   build: { reducer: buildReducer, covers: ['reduceBuild'] },
   harvest: { reducer: harvestReducer, covers: ['reduceHarvest'] },
   dispatchSettings: { reducer: dispatchSettingsReducer, covers: ['reduceDispatchSettings'] },
@@ -134,6 +136,8 @@ export const REDUCERS: Record<string, RegisteredReducer> = {
 /** Event-array functions that are deliberately not reducers, each with the
  * concrete reason. */
 export const EXCLUDED: Record<string, string> = {
+  projectDispatcherLiveness:
+    'combines mutable repository lease metadata and an explicit clock with correlated facts; cannot be restored from an event-only snapshot',
   decideNext: 'a decision function over config; returns a Decision, not a state',
   harvestCreationsDuringReadyScan:
     'a derived query over two reduceHarvest states (before/after), which is already incremental',

package/packages/core/src/kernel/ticket-source-health.ts

@@ -0,0 +1,30 @@
+import type { RepositoryEvent, RepositoryEventPayload } from '../events/repository'
+import { defineReducer } from './incremental'
+
+export type TicketSourceDegradation = RepositoryEventPayload<'dispatcher.ticket-source-degraded'>
+export const ticketSourceHealthReducer = defineReducer<
+  { active?: TicketSourceDegradation },
+  RepositoryEvent,
+  TicketSourceDegradation | undefined
+>({
+  version: 2,
+  initial: () => ({}),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'dispatcher.ticket-source-degraded') acc.active = event.payload
+      if (
+        event.type === 'dispatcher.ticket-source-dependency-limited' &&
+        acc.active?.cause === 'rate-limited' &&
+        acc.active.source === event.payload.source
+      )
+        acc.active = { ...acc.active, operation: 'dependency-check' }
+      if (event.type === 'dispatcher.ticket-source-recovered') delete acc.active
+    }
+  },
+  finish: (acc) => acc.active,
+})
+export function reduceTicketSourceHealth(
+  events: readonly RepositoryEvent[],
+): TicketSourceDegradation | undefined {
+  return ticketSourceHealthReducer.reduce(events)
+}

package/packages/core/src/operator/query.ts

@@ -1,3 +1,4 @@
+import { readDispatcherLiveness } from '../cli/dispatcher-liveness'
 import { composeBuildConfig } from '../config/live'
 import type { PipelineSourceMeta } from '../config/pipeline-source'
 import { configSchema, type Config } from '../config/schema'
@@ -255,10 +256,12 @@ export async function getOperatorBuild(opts: {
 export async function getRepositoryStatus(
   store: BuildStore,
   repo: string,
+  now = new Date(),
 ): Promise<RepositoryStatus> {
-  return withOperatorView(store, repo, 'journal', async (view) =>
-    projectRepositoryStatus(repo, view.recordedJournal()),
-  )
+  return withOperatorView(store, repo, 'journal', async (view) => {
+    const { dispatcher } = await readDispatcherLiveness(store, repo, now, view.recordedJournal())
+    return projectRepositoryStatus(repo, view.recordedJournal(), dispatcher)
+  })
 }
 
 export async function getHarvestStatus(

package/packages/core/src/ports/tickets/contract.ts

@@ -116,6 +116,29 @@ export function describeTicketSourceContract(
   factory: TicketSourceContractFactory,
 ): void {
   describe(`TicketSource contract: ${name}`, () => {
+    test('completion projections agree across create, get, listing, and transitions', async () => {
+      await withTicketSource(factory, async (harness) => {
+        const created = await createTracked(
+          harness,
+          {
+            title: contractTicketTitle('completion facts'),
+            body: CONTRACT_TICKET_BODY,
+          },
+          { state: harness.states.ready },
+        )
+        expect(created.resolved).toBe(false)
+        for (const state of [harness.states.completed, harness.states.ready]) {
+          await harness.source.transition(created.ref.id, state)
+          const [dependency] = await harness.source.dependencyStates([created.ref.id])
+          expect((await harness.source.get(created.ref.id))?.resolved).toBe(dependency?.resolved)
+          const listing = await harness.source.listReady({ state })
+          expect(listing.tickets.find((ticket) => ticket.ref.id === created.ref.id)?.resolved).toBe(
+            dependency?.resolved,
+          )
+          expect(dependency?.resolved).toBe(state === harness.states.completed)
+        }
+      })
+    })
     test('create/get round-trips common fields and honors an explicit state', async () => {
       await withTicketSource(factory, async (harness) => {
         const title = contractTicketTitle('round trip')
@@ -302,6 +325,8 @@ export function describeTicketSourceContract(
           },
           { state: harness.states.completed },
         )
+        expect(completed.resolved).toBe(true)
+        expect(unresolved.resolved).toBe(false)
         const dependent = await createTracked(
           harness,
           {

package/packages/core/src/ports/tickets/fake.ts

@@ -15,13 +15,14 @@ import type {
 } from '../types'
 import { validateTicketUpdate } from './update'
 
-function cloneTicket(ticket: Ticket): Ticket {
+function cloneTicket(ticket: Ticket, doneState: string): Ticket {
   return {
     ref: { ...ticket.ref },
     ...(ticket.creationKey !== undefined ? { creationKey: ticket.creationKey } : {}),
     title: ticket.title,
     body: ticket.body,
     state: ticket.state,
+    resolved: ticket.state === doneState,
     labels: [...ticket.labels],
     ...(ticket.blockedBy !== undefined ? { blockedBy: [...ticket.blockedBy] } : {}),
   }
@@ -61,14 +62,14 @@ export class FakeTicketSource implements TicketSource {
       doneState?: string
     } = {},
   ) {
+    this.doneState = opts.doneState ?? 'Done'
     for (const ticket of seed) {
-      this.tickets.set(ticket.ref.id, cloneTicket(ticket))
+      this.tickets.set(ticket.ref.id, cloneTicket(ticket, this.doneState))
       if (ticket.creationKey !== undefined) {
         this.idempotency.set(ticket.creationKey, ticket.ref.id)
       }
     }
     this.createState = opts.createState ?? 'Triage'
-    this.doneState = opts.doneState ?? 'Done'
   }
 
   /** Seed a ticket after construction — lets a test make one become Ready
@@ -76,7 +77,7 @@ export class FakeTicketSource implements TicketSource {
    * after its initial selection" (§12) gets a real oracle rather than a
    * vacuous one. */
   add(ticket: Ticket): void {
-    this.tickets.set(ticket.ref.id, cloneTicket(ticket))
+    this.tickets.set(ticket.ref.id, cloneTicket(ticket, this.doneState))
   }
 
   async listReady(criteria: {
@@ -92,14 +93,14 @@ export class FakeTicketSource implements TicketSource {
             (criteria.state === undefined || ticket.state === criteria.state) &&
             labels.every((label) => ticket.labels.includes(label)),
         )
-        .map(cloneTicket),
+        .map((ticket) => cloneTicket(ticket, this.doneState)),
       diagnostics: [],
     }
   }
 
   async get(id: string): Promise<Ticket | null> {
     const ticket = this.tickets.get(id)
-    return ticket ? cloneTicket(ticket) : null
+    return ticket ? cloneTicket(ticket, this.doneState) : null
   }
 
   /** Claim-before-launch: true once per nonterminal lifecycle stay. A later
@@ -128,7 +129,7 @@ export class FakeTicketSource implements TicketSource {
   async create(draft: TicketDraft, opts: TicketCreateOptions = {}): Promise<Ticket> {
     if (opts.idempotencyKey !== undefined) {
       const adopted = this.idempotency.get(opts.idempotencyKey)
-      if (adopted !== undefined) return cloneTicket(this.require(adopted, 'create'))
+      if (adopted !== undefined) return cloneTicket(this.require(adopted, 'create'), this.doneState)
     }
     const id = `fake-${this.nextId++}`
     const ticket: Ticket = {
@@ -137,6 +138,7 @@ export class FakeTicketSource implements TicketSource {
       title: draft.title,
       body: draft.body,
       state: opts.state ?? this.createState,
+      resolved: (opts.state ?? this.createState) === this.doneState,
       labels: [...(draft.labels ?? [])],
       // Recorded verbatim, never discarded — the same contract the real
       // adapters owe (§13).
@@ -148,7 +150,7 @@ export class FakeTicketSource implements TicketSource {
     if (opts.idempotencyKey !== undefined) {
       this.idempotency.set(opts.idempotencyKey, id)
     }
-    return cloneTicket(ticket)
+    return cloneTicket(ticket, this.doneState)
   }
 
   async update(id: string, patch: TicketUpdate): Promise<void> {

package/packages/core/src/ports/tickets/file.ts

@@ -663,6 +663,7 @@ export class FileTicketSource implements TicketSource {
       title: front.title,
       body,
       state,
+      resolved: state === this.doneState,
       labels: [...front.labels],
       ...(front.blockedBy !== undefined && front.blockedBy.length > 0
         ? { blockedBy: [...front.blockedBy] }