@defrex/autobuild 0.8.0 → 0.9.0

package/packages/core/src/cli/watch.ts

@@ -38,20 +38,23 @@
  * Output carries no ANSI, ever, in either form (§16).
  */
 import type { AbEvent } from '../events/catalog'
-import { EVENT_TYPES, type EventType } from '../events/payloads'
-import {
-  REPOSITORY_EVENT_TYPES,
-  type RepositoryEvent,
-  type RepositoryEventType,
-} from '../events/repository'
+import type { EventType } from '../events/payloads'
+import type { RepositoryEvent, RepositoryEventType } from '../events/repository'
+import { REPOSITORY_ATTENTION_EVENTS } from '../events/repository'
 import type { BuildState, PrLifecycle } from '../kernel/reducer'
 import { reduceBuild } from '../kernel/reducer'
 import type { BuildOutcome, BuildStatus, Phase } from '../ontology'
 import type { Exec } from '../ports/workspace/git-worktree'
 import { PhaseSessionError } from '../store/phase-session'
-import { REMOTE_EVENT_WAIT_SECONDS } from '../store/remote/client'
 import type { BuildRecord } from '../store/types'
 import { resolveAmbientReadSession } from './env'
+import {
+  createRemotePollRunner,
+  defaultDelay,
+  makeFailureStreak,
+  type RemotePollReadOpts,
+  type RemotePollRunner,
+} from './remote-poll'
 import { buildInRepository, isRemoteStoreRef, normalizeGitRemoteUrl } from './repo-state'
 import { withAmbientReadStore, type StoreOpener } from './store-opening'
 
@@ -93,15 +96,6 @@ export const BUILD_ATTENTION_EVENTS = [
   'build.aborted',
 ] as const satisfies readonly EventType[]
 
-/** The repository-journal attention set, followed only under `--repository`. */
-export const REPOSITORY_ATTENTION_EVENTS = [
-  'harvest.escalated',
-  'harvest.failed',
-  'dispatcher.tick-failed',
-  'dispatcher.config-rejected',
-  'dispatcher.harvest-runner-failed',
-] as const satisfies readonly RepositoryEventType[]
-
 // ── Glob compilation and matching ────────────────────────────────────────────
 
 /**
@@ -111,36 +105,12 @@ export const REPOSITORY_ATTENTION_EVENTS = [
  * the build catalog — or, when `--repository` is given, in the repository
  * catalog — otherwise a usage error naming the glob is thrown before any
  * store read. Supplying any glob replaces the attention set entirely.
+ *
+ * The compiler itself lives in `events/globs.ts`, shared with the
+ * `[orchestrator].wake` configuration validation (AUT-342).
  */
-export function compileEventGlobs(
-  globs: readonly string[],
-  opts: { repository: boolean; usage: string },
-): RegExp[] {
-  return globs.map((glob) => {
-    const source =
-      '^' +
-      [...glob]
-        .map((char) => {
-          if (char === '*') return '.*'
-          if (char === '?') return '.'
-          return char.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-        })
-        .join('') +
-      '$'
-    const regex = new RegExp(source)
-    const inBuildCatalog = EVENT_TYPES.some((type) => regex.test(type))
-    const inRepositoryCatalog =
-      opts.repository && REPOSITORY_EVENT_TYPES.some((type) => regex.test(type))
-    if (!inBuildCatalog && !inRepositoryCatalog) {
-      throw new Error(
-        `--event "${glob}" matches no known event type${
-          opts.repository ? ' in the build or repository catalogs' : ' in the build event catalog'
-        } — ${opts.usage}`,
-      )
-    }
-    return regex
-  })
-}
+import { compileEventGlobs } from '../events/globs'
+export { compileEventGlobs } from '../events/globs'
 
 function matchesBuildFilter(type: EventType, filters: readonly RegExp[]): boolean {
   return filters.length > 0
@@ -470,23 +440,6 @@ interface RepositoryStream {
 
 type Stream = BuildStream | RepositoryStream
 
-function defaultDelay(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve) => {
-    if (signal?.aborted === true) {
-      resolve()
-      return
-    }
-    const finish = (): void => {
-      clearTimeout(timer)
-      signal?.removeEventListener('abort', onAbort)
-      resolve()
-    }
-    const timer = setTimeout(finish, ms)
-    const onAbort = (): void => finish()
-    signal?.addEventListener('abort', onAbort, { once: true })
-  })
-}
-
 /**
  * `ab watch` — stream matching build and repository events until a timeout, a
  * record count, or (only when slugs were named) terminal status ends the
@@ -531,6 +484,14 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
       const sinceStreams =
         opts.since !== undefined ? decodeCursor(opts.since, { store: storeRef, repo }).streams : {}
 
+      // Verified (AUT-574): this is the full normalized-identity rule of
+      // AUT-567 — the same `mine` predicate as status.ts and wait.ts, with
+      // buildInRepository's semantics. `identity` is resolveRepoState's
+      // `origin ?? resolved checkout`, already normalized (re-normalizing is
+      // a no-op); the first arm is the whole test for new records, whose
+      // `record.repo` IS the normalized origin, and the second arm forgives
+      // legacy path-keyed records via their normalized `repoOrigin`. A
+      // foreign origin, or an origin-less legacy record, is excluded.
       const identity = normalizeGitRemoteUrl(repo)
       const mine = (record: BuildRecord): boolean =>
         record.repo === identity ||
@@ -543,17 +504,13 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
       let emitted = 0
       let countCursor: string | undefined
       let stop = false
-      // Held reads in flight right now, each with its own controller. When
-      // the watch stops for any reason, every in-flight read is cancelled —
-      // otherwise a stop during a quiet window would wait out a full wait
-      // window (up to the remote hold) before the watch could exit.
-      const inFlightReads = new Set<AbortController>()
-      // Wakes stop-aware gap sleeps the moment the watch stops.
-      const stopController = new AbortController()
+      // On the remote path this is the shared long-poll runner (the held
+      // reads, their cancellation, and the gap sleeps it owns); on the local
+      // path it stays undefined and a stop trips the `stop` flag alone.
+      let runner: RemotePollRunner | undefined
       const requestStop = (): void => {
         stop = true
-        stopController.abort()
-        for (const controller of inFlightReads) controller.abort()
+        runner?.requestStop()
       }
 
       const encodeCurrent = (): string =>
@@ -607,6 +564,12 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         if (streams.has(slug)) return true
         const record = await store.getBuild(slug)
         if (record === null) return false
+        // AUT-545: this full-log read is deliberate, accepted growth — the
+        // retained prefix is consumed at full replay depth by every later
+        // reduction (approvals, findings, answered escalations, PR facts,
+        // observations), so bounding it would need reducer-partition store
+        // machinery out of AUT-545's scope. Required for `--since` replay and
+        // the baselined stream prefix. Mirrors cli/wait.ts trackBuild.
         const events = await store.getEvents(slug)
         const stream: BuildStream = {
           kind: 'build',
@@ -646,8 +609,24 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
        * the throw stay tracked, so the retry neither duplicates nor skips.
        */
       const discoverBuilds = async (): Promise<void> => {
+        // AUT-545: the terminal filter is the AUT-487 digest, not a full-log read —
+        // one flat batch read replaces a full getEvents per candidate build, per
+        // discovery pass; `terminal` is reduceBuild's exact terminal rule
+        // (store/digest's reduceBuildDigest, pinned by contract). The per-build
+        // full read below remains deliberate for builds the digest cannot retire:
+        // its retained prefix is consumed at full replay depth by every later
+        // reduction (approvals, findings, answered escalations, PR facts,
+        // observations), so bounding it would need reducer-partition store
+        // machinery out of AUT-545's scope. The reduceBuild re-check stays: it is
+        // the legacy-record fallback (a record whose `repo` predates origin
+        // normalization is in `mine` via `repoOrigin` but absent from the digest
+        // map, which keys on `record.repo`) and it keeps this filter unable to
+        // diverge from reduceBuild. Mirrors cli/wait.ts discoverBuilds.
+        const digests = await store.getRepoBuildDigests(repo)
         for (const record of (await store.listBuilds()).filter(mine)) {
           if (streams.has(record.slug)) continue
+          const digest = digests.get(record.slug)
+          if (digest !== undefined && digest.terminal !== undefined) continue
           const events = await store.getEvents(record.slug)
           const status = reduceBuild(events).status
           if (!NONTERMINAL_STATUSES.includes(status)) continue
@@ -672,9 +651,27 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         try {
           // A fresh store has no repository row; do not create one.
           if (resumeSeq === undefined && (await store.getRepo(repo)) !== null) {
-            const events = await store.getRepoEvents(repo)
-            stream.lastSeq = events.at(-1)?.seq ?? 0
-            positions[REPO_STREAM_KEY] = stream.lastSeq
+            // Bounded baseline (AUT-534): the baseline needs only the
+            // journal's end position, and AUT-489's bounded read answers that
+            // whenever the journal contains a `dispatcher.run-started` — the
+            // tail from the latest anchor runs to the journal end, so the
+            // subset's max seq equals the journal's max seq.
+            const subset = await store.getRepoStateEvents(repo)
+            let last = subset.at(-1)?.seq ?? 0
+            if (!subset.some((event) => event.type === 'dispatcher.run-started')) {
+              // Anchor-less journal: the subset may have dropped run-scoped
+              // facts appended before any anchor, so one bounded delta read
+              // recovers the true end; its events are baselined silently,
+              // exactly as the full read baselines them. The skip condition
+              // is exact: a run-started is its own anchor or lies in a later
+              // anchor's tail, so "no run-started in the subset" means "no
+              // run-started in the journal" — the only case where the subset
+              // can trail.
+              const tail = await store.getRepoEvents(repo, last)
+              last = tail.at(-1)?.seq ?? last
+            }
+            stream.lastSeq = last
+            positions[REPO_STREAM_KEY] = last
           }
           return true
         } catch {
@@ -684,7 +681,7 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
 
       const pollBuild = async (
         stream: BuildStream,
-        readOpts?: { waitSeconds?: number; signal?: AbortSignal },
+        readOpts?: RemotePollReadOpts,
       ): Promise<boolean> => {
         const fresh = await store.getEvents(stream.slug, stream.lastSeq, readOpts)
         for (const event of fresh) {
@@ -700,7 +697,7 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
 
       const pollRepository = async (
         stream: RepositoryStream,
-        readOpts?: { waitSeconds?: number; signal?: AbortSignal },
+        readOpts?: RemotePollReadOpts,
       ): Promise<boolean> => {
         // A repository row may be created mid-watch by the first dispatch.
         if ((await store.getRepo(repo)) === null) return true
@@ -722,34 +719,10 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         return true
       }
 
-      /** A failed read is reported once per failure streak, advances nothing,
-       * and is retried at the next interval (local) or next request (remote);
-       * a success on the same source re-arms the report. Each read source —
-       * per stream task, plus discovery — carries its own streak, so a
-       * persistent failure on one stream interleaved with successes elsewhere
-       * is still reported only once. */
-      const makeFailureStreak = (): {
-        onFailure: (error: unknown) => void
-        onSuccess: () => void
-      } => {
-        let reported = false
-        return {
-          onFailure: (error: unknown): void => {
-            if (reported) return
-            reported = true
-            const message = error instanceof Error ? error.message : String(error)
-            opts.stderr(`ab watch: a store read failed (${message}); retrying at the next interval`)
-          },
-          onSuccess: (): void => {
-            reported = false
-          },
-        }
-      }
-
       // One streak for the whole local loop — the same lifetime the shared
       // reported flag had before per-source streaks: a persistent read
       // failure is reported once, and a fully-successful cycle re-arms it.
-      const tickStreak = makeFailureStreak()
+      const tickStreak = makeFailureStreak('watch', opts.stderr)
 
       const tick = async (): Promise<void> => {
         let allReadsOk = true
@@ -799,7 +772,7 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
       }
       if (repository) {
         if (!(await trackRepository())) {
-          makeFailureStreak().onFailure(
+          makeFailureStreak('watch', opts.stderr).onFailure(
             new Error(`could not read the repository journal for "${repo}"`),
           )
         }
@@ -840,57 +813,51 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         // Every stop is prompt: an external abort, a tripped --count, an
         // all-terminal named set, or an elapsed --timeout cancels the
         // in-flight held reads (via `requestStop`) and wakes the gap sleeps
-        // (via `stopController`) instead of waiting out a full hold. The
-        // held read's own bound is additionally capped at the watch's
-        // remaining time budget, so a hold can never outlive the deadline.
+        // (via the runner's stop controller) instead of waiting out a full
+        // hold. The held read's own bound is additionally capped at the
+        // watch's remaining time budget, so a hold can never outlive the
+        // deadline.
         const shouldStop = stop || aborted() || now().getTime() >= deadline || namedAllTerminal()
-        const tasks: Promise<void>[] = []
-        const launched = new Set<string>()
-
-        /** The wait bound for one held read: the remote default, capped at
-         * the watch's remaining time budget. */
-        const readWaitSeconds = (atMs: number): number => {
-          if (timeoutMs === 0) return REMOTE_EVENT_WAIT_SECONDS
-          const remaining = Math.floor((deadline - atMs) / 1000)
-          return Math.max(0, Math.min(REMOTE_EVENT_WAIT_SECONDS, remaining))
-        }
-
-        const runStreamTask = async (
-          poll: (readOpts: { waitSeconds?: number; signal?: AbortSignal }) => Promise<unknown>,
-        ): Promise<void> => {
-          const streak = makeFailureStreak()
-          while (!stop && !aborted() && now().getTime() < deadline) {
-            const started = now().getTime()
-            const controller = new AbortController()
-            inFlightReads.add(controller)
-            try {
-              await poll({ waitSeconds: readWaitSeconds(started), signal: controller.signal })
-              streak.onSuccess()
-              if (namedAllTerminal()) {
-                requestStop()
-                return
-              }
-            } catch (error) {
-              // A cancelled held read is the watch stopping, not a store
-              // failure — never report it.
-              if (!stop && !aborted() && !controller.signal.aborted) streak.onFailure(error)
-            } finally {
-              inFlightReads.delete(controller)
-            }
-            if (stop || aborted()) return
-            const elapsed = now().getTime() - started
-            if (elapsed < interval) await sleep(interval - elapsed, stopController.signal)
-          }
-        }
+        const remoteRunner = createRemotePollRunner({
+          command: 'watch',
+          stderr: opts.stderr,
+          now,
+          sleep,
+          intervalMs: interval,
+          deadlineMs: deadline,
+          aborted,
+          shouldStop: () => aborted() || now().getTime() >= deadline || namedAllTerminal(),
+          // A task's terminal endCheck stops the runner from the inside; the
+          // command's `stop` flag must trip with it — pollBuild and
+          // pollRepository gate their batch loops on that flag
+          // (`if (stop) break`), so a sibling task whose held read has
+          // already resolved stops delivering its batch instead of draining
+          // it, exactly as the pre-extraction command-scoped `requestStop`
+          // (which set `stop` on every path) made it do (f_42263f38).
+          onStop: (): void => {
+            stop = true
+          },
+          // Quiesce, not the runner's one-shot snapshot: a stream the
+          // discovery task registers while drain is awaiting must have its
+          // first held read awaited before the final cursor is encoded, or a
+          // mid-discovery registration's emission lands after the cursor and
+          // the next run replays it (the gap widened from a scheduling race
+          // to a deterministic miss when discovery's digest read added one
+          // await before the per-build reads — AUT-545). The snapshot
+          // semantics the runner documents remain covered by its own tests.
+          drain: 'quiesce',
+        })
+        runner = remoteRunner
 
         const launch = (stream: Stream): void => {
           const key = stream.kind === 'build' ? stream.slug : REPO_STREAM_KEY
-          if (launched.has(key)) return
-          launched.add(key)
-          tasks.push(
-            stream.kind === 'build'
-              ? runStreamTask((readOpts) => pollBuild(stream, readOpts))
-              : runStreamTask((readOpts) => pollRepository(stream, readOpts)),
+          remoteRunner.launch(
+            key,
+            (readOpts) =>
+              stream.kind === 'build'
+                ? pollBuild(stream, readOpts)
+                : pollRepository(stream, readOpts),
+            () => namedAllTerminal(),
           )
         }
 
@@ -901,25 +868,20 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         for (const stream of streams.values()) if (!shouldStop) launch(stream)
 
         if (slugs.length === 0 && !shouldStop) {
-          tasks.push(
-            (async (): Promise<void> => {
-              const streak = makeFailureStreak()
-              while (!stop && !aborted() && now().getTime() < deadline) {
-                try {
-                  await discoverBuilds()
-                  streak.onSuccess()
-                } catch (error) {
-                  streak.onFailure(error)
-                }
-                for (const stream of streams.values()) launch(stream)
-                if (stop || aborted()) return
-                await sleep(interval, stopController.signal)
-              }
-            })(),
-          )
+          void remoteRunner.runDiscovery({
+            step: async (): Promise<void> => {
+              await discoverBuilds()
+            },
+            // Unconditional, after the catch — exactly where the inline
+            // launch loop ran: streams registered before a mid-discovery
+            // throw still get tasks whose polls then run independently.
+            launchPending: (): void => {
+              for (const stream of streams.values()) launch(stream)
+            },
+          })
         }
 
-        await Promise.all(tasks)
+        await remoteRunner.drain()
         opts.signal?.removeEventListener('abort', requestStop)
       }
 

package/packages/core/src/config/live.ts

@@ -90,6 +90,28 @@ export function restartRequiredChanges(
   return changed
 }
 
+/** Config sections that define the pipeline a build runs under (SPEC §16.1):
+ * the verify universe, finalize steps, deterministic commands, and the
+ * workspace provisioning definition. Build-owned sections are composed from
+ * the build's own branch at a recorded pipeline-source commit and never
+ * replaced by a later base-branch change. */
+export const BUILD_OWNED_CONFIG_PATHS = ['verify', 'finalize', 'commands', 'workspace'] as const
+
+/** Compose one build's effective config: build-owned tables come from the
+ * pipeline source (the build's own branch), everything else from the live
+ * dispatcher snapshot (deployment). Dispatcher-owned sections (baseBranch,
+ * capacity, forge, plugins, pr, tickets, orchestrator) always travel with the
+ * deployment side — the runner never interprets them. */
+export function composeBuildConfig(pipeline: Config, deployment: Config): Config {
+  return {
+    ...deployment,
+    verify: pipeline.verify,
+    finalize: pipeline.finalize,
+    commands: pipeline.commands,
+    workspace: pipeline.workspace,
+  }
+}
+
 /** Overlay all hot fields while retaining every startup-built adapter field. */
 export function composeReloadedConfig(startup: Config, candidate: Config): Config {
   return {