@defrex/autobuild 0.13.0 → 0.14.0

package/packages/core/src/processes/tick-publication.ts

@@ -0,0 +1,110 @@
+import type { RepositoryEvent } from '../events/repository'
+import type { TickReport } from './dispatcher'
+
+/** Every counter and diagnostic is significant, including standing counts.
+ * Queue depth alone may be unchanged and nonzero. */
+export function shouldPublishTick(
+  report: TickReport,
+  events: readonly RepositoryEvent[],
+  run: string,
+  startedAt: string,
+): boolean {
+  if (
+    Object.entries(report).some(
+      ([key, value]) =>
+        key !== 'queued' && (typeof value === 'number' ? value !== 0 : value.length > 0),
+    )
+  )
+    return true
+  // Queue and diagnostic readers reduce per run, so each run must publish
+  // its own baseline before quiet ticks can be suppressed.
+  const previous = events.findLast(
+    (e) => e.type === 'dispatcher.tick-completed' && e.payload.run === run,
+  )
+  if (previous?.type !== 'dispatcher.tick-completed' || previous.payload.queued !== report.queued)
+    return true
+  if (
+    [
+      previous.payload.blockedDiagnostics ?? [],
+      previous.payload.janitorDiagnostics,
+      previous.payload.ticketDiagnostics,
+      previous.payload.creationDiagnostics ?? [],
+      previous.payload.dependencyDiagnostics,
+    ].some((list) => list.length > 0)
+  )
+    return true
+  const boundary = events.findLast(
+    (e) =>
+      (e.type === 'dispatcher.tick-completed' || e.type === 'dispatcher.tick-failed') &&
+      e.payload.run === run,
+  )
+  if (boundary?.type === 'dispatcher.tick-failed') return true
+
+  // Preserve the first completed retry after each outstanding source cooldown.
+  const sources = new Map<string, { deadline: number; requiresRetry: boolean; retried: boolean }>()
+  const starts = new Map<string, number>()
+  for (const event of events) {
+    if (event.type === 'dispatcher.ticket-source-degraded') {
+      const existing = sources.get(event.payload.source)
+      const requiresRetry = 'resetAt' in event.payload
+      const deadline =
+        'resetAt' in event.payload
+          ? Date.parse(event.payload.resetAt)
+          : Date.parse(event.ts) + 15 * 60_000
+      if (existing) {
+        existing.deadline = Math.min(existing.deadline, deadline)
+        existing.requiresRetry ||= requiresRetry
+      } else sources.set(event.payload.source, { deadline, requiresRetry, retried: false })
+    } else if (event.type === 'dispatcher.ticket-source-recovered')
+      sources.delete(event.payload.source)
+    else if (event.type === 'dispatcher.run-started') starts.clear()
+    else if (event.type === 'dispatcher.run-stopped') starts.delete(event.payload.run)
+    else if (event.type === 'dispatcher.tick-started')
+      starts.set(event.payload.run, Date.parse(event.payload.startedAt ?? event.ts))
+    else if (
+      event.type === 'dispatcher.tick-completed' ||
+      event.type === 'dispatcher.tick-failed'
+    ) {
+      const start = starts.get(event.payload.run)
+      starts.delete(event.payload.run)
+      for (const source of sources.values())
+        if (start !== undefined && start >= source.deadline) source.retried = true
+    }
+  }
+  return [...sources.values()].some(
+    (source) => source.requiresRetry && !source.retried && Date.parse(startedAt) >= source.deadline,
+  )
+}
+
+export function shouldPublishTickFromFacts(
+  report: TickReport,
+  facts: import('../store/reduced-reads').RepositoryReadFacts,
+  run: import('../kernel/read-facts').DispatcherRunFacts,
+  startedAt: string,
+): boolean {
+  if (
+    Object.entries(report).some(
+      ([key, value]) =>
+        key !== 'queued' && (typeof value === 'number' ? value !== 0 : value.length > 0),
+    )
+  )
+    return true
+  const previous = run.completed
+  if (previous?.type !== 'dispatcher.tick-completed' || previous.payload.queued !== report.queued)
+    return true
+  if (
+    [
+      previous.payload.blockedDiagnostics ?? [],
+      previous.payload.janitorDiagnostics,
+      previous.payload.ticketDiagnostics,
+      previous.payload.creationDiagnostics ?? [],
+      previous.payload.dependencyDiagnostics,
+    ].some((list) => list.length > 0)
+  )
+    return true
+  if (run.tick?.type === 'dispatcher.tick-failed') return true
+  return facts.attention.sources.some(
+    ([, source]) =>
+      source.requiresRetry && !source.retryObserved && Date.parse(startedAt) >= source.deadline,
+  )
+}

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

@@ -1,3 +1,9 @@
+export {
+  validateTickFinish,
+  repoTickCompletionSchema,
+  repoTickObservationSchema,
+} from './repo-tick'
+export type { RepoTickCompletion, RepoTickObservation, RepoTickFinish } from './types'
 export { validateEventWrite } from '../events/catalog'
 export { humanActor } from '../events/envelope'
 export type { AbEvent, EventEnvelope, EventWrite } from '../events/catalog'
@@ -120,3 +126,20 @@ export {
   snapshotSupersedes,
 } from './snapshots'
 export type { ReducerSnapshot, SnapshotScope } from './snapshots'
+
+export {
+  readReducerValue,
+  resolveReducerValue,
+  reducerValueRequestSchema,
+  reducerValueSchema,
+} from './reducer-values'
+export type {
+  ReducerValue,
+  ReducerValueRequest,
+  ReducerValueStorage,
+  ValueCacheRow,
+} from './reducer-values'
+
+export { assertPublicSnapshotReducer } from './snapshots'
+
+export { readPersistedBuildDigests } from './reduced-reads'

package/packages/core/src/store/build-scope.ts

@@ -1,3 +1,4 @@
+import type { ReducerValueRequest, ReducerValue } from './reducer-values'
 import type { ReducerSnapshot, SnapshotScope } from './snapshots'
 import type { EventType } from '../events/payloads'
 import type { EventWrite } from '../events/catalog'
@@ -194,6 +195,16 @@ export function createBuildScopedStore(store: BuildStore, scope: string): BuildS
     getRepoHighWater(repo: string): Promise<number> {
       return Promise.reject(new BuildScopeError(scope, 'getRepoHighWater', repo))
     },
+    async getReducerValue(
+      target: SnapshotScope,
+      request: ReducerValueRequest,
+    ): Promise<ReducerValue> {
+      if (target.kind !== 'build') {
+        throw new BuildScopeError(scope, 'getReducerValue', target.repo)
+      }
+      own('getReducerValue', target.slug)
+      return store.getReducerValue(target, request)
+    },
     async getReducerSnapshot(
       target: SnapshotScope,
       reducer: string,
@@ -278,6 +289,12 @@ export function createBuildScopedStore(store: BuildStore, scope: string): BuildS
     claimRepoLease(repo: string, _holder: string, _ttlMs: number): Promise<boolean> {
       return Promise.reject(new BuildScopeError(scope, 'claimRepoLease', repo))
     },
+    beginRepoTick(repo: string) {
+      return Promise.reject(new BuildScopeError(scope, 'beginRepoTick', repo))
+    },
+    finishRepoTick(repo: string) {
+      return Promise.reject(new BuildScopeError(scope, 'finishRepoTick', repo))
+    },
     heartbeatRepo(repo: string, _holder: string): Promise<boolean> {
       return Promise.reject(new BuildScopeError(scope, 'heartbeatRepo', repo))
     },

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

@@ -1,3 +1,5 @@
+import { REDUCERS } from '../kernel/reducer-registry'
+import { resolveReducerValue } from './reducer-values'
 import { prepareAssetSnapshots } from './ticket-asset-snapshots'
 import { MemoryBuildStore } from './memory'
 /**
@@ -704,6 +706,135 @@ export function describeBuildStoreContract(name: string, factory: BuildStoreFact
     })
 
     describe('repository journal (workflow and control paper trail)', () => {
+      test('tick observations are fenced, bounded, atomic and detached snapshots', async () => {
+        const clock = manualClock(CONTRACT_T0)
+        await withStore(factory, { clock }, async (store) => {
+          const repo = 'tick-contract'
+          await store.ensureRepo(repo)
+          expect(await store.beginRepoTick(repo, 'owner')).toBeNull()
+          await store.claimRepoLease(repo, 'owner', 60_000)
+          const startedAt = await store.beginRepoTick(repo, 'owner')
+          expect(startedAt).toBe(CONTRACT_T0)
+          const failure = { outcome: 'failed' as const, error: 'failure' }
+          const events: RepositoryEventWrite[] = [
+            {
+              actor: DISPATCHER,
+              type: 'dispatcher.tick-started',
+              payload: { run: 'owner', startedAt: startedAt! },
+            },
+            {
+              actor: DISPATCHER,
+              type: 'dispatcher.tick-failed',
+              payload: { run: 'owner', error: 'failure' },
+            },
+          ]
+          const before = await store.getRepo(repo)
+          expect(
+            await store.finishRepoTick(repo, 'foreign', failure, [
+              { ...events[0]!, payload: { run: 'foreign' } },
+              { ...events[1]!, payload: { run: 'foreign', error: 'failure' } },
+            ]),
+          ).toBeNull()
+          expect(await store.getRepo(repo)).toEqual(before)
+          await expect(
+            store.finishRepoTick(repo, 'owner', failure, [
+              events[0]!,
+              { ...events[1]!, payload: {} },
+            ]),
+          ).rejects.toThrow()
+          expect(await store.getRepoEvents(repo)).toEqual([])
+          expect(await store.getRepo(repo)).toEqual(before)
+          clock.advance(1000)
+          const finished = await store.finishRepoTick(repo, 'owner', failure, events)
+          expect(finished!.events.map((e) => e.seq)).toEqual([1, 2])
+          expect(finished!.observation.finished).toMatchObject({
+            startedAt,
+            completedAt: clock().toISOString(),
+            ...failure,
+          })
+          finished!.observation.finished!.startedAt = 'mutated'
+          expect((await store.getRepo(repo))!.tick!.finished!.startedAt).toBe(startedAt!)
+          await store.beginRepoTick(repo, 'owner')
+          expect((await store.getRepo(repo))!.tick!.finished!.outcome).toBe('failed')
+          clock.advance(60_000)
+          const expired = await store.getRepo(repo)
+          expect(await store.beginRepoTick(repo, 'owner')).toBeNull()
+          expect(await store.finishRepoTick(repo, 'owner', failure, events)).toBeNull()
+          expect(await store.getRepo(repo)).toEqual(expired)
+          await store.releaseRepoLease(repo, 'owner')
+          expect((await store.getRepo(repo))!.tick!.finished!.startedAt).toBe(startedAt!)
+        })
+      })
+
+      test('restricted handles deny tick mutations and arbitrary finish batches append nothing', async () => {
+        await withStore(factory, undefined, async (store) => {
+          const repo = 'tick-authority'
+          await store.ensureRepo(repo)
+          await store.createBuild(sampleBuildInput('tick-scope', { repo }))
+          const scoped = store.scopeBuild('tick-scope')
+          await expect(scoped.beginRepoTick(repo, 'owner')).rejects.toThrow()
+          const failure = { outcome: 'failed' as const, error: 'failed' }
+          await expect(scoped.finishRepoTick(repo, 'owner', failure, [])).rejects.toThrow()
+          const session = await store.createSession({ repo, operator: 'operator' })
+          await expect(
+            store.scopeSession(session.id).beginRepoTick(repo, 'owner'),
+          ).rejects.toThrow()
+          await expect(
+            store.scopeSession(session.id).finishRepoTick(repo, 'owner', failure, []),
+          ).rejects.toThrow()
+          await store.claimRepoLease(repo, 'owner', 60_000)
+          await store.beginRepoTick(repo, 'owner')
+          const before = await store.getRepo(repo)
+          await expect(
+            store.finishRepoTick(repo, 'owner', failure, [
+              { actor: DISPATCHER, type: 'dispatcher.tick-started', payload: { run: 'owner' } },
+              {
+                actor: humanActor('operator'),
+                type: 'dispatcher.intake-set',
+                payload: { enabled: false },
+              },
+            ]),
+          ).rejects.toThrow()
+          expect(await store.getRepoEvents(repo)).toEqual([])
+          expect(await store.getRepo(repo)).toEqual(before)
+        })
+      })
+
+      test('quiet finishes update completion without advancing the journal or heartbeat', async () => {
+        const clock = manualClock(CONTRACT_T0)
+        await withStore(factory, { clock }, async (store) => {
+          const repo = 'quiet-tick-contract'
+          await store.ensureRepo(repo)
+          await store.claimRepoLease(repo, 'owner', 60_000)
+          const { emptyTickReport } = await import('../processes/dispatcher')
+          const {
+            queued,
+            janitorDiagnostics,
+            blockedDiagnostics,
+            ticketDiagnostics,
+            creationDiagnostics,
+            dependencyDiagnostics,
+            ...counters
+          } = emptyTickReport()
+          for (let i = 0; i < 20; i++) {
+            await store.beginRepoTick(repo, 'owner')
+            clock.advance(1000)
+            const result = await store.finishRepoTick(
+              repo,
+              'owner',
+              { outcome: 'completed', counters },
+              [],
+            )
+            expect(result!.events).toEqual([])
+            expect((await store.getRepo(repo))!.tick!.finished!.completedAt).toBe(
+              clock().toISOString(),
+            )
+          }
+          expect(await store.getRepoHighWater(repo)).toBe(0)
+          expect(await store.getRepoEvents(repo)).toEqual([])
+          expect((await store.getRepo(repo))!.heartbeatAt).toBeUndefined()
+        })
+      })
       test('ensureRepo is idempotent and repo event seq is independent', async () => {
         const clock = manualClock(CONTRACT_T0)
         await withStore(factory, { clock }, async (store) => {
@@ -922,6 +1053,126 @@ export function describeBuildStoreContract(name: string, factory: BuildStoreFact
       })
     })
 
+    describe('named reducer value reads', () => {
+      test('all admitted reducers match replay on both scopes and isolate parameter variants', async () => {
+        await withStore(factory, undefined, async (store) => {
+          const slug = 'values'
+          const repo = 'acme/values'
+          await store.createBuild(sampleBuildInput(slug))
+          await store.ensureRepo(repo)
+          await store.append(slug, sampleEventWrite('hello'))
+          await store.appendRepo(repo, {
+            actor: humanActor('op'),
+            type: 'dispatcher.intake-set',
+            payload: { enabled: false },
+          })
+          const buildEvents = await store.getEvents(slug)
+          const repoEvents = await store.getRepoEvents(repo)
+          for (const [name, entry] of Object.entries(REDUCERS)) {
+            const read = entry.valueRead
+            const scope =
+              read && !('excluded' in read) && read.scope === 'repo'
+                ? { kind: 'repo' as const, repo }
+                : { kind: 'build' as const, slug }
+            if ('excluded' in read) {
+              await expect(store.getReducerValue(scope, { reducer: name })).rejects.toThrow(
+                'excluded',
+              )
+              continue
+            }
+            const variants =
+              name === 'terminalGuard'
+                ? [
+                    { phase: 'plan', round: 1, session: 'session-a' },
+                    { phase: 'implement', round: 2, session: 'session-b' },
+                  ]
+                : name === 'openTick' || name === 'dispatchStatus' || name === 'dispatcherRunFacts'
+                  ? [{ run: 'run-a' }, { run: 'run-b' }]
+                  : name === 'phaseFailures'
+                    ? [
+                        { phase: 'plan', round: 1 },
+                        { phase: 'implement', round: 2 },
+                      ]
+                    : name === 'dispatchFailureBudget'
+                      ? [
+                          { infrastructureOwnsWorkspace: false },
+                          { infrastructureOwnsWorkspace: true },
+                        ]
+                      : [{}]
+            for (const args of variants) {
+              const request = { reducer: name, args }
+              const resolved = resolveReducerValue(scope, request)
+              const events = scope.kind === 'repo' ? repoEvents : buildEvents
+              const expected = JSON.parse(JSON.stringify(resolved.reducer.reduce(events)))
+              const answer = await store.getReducerValue(scope, request)
+              expect(answer).toEqual({
+                version: resolved.reducer.version,
+                cursor: events.at(-1)?.seq ?? 0,
+                value: expected,
+              })
+              if (answer.value && typeof answer.value === 'object')
+                Object.assign(answer.value, { poison: true })
+              expect((await store.getReducerValue(scope, request)).value).toEqual(expected)
+            }
+          }
+        })
+      })
+      test('public snapshots cannot supply value checkpoints and unknown scopes create nothing', async () => {
+        await withStore(factory, undefined, async (store) => {
+          const scope = { kind: 'build' as const, slug: 'value-repair' }
+          await store.createBuild(sampleBuildInput(scope.slug))
+          await store.append(scope.slug, sampleEventWrite('first'))
+          const request = { reducer: 'build' }
+          const resolved = resolveReducerValue(scope, request)
+          await expect(
+            store.putReducerSnapshot(scope, resolved.key, {
+              version: resolved.reducer.version,
+              cursor: 1,
+              state: { identity: resolved.identity, acc: resolved.reducer.initial() },
+            }),
+          ).rejects.toThrow('reserved')
+          await expect(
+            store.getReducerSnapshot(scope, resolved.key, resolved.reducer.version),
+          ).rejects.toThrow('reserved')
+          // Block the whole namespace, including the former writable format.
+          for (const target of [scope, { kind: 'repo' as const, repo: 'value-repair' }]) {
+            await store.ensureRepo('value-repair')
+            await expect(
+              store.putReducerSnapshot(target, 'value.legacy', {
+                version: 1,
+                cursor: 0,
+                state: {},
+              }),
+            ).rejects.toThrow('reserved')
+          }
+          const answer = await store.getReducerValue(scope, request)
+          expect(answer.value).toEqual(
+            JSON.parse(JSON.stringify(reduceBuild(await store.getEvents(scope.slug)))),
+          )
+          await expect(
+            store.getReducerValue({ kind: 'build', slug: 'unknown' }, request),
+          ).rejects.toThrow()
+          await expect(
+            store.getReducerValue(
+              { kind: 'repo', repo: 'unknown' },
+              { reducer: 'dispatchSettings' },
+            ),
+          ).rejects.toThrow()
+          expect(await store.getRepo('unknown')).toBeNull()
+          await expect(
+            store
+              .scopeBuild(scope.slug)
+              .getReducerValue({ kind: 'repo', repo: 'unknown' }, { reducer: 'dispatchSettings' }),
+          ).rejects.toThrow()
+          await expect(
+            store
+              .scopeBuild(scope.slug)
+              .getReducerValue({ kind: 'build', slug: 'unknown' }, request),
+          ).rejects.toThrow()
+        })
+      })
+    })
+
     describe('reducer snapshots (a cache beside the log, never an authority)', () => {
       const buildScope = (slug: string) => ({ kind: 'build' as const, slug })
       const repoScope = (repo: string) => ({ kind: 'repo' as const, repo })

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

@@ -56,6 +56,7 @@ export const repoStreams = sqliteTable('repo_streams', {
   leaseExpiresAt: text('lease_expires_at'),
   leaseTtlMs: integer('lease_ttl_ms'),
   heartbeatAt: text('heartbeat_at'),
+  tick: text('tick', { mode: 'json' }).$type<import('../types').RepoTickObservation>(),
 })
 
 export const repoEvents = sqliteTable(