@defrex/autobuild 0.11.0 → 0.13.0

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

@@ -31,6 +31,7 @@
  * Read-only: it appends no event, claims or renews no lease, and creates no
  * build or repository record. Output carries no ANSI, ever, in either form.
  */
+import { buildNeedsAttention, mergeDecision, mergeIdentity } from './attention'
 import type { AbEvent } from '../events/catalog'
 import type { EventType } from '../events/payloads'
 import type { BuildState, PrLifecycle } from '../kernel/reducer'
@@ -54,6 +55,8 @@ import {
   encodeCursor,
   parseDurationMs,
   projectRecord,
+  projectAttentionRecord,
+  renderAttentionLine,
   renderWatchLine,
   watchSelection,
 } from './watch'
@@ -153,8 +156,8 @@ export function parseConditions(
   return { conditions, globs }
 }
 
-/** Does one condition body hold over a reduction? Attention is event-only. */
-function stateSatisfies(cond: ConditionBody, state: BuildState): boolean {
+/** Does one condition body hold over a reduction? Attention includes current escalation and merge state. */
+function stateSatisfies(cond: ConditionBody, state: BuildState, events: AbEvent[] = []): boolean {
   switch (cond.kind) {
     case 'status':
       return state.status === cond.status
@@ -165,7 +168,7 @@ function stateSatisfies(cond: ConditionBody, state: BuildState): boolean {
     case 'phase':
       return (state.phase ?? null) === cond.phase
     case 'attention':
-      return false
+      return buildNeedsAttention(events, state)
   }
 }
 
@@ -174,9 +177,13 @@ function stateSatisfies(cond: ConditionBody, state: BuildState): boolean {
  * the start-of-command and start-of-registration checks — never during a
  * backlog replay, where only event conditions may fire.
  */
-export function matchState(conditions: readonly WaitCondition[], state: BuildState): string | null {
+export function matchState(
+  conditions: readonly WaitCondition[],
+  state: BuildState,
+  events: AbEvent[] = [],
+): string | null {
   for (const { text, cond } of conditions) {
-    if (stateSatisfies(cond, state)) return text
+    if (stateSatisfies(cond, state, events)) return text
   }
   return null
 }
@@ -188,9 +195,15 @@ export function matchEvent(
   event: Pick<AbEvent, 'type'>,
   conditions: readonly WaitCondition[],
   globs: readonly EventGlob[],
+  events: AbEvent[] = [],
 ): string | null {
   for (const { text, cond } of conditions) {
-    if (cond.kind === 'attention' && isAttentionEvent(event.type)) return text
+    if (
+      cond.kind === 'attention' &&
+      (isAttentionEvent(event.type) ||
+        (events.length > 0 && mergeDecision(events, new Date(0)) !== null))
+    )
+      return text
   }
   for (const { regex, text } of globs) {
     if (regex.test(event.type)) return text
@@ -209,10 +222,16 @@ function matchFirst(
   state: BuildState,
   conditions: readonly WaitCondition[],
   globs: readonly EventGlob[],
+  events: AbEvent[] = [],
 ): string | null {
   for (const { text, cond } of conditions) {
-    if (stateSatisfies(cond, state)) return text
-    if (cond.kind === 'attention' && isAttentionEvent(event.type)) return text
+    if (stateSatisfies(cond, state, events)) return text
+    if (
+      cond.kind === 'attention' &&
+      (isAttentionEvent(event.type) ||
+        (events.length > 0 && mergeDecision(events, new Date(0)) !== null))
+    )
+      return text
   }
   for (const { regex, text } of globs) {
     if (regex.test(event.type)) return text
@@ -305,11 +324,12 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
       const interval = intervalMs ?? watchSelection(storeRef).intervalMs
 
       // Decode --since before any read: a foreign cursor is rejected outright.
-      const sinceStreams =
+      const resumedCursor =
         opts.since !== undefined
           ? decodeCursor(opts.since, { store: storeRef, repo }, { verb: 'wait', usage: WAIT_USAGE })
-              .streams
-          : {}
+          : undefined
+      const sinceStreams = resumedCursor?.streams ?? {}
+      const deliveredAttention = new Set(resumedCursor?.deliveredAttention ?? [])
 
       const identity = normalizeGitRemoteUrl(repo)
       const mine = (record: BuildRecord): boolean =>
@@ -322,17 +342,40 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
       const positions: Record<string, number> = { ...sinceStreams }
 
       const encodeCurrent = (): string =>
-        encodeCursor({ v: 1, store: storeRef, repo, streams: { ...positions } })
+        encodeCursor({
+          v: 1,
+          store: storeRef,
+          repo,
+          streams: { ...positions },
+          ...(resumedCursor?.lostRuns ? { lostRuns: resumedCursor.lostRuns } : {}),
+          deliveredAttention: [...deliveredAttention],
+        })
 
       /** The one success/terminal record. Exit 0 is contractually tied to
        * exactly one condition-satisfying record; the exit-2 record carries
        * `condition` null so the caller can see how the build ended. */
       const finish = (condition: string | null, event: AbEvent, state: BuildState): number => {
-        const record = { ...projectRecord(event, state, encodeCurrent()), condition }
+        const observation =
+          condition === 'attention' && event.type !== 'escalation.raised'
+            ? mergeDecision(
+                streams.get(event.build)?.events.filter((e) => e.seq <= event.seq) ?? [],
+                now(),
+                state,
+              )
+            : null
+        if (observation) deliveredAttention.add(mergeIdentity(event.build, observation.pr.number))
+        const record = {
+          ...(observation
+            ? projectAttentionRecord(observation, state, encodeCurrent(), { build: event.build })
+            : projectRecord(event, state, encodeCurrent())),
+          condition,
+        }
         if (json) {
           opts.stdout(JSON.stringify(record))
         } else {
-          const line = renderWatchLine(event, state)
+          const line = observation
+            ? renderAttentionLine(observation, event.build)
+            : renderWatchLine(event, state)
           opts.stdout(condition === null ? line : `${line} (${condition})`)
         }
         return condition === null ? 2 : 0
@@ -351,6 +394,15 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
         if (satisfied === null) satisfied = { event, state, condition }
       }
 
+      const eventConditions = (event: AbEvent, prefix: AbEvent[]): readonly WaitCondition[] => {
+        if (event.type === 'escalation.raised') return conditions
+        const observation = mergeDecision(prefix, now())
+        return observation &&
+          !deliveredAttention.has(mergeIdentity(event.build, observation.pr.number))
+          ? conditions
+          : conditions.filter(({ cond }) => cond.kind !== 'attention')
+      }
+
       const registerStream = (slug: string, events: AbEvent[], named: boolean): WaitStream => {
         const state = reduceBuild(events)
         const stream: WaitStream = {
@@ -370,7 +422,7 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
        * latest event. Not cursor-relative — `--since` does not suppress it. */
       const checkRegistrationState = (stream: WaitStream): void => {
         const state = reduceBuild(stream.events)
-        const condition = matchState(conditions, state)
+        const condition = matchState(conditions, state, stream.events)
         if (condition !== null && stream.events.length > 0) {
           match(stream.events.at(-1)!, state, condition)
         }
@@ -401,12 +453,20 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
           // the reduction of the prefix ENDING at that event, never the
           // reduction of the full loaded prefix.
           const replay: AbEvent[] = events.filter((event) => event.seq <= resumeSeq)
+          if (resumedCursor?.deliveredAttention === undefined) {
+            const historical: AbEvent[] = []
+            for (const event of replay) {
+              historical.push(event)
+              const observation = mergeDecision(historical, now())
+              if (observation) deliveredAttention.add(mergeIdentity(slug, observation.pr.number))
+            }
+          }
           for (const event of events) {
             if (event.seq <= resumeSeq) continue
             replay.push(event)
             stream.lastSeq = event.seq
             positions[slug] = event.seq
-            const condition = matchEvent(event, conditions, globs)
+            const condition = matchEvent(event, eventConditions(event, replay), globs, replay)
             if (condition !== null) {
               match(event, reduceBuild(replay), condition)
               break
@@ -470,7 +530,13 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
           positions[stream.slug] = event.seq
           const state = reduceBuild(stream.events)
           stream.status = state.status
-          const condition = matchFirst(event, state, conditions, globs)
+          const condition = matchFirst(
+            event,
+            state,
+            eventConditions(event, stream.events),
+            globs,
+            stream.events,
+          )
           if (condition !== null) {
             match(event, state, condition)
             return
@@ -564,6 +630,7 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
       // Cursor streams that are no longer named resume anyway: finishing
       // their backlog is what makes a resumed wait lossless.
       for (const key of Object.keys(sinceStreams)) {
+        if (key === '#repo') continue
         await trackBuild(key, sinceStreams[key])
         if (hasMatch()) return finishSatisfied()
       }

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

@@ -42,8 +42,15 @@ import type { RepositoryRecord } from '../store/types'
  */
 import type { AbEvent } from '../events/catalog'
 import type { EventType } from '../events/payloads'
-import type { RepositoryEvent, RepositoryEventType } from '../events/repository'
-import { REPOSITORY_ATTENTION_EVENTS } from '../events/repository'
+import type { RepositoryEvent } from '../events/repository'
+import {
+  mergeDecision,
+  mergeIdentity,
+  RepositoryAttention,
+  repositoryNeedsAttention,
+  type MergeDecision,
+  type PersistenceObservation,
+} from './attention'
 import type { BuildState, PrLifecycle } from '../kernel/reducer'
 import { reduceBuild } from '../kernel/reducer'
 import type { BuildOutcome, BuildStatus, Phase } from '../ontology'
@@ -84,20 +91,7 @@ const TERMINAL_STATUSES: readonly BuildStatus[] = ['done', 'aborted']
  * a watch emits exactly these — deciding what to do about a blocker or a
  * merge stays with the caller's skill.
  */
-export const BUILD_ATTENTION_EVENTS = [
-  'escalation.raised',
-  'phase.failed',
-  'infrastructure.failed',
-  'runner.setup-failed',
-  'dispatch.failed',
-  'publication.lost',
-  'finalize.completed',
-  'pr.conflicted',
-  'pr.merged',
-  'pr.closed',
-  'build.completed',
-  'build.aborted',
-] as const satisfies readonly EventType[]
+export const BUILD_ATTENTION_EVENTS = ['escalation.raised'] as const satisfies readonly EventType[]
 
 // ── Glob compilation and matching ────────────────────────────────────────────
 
@@ -121,12 +115,6 @@ function matchesBuildFilter(type: EventType, filters: readonly RegExp[]): boolea
     : (BUILD_ATTENTION_EVENTS as readonly string[]).includes(type)
 }
 
-function matchesRepositoryFilter(type: RepositoryEventType, filters: readonly RegExp[]): boolean {
-  return filters.length > 0
-    ? filters.some((regex) => regex.test(type))
-    : (REPOSITORY_ATTENTION_EVENTS as readonly string[]).includes(type)
-}
-
 // ── The cursor ───────────────────────────────────────────────────────────────
 
 interface CursorPayload {
@@ -136,10 +124,29 @@ interface CursorPayload {
   /** The repository identity (normalized origin or checkout path). */
   repo: string
   /** Per-stream watch position: build slug → seq, `#repo` → seq. */
+  deliveredAttention?: string[]
   lostRuns?: string[]
   streams: Record<string, number>
 }
 
+function validAttentionIdentity(id: unknown): boolean {
+  if (typeof id !== 'string') return false
+  if (/^(source|tick):[1-9][0-9]*$/.test(id)) return true
+  try {
+    const value: unknown = JSON.parse(id)
+    return (
+      Array.isArray(value) &&
+      value.length === 2 &&
+      typeof value[0] === 'string' &&
+      value[0].length > 0 &&
+      Number.isSafeInteger(value[1]) &&
+      value[1] > 0
+    )
+  } catch {
+    return false
+  }
+}
+
 const CURSOR_PREFIX = 'v1.'
 
 /** Opaque to callers; the format is internal, not contract. */
@@ -173,13 +180,22 @@ export function decodeCursor(
     throw malformed()
   }
   if (typeof payload !== 'object' || payload === null) throw malformed()
-  const { v, store, repo, streams, lostRuns } = payload as Record<string, unknown>
+  const { v, store, repo, streams, lostRuns, deliveredAttention } = payload as Record<
+    string,
+    unknown
+  >
   if (
     lostRuns !== undefined &&
     (!Array.isArray(lostRuns) ||
       lostRuns.some((run) => typeof run !== 'string' || run.length === 0))
   )
     throw malformed()
+  if (
+    deliveredAttention !== undefined &&
+    (!Array.isArray(deliveredAttention) ||
+      deliveredAttention.some((id) => !validAttentionIdentity(id)))
+  )
+    throw malformed()
   if (v !== 1 || typeof store !== 'string' || typeof repo !== 'string') throw malformed()
   if (typeof streams !== 'object' || streams === null || Array.isArray(streams)) throw malformed()
   for (const seq of Object.values(streams)) {
@@ -202,6 +218,9 @@ export function decodeCursor(
     store,
     repo,
     streams: streams as Record<string, number>,
+    ...(deliveredAttention === undefined
+      ? {}
+      : { deliveredAttention: deliveredAttention as string[] }),
     ...(lostRuns === undefined ? {} : { lostRuns: lostRuns as string[] }),
   }
 }
@@ -272,6 +291,36 @@ export interface WatchObservationRecord {
   cursor: string
 }
 
+export interface AttentionObservationRecord {
+  repo?: string
+  build: string | null
+  state: WatchRecordState | null
+  observation: MergeDecision | PersistenceObservation
+  cursor: string
+}
+
+export function projectAttentionRecord(
+  observation: MergeDecision | PersistenceObservation,
+  state: BuildState | null,
+  cursor: string,
+  scope: { build: string } | { repo: string },
+): AttentionObservationRecord {
+  return {
+    ...scope,
+    build: 'build' in scope ? scope.build : null,
+    state: state ? projectState(state) : null,
+    observation,
+    cursor,
+  }
+}
+
+export function renderAttentionLine(
+  observation: MergeDecision | PersistenceObservation,
+  label: string,
+): string {
+  return `${observation.observedAt}  ${singleLine(label)}  ${observation.type}  ${singleLine(JSON.stringify(observation))}`
+}
+
 export interface WatchRecord {
   /** The build slug, or null for a repository-journal event. */
   build: string | null
@@ -544,6 +593,12 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
       const lostRuns = new Set(
         opts.since ? (decodeCursor(opts.since, { store: storeRef, repo }).lostRuns ?? []) : [],
       )
+      const resumedCursor = opts.since
+        ? decodeCursor(opts.since, { store: storeRef, repo })
+        : undefined
+      const deliveredAttention = new Set(resumedCursor?.deliveredAttention ?? [])
+      const repositoryAttention = new RepositoryAttention()
+      let attentionInitialized = false
       let livenessEvents: RepositoryEvent[] = []
       let livenessSeq = 0
       let livenessInitialized = false
@@ -571,6 +626,7 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
           repo,
           streams: { ...positions },
           lostRuns: [...lostRuns],
+          deliveredAttention: [...deliveredAttention],
         })
 
       /** One record, flushed the moment it is projected. `cursor` is the watch
@@ -591,6 +647,44 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         }
       }
 
+      const emitObservation = (
+        observation: MergeDecision | PersistenceObservation,
+        state: BuildState | null,
+        scope: { build: string } | { repo: string },
+        identity: string,
+      ): void => {
+        if (stop || deliveredAttention.has(identity)) return
+        deliveredAttention.add(identity)
+        const cursor = encodeCurrent()
+        opts.stdout(
+          opts.json
+            ? JSON.stringify(projectAttentionRecord(observation, state, cursor, scope))
+            : renderAttentionLine(observation, 'build' in scope ? scope.build : '(repository)'),
+        )
+        emitted += 1
+        if (opts.count !== undefined && emitted >= opts.count) {
+          countCursor = cursor
+          requestStop()
+        }
+      }
+      const checkPersistence = (): void => {
+        if (filters.length || !attentionInitialized || stop) return
+        for (const { identity, observation } of repositoryAttention.pending(now())) {
+          emitObservation(observation, null, { repo }, identity)
+          if (stop) return
+        }
+      }
+      const baselineMerge = (slug: string, events: AbEvent[]): void => {
+        // Old cursors already consumed finalize attention. Infer every eligible
+        // historical prefix, even if consent was subsequently armed again.
+        const prefix: AbEvent[] = []
+        for (const event of events) {
+          prefix.push(event)
+          const observation = mergeDecision(prefix, now())
+          if (observation) deliveredAttention.add(mergeIdentity(slug, observation.pr.number))
+        }
+      }
+
       const checkLiveness = async (): Promise<void> => {
         if (!followRepository || stop) return
         if (!livenessInitialized) {
@@ -665,17 +759,34 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
        * into a scratch prefix so a resumed record never leaks state from
        * events that landed after it. */
       const processBuildEvent = (stream: BuildStream, event: AbEvent, prefix: AbEvent[]): void => {
+        if (stop) return
         stream.lastSeq = event.seq
         positions[stream.slug] = event.seq
-        if (!matchesBuildFilter(event.type, filters)) return
-        emit(event, reduceBuild(prefix))
+        const state = reduceBuild(prefix)
+        if (matchesBuildFilter(event.type, filters)) emit(event, state)
+        if (!filters.length && !stop) {
+          const observation = mergeDecision(prefix, now(), state)
+          if (observation)
+            emitObservation(
+              observation,
+              state,
+              { build: stream.slug },
+              mergeIdentity(stream.slug, observation.pr.number),
+            )
+        }
       }
 
       const processRepositoryEvent = (stream: RepositoryStream, event: RepositoryEvent): void => {
+        if (stop) return
         stream.lastSeq = event.seq
         positions[REPO_STREAM_KEY] = event.seq
-        if (!matchesRepositoryFilter(event.type, filters)) return
-        emit(event, null)
+        repositoryAttention.fold(event)
+        if (
+          filters.length
+            ? filters.some((regex) => regex.test(event.type))
+            : repositoryNeedsAttention(event)
+        )
+          emit(event, null)
       }
 
       /**
@@ -705,7 +816,16 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         }
         streams.set(slug, stream)
         positions[slug] = stream.lastSeq
-        if (resumeSeq === undefined) return true
+        if (resumeSeq === undefined) {
+          baselineMerge(slug, events)
+          return true
+        }
+        positions[slug] = resumeSeq
+        if (resumedCursor?.deliveredAttention === undefined)
+          baselineMerge(
+            slug,
+            events.filter((event) => event.seq <= resumeSeq),
+          )
         stream.lastSeq = resumeSeq
         // Replay the backlog into a scratch prefix: each record's state is
         // the reduction of the prefix ENDING at that event, never the
@@ -771,6 +891,7 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
             status,
           }
           streams.set(record.slug, stream)
+          baselineMerge(record.slug, events)
           positions[record.slug] = stream.lastSeq
         }
       }
@@ -781,35 +902,22 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         streams.set(REPO_STREAM_KEY, stream)
         positions[REPO_STREAM_KEY] = stream.lastSeq
         try {
-          // A fresh store has no repository row; do not create one.
-          if (resumeSeq === undefined && (await store.getRepo(repo)) !== null) {
-            // 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
+          if ((await store.getRepo(repo)) !== null) {
+            // Full bootstrap is intentional: degradation can predate run anchors.
+            const history = await store.getRepoEvents(repo)
+            const baseline = resumeSeq ?? history.at(-1)?.seq ?? 0
+            for (const event of history) {
+              if (event.seq <= baseline) repositoryAttention.fold(event)
             }
-            const input = await readDispatcherLiveness(store, repo, now(), subset)
-            livenessEvents = input.events
-            livenessSeq = Math.max(last, input.events.at(-1)?.seq ?? 0)
-            livenessInitialized = true
-            if (input.record?.lease) observedOwners.set(input.record.lease.holder, input.record)
-            stream.lastSeq = last
-            positions[REPO_STREAM_KEY] = last
-          }
+            attentionInitialized = true
+            stream.lastSeq = baseline
+            positions[REPO_STREAM_KEY] = baseline
+            for (const event of history) {
+              if (event.seq <= baseline || stop) continue
+              processRepositoryEvent(stream, event)
+            }
+            if (!stop) checkPersistence()
+          } else attentionInitialized = true
           return true
         } catch {
           return false
@@ -822,6 +930,7 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
       ): Promise<boolean> => {
         const fresh = await store.getEvents(stream.slug, stream.lastSeq, readOpts)
         for (const event of fresh) {
+          if (stop) break
           stream.events.push(event)
           processBuildEvent(stream, event, stream.events)
           if (stop) break
@@ -832,17 +941,43 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         return true
       }
 
+      let repositoryQueue = Promise.resolve()
+      let repositoryInitialization: Promise<void> | undefined
       const pollRepository = async (
         stream: RepositoryStream,
         readOpts?: RemotePollReadOpts,
       ): Promise<boolean> => {
         // A repository row may be created mid-watch by the first dispatch.
         if ((await store.getRepo(repo)) === null) return true
-        const fresh = await store.getRepoEvents(repo, stream.lastSeq, readOpts)
-        for (const event of fresh) {
-          processRepositoryEvent(stream, event)
-          if (stop) break
+        if (!attentionInitialized) {
+          repositoryInitialization ??= (async () => {
+            const history = await store.getRepoEvents(repo)
+            const baseline = sinceStreams[REPO_STREAM_KEY] ?? history.at(-1)?.seq ?? 0
+            for (const event of history) {
+              if (event.seq <= baseline) repositoryAttention.fold(event)
+            }
+            stream.lastSeq = baseline
+            positions[REPO_STREAM_KEY] = baseline
+            attentionInitialized = true
+          })()
+          try {
+            await repositoryInitialization
+          } catch (error) {
+            repositoryInitialization = undefined
+            throw error
+          }
         }
+        const fresh = await store.getRepoEvents(repo, stream.lastSeq, readOpts)
+        const apply = repositoryQueue.then(() => {
+          for (const event of fresh) {
+            if (stop) break
+            if (event.seq <= stream.lastSeq) continue
+            processRepositoryEvent(stream, event)
+          }
+          if (!stop) checkPersistence()
+        })
+        repositoryQueue = apply.catch(() => {})
+        await apply
         return true
       }
 
@@ -1023,6 +1158,8 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
           void remoteRunner.runDiscovery({
             step: async (): Promise<void> => {
               if (slugs.length === 0) await discoverBuilds()
+              const repositoryStream = streams.get(REPO_STREAM_KEY)
+              if (repositoryStream?.kind === 'repo' && !stop) await pollRepository(repositoryStream)
               await checkLiveness()
             },
             // Unconditional, after the catch — exactly where the inline

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

@@ -12,6 +12,7 @@ export const DISPATCHER_CONFIG_ARTIFACT = 'dispatcher-config'
  * behavior.
  */
 export const CONFIG_RELOAD_CLASSIFICATION = {
+  store: 'restart',
   baseBranch: 'hot',
   capacity: 'hot',
   ticketScanIntervalSeconds: 'hot',
@@ -49,6 +50,7 @@ export const CONFIG_RELOAD_CLASSIFICATION = {
 }
 
 export const RESTART_REQUIRED_CONFIG_PATHS = [
+  'store',
   'forge',
   'plugins',
   'workspace.provider',
@@ -118,6 +120,7 @@ export function composeBuildConfig(pipeline: Config, deployment: Config): Config
 export function composeReloadedConfig(startup: Config, candidate: Config): Config {
   return {
     ...candidate,
+    store: startup.store,
     forge: startup.forge,
     plugins: startup.plugins,
     workspace: startup.workspace,