@defrex/autobuild 0.10.1 → 0.12.0

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

@@ -1,8 +1,11 @@
+import { readDispatcherLiveness } from './dispatcher-liveness'
+import { projectDispatcherLiveness } from '../kernel/dispatcher-liveness'
+import type { RepositoryRecord } from '../store/types'
 /**
  * `ab watch` — the sessionless, read-only streaming half of the status family
  * (§8.2, §7.2). It follows the event logs of one, several, or all active
- * builds in the repository — optionally the repository journal — and emits one
- * record per matching event as it lands, each carrying the full durable
+ * builds in the repository, plus the repository journal by default with no
+ * slugs, and emits one record per matching event as it lands, carrying the durable
  * envelope, the build's reduced state after that event, and an opaque cursor
  * so a later `--since` invocation resumes exactly where this one stopped.
  *
@@ -39,8 +42,15 @@
  */
 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'
@@ -81,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 ────────────────────────────────────────────
 
@@ -102,8 +99,8 @@ export const BUILD_ATTENTION_EVENTS = [
  * Compile `--event` globs to anchored matchers: `*` matches any run of
  * characters, `?` exactly one, everything else verbatim (so the dots inside
  * event type names are escaped). Each glob must match at least one type in
- * the build catalog — or, when `--repository` is given, in the repository
- * catalog — otherwise a usage error naming the glob is thrown before any
+ * the build catalog, or the repository catalog with no slugs or explicit
+ * `--repository` — 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
@@ -118,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 {
@@ -133,9 +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. */
@@ -169,7 +180,22 @@ export function decodeCursor(
     throw malformed()
   }
   if (typeof payload !== 'object' || payload === null) throw malformed()
-  const { v, store, repo, streams } = 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)) {
@@ -187,7 +213,16 @@ export function decodeCursor(
         `repository "${expected.repo}" — run from the repository the cursor came from`,
     )
   }
-  return { v: 1, store, repo, streams: streams as Record<string, number> }
+  return {
+    v: 1,
+    store,
+    repo,
+    streams: streams as Record<string, number>,
+    ...(deliveredAttention === undefined
+      ? {}
+      : { deliveredAttention: deliveredAttention as string[] }),
+    ...(lostRuns === undefined ? {} : { lostRuns: lostRuns as string[] }),
+  }
 }
 
 // ── Durations and cadence ────────────────────────────────────────────────────
@@ -237,6 +272,55 @@ export interface WatchRecordState {
   outcome: BuildOutcome | null
 }
 
+/** Lease-expiry evidence is an observation, never a fabricated journal event. */
+export interface WatchObservationRecord {
+  repo: string
+  build: null
+  state: null
+  observation: {
+    type: 'dispatcher.lost'
+    run: string
+    observedAt: string
+    leaseExpiresAt: string
+    pid?: number | null
+    host?: string | null
+    startedAt?: string | null
+    heartbeatAt?: string | null
+    heartbeatAgeMs?: number | null
+  }
+  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
@@ -340,6 +424,10 @@ export function summarizeEvent(event: AbEvent | RepositoryEvent, state: BuildSta
       return `harvest run ${event.payload.run} escalated: ${singleLine(event.payload.reason)}`
     case 'harvest.failed':
       return `harvest run ${event.payload.run} failed at ${event.payload.step} (attempt ${event.payload.attempt}): ${singleLine(event.payload.error)}`
+    case 'dispatcher.ticket-source-degraded':
+      return `ticket source ${event.payload.source} degraded: ${event.payload.cause} (${event.payload.operation}) — ${singleLine(event.payload.message)}${'resetAt' in event.payload ? `; reset ${event.payload.resetAt}` : ''}`
+    case 'dispatcher.ticket-source-recovered':
+      return `ticket source ${event.payload.source} recovered: ${event.payload.cause} (${event.payload.operation})`
     case 'dispatcher.tick-failed':
       return `dispatcher tick failed: ${singleLine(event.payload.error)}`
     case 'dispatcher.config-rejected':
@@ -451,6 +539,7 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
   const sleep = opts.delay ?? defaultDelay
   const slugs = [...(opts.slugs ?? [])]
   const repository = opts.repository === true
+  const followRepository = repository || slugs.length === 0
 
   const timeoutMs =
     opts.timeout !== undefined
@@ -462,10 +551,14 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
       : undefined
 
   // Ambient scope, before any store access.
-  assertReadScope(slugs, { repository, env: opts.env })
+  assertReadScope(slugs, { repository: followRepository, env: opts.env })
 
   // Glob validation needs only the catalogs — before any store access.
-  const filters = compileEventGlobs(opts.events ?? [], { repository, usage: WATCH_USAGE })
+  const filters = compileEventGlobs(opts.events ?? [], {
+    repository: followRepository,
+    additionalCatalog: followRepository ? ['dispatcher.lost'] : [],
+    usage: WATCH_USAGE,
+  })
 
   await withAmbientReadStore(
     {
@@ -497,6 +590,19 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         record.repo === identity ||
         (record.repoOrigin !== undefined && normalizeGitRemoteUrl(record.repoOrigin) === identity)
 
+      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
+      const observedOwners = new Map<string, RepositoryRecord>()
       const streams = new Map<string, Stream>()
       // Every stream's position — matching or not, delivered or baselined —
       // lives here, so a resume never rescans or redelivers a filtered event.
@@ -514,7 +620,14 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
       }
 
       const encodeCurrent = (): string =>
-        encodeCursor({ v: 1, store: storeRef, repo, streams: { ...positions } })
+        encodeCursor({
+          v: 1,
+          store: storeRef,
+          repo,
+          streams: { ...positions },
+          lostRuns: [...lostRuns],
+          deliveredAttention: [...deliveredAttention],
+        })
 
       /** One record, flushed the moment it is projected. `cursor` is the watch
        * position AFTER this event. */
@@ -534,6 +647,111 @@ 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) {
+          const input = await readDispatcherLiveness(store, repo, now())
+          livenessEvents = input.events
+          livenessSeq = input.events.at(-1)?.seq ?? 0
+          livenessInitialized = true
+        }
+        if ((await store.getRepo(repo)) === null) return
+        const fresh = await store.getRepoEvents(repo, livenessSeq)
+        livenessEvents.push(...fresh)
+        livenessSeq = fresh.at(-1)?.seq ?? livenessSeq
+        // Sample metadata after the journal. Recheck both immediately before
+        // reporting: a failed read is infrastructure, never evidence of death.
+        const record = await store.getRepo(repo)
+        if (record?.lease) observedOwners.set(record.lease.holder, record)
+        for (const [id, owner] of observedOwners) {
+          if (
+            stop ||
+            lostRuns.has(id) ||
+            !owner.lease ||
+            Date.parse(owner.lease.expiresAt) > now().getTime()
+          )
+            continue
+          const delta = await store.getRepoEvents(repo, livenessSeq)
+          livenessEvents.push(...delta)
+          livenessSeq = delta.at(-1)?.seq ?? livenessSeq
+          const current = await store.getRepo(repo)
+          if (current?.lease?.holder === id) {
+            observedOwners.set(id, current)
+            if (Date.parse(current.lease.expiresAt) > now().getTime()) continue
+          }
+          const evidence = projectDispatcherLiveness(
+            current?.lease?.holder === id ? current : owner,
+            livenessEvents,
+            now(),
+          )
+          if (
+            livenessEvents.some((e) => e.type === 'dispatcher.run-stopped' && e.payload.run === id)
+          ) {
+            observedOwners.delete(id)
+            continue
+          }
+          if (!(filters.length ? filters.some((f) => f.test('dispatcher.lost')) : true)) continue
+          if (stop) return
+          lostRuns.add(id)
+          const cursor = encodeCurrent()
+          const observation = {
+            ...evidence.expiredHolder,
+            type: 'dispatcher.lost',
+            run: id,
+            observedAt: now().toISOString(),
+            leaseExpiresAt: (current?.lease?.holder === id ? current : owner).lease!.expiresAt,
+          }
+          opts.stdout(
+            opts.json
+              ? JSON.stringify({ repo, build: null, state: null, observation, cursor })
+              : `dispatcher.lost ${id} — lease expired ${observation.leaseExpiresAt}`,
+          )
+          emitted += 1
+          if (opts.count !== undefined && emitted >= opts.count) {
+            countCursor = cursor
+            requestStop()
+          }
+        }
+      }
+
       /** Record one event. `prefix` is the event prefix ENDING at `event` —
        * the record's state is the reduction after THIS event, never a
        * reduction over events that landed after it. The poll path passes the
@@ -541,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)
       }
 
       /**
@@ -581,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
@@ -647,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
         }
       }
@@ -657,30 +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)
             }
-            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
@@ -693,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
@@ -703,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
       }
 
@@ -752,7 +1016,14 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
             tickStreak.onFailure(error)
           }
         }
-        if (allReadsOk) tickStreak.onSuccess()
+        if (allReadsOk) {
+          try {
+            await checkLiveness()
+            tickStreak.onSuccess()
+          } catch (error) {
+            tickStreak.onFailure(error)
+          }
+        }
       }
 
       // ── Initial scan ──
@@ -778,13 +1049,14 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         await trackBuild(key, sinceStreams[key])
         if (stop) break
       }
-      if (repository) {
+      if (followRepository) {
         if (!(await trackRepository())) {
           makeFailureStreak('watch', opts.stderr).onFailure(
             new Error(`could not read the repository journal for "${repo}"`),
           )
         }
-      } else if (slugs.length === 0) {
+      }
+      if (!repository && slugs.length === 0) {
         // Membership discovery also baselines the default watch; a failed
         // discovery here is fatal — nothing has started yet.
         try {
@@ -795,6 +1067,13 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
         }
       }
 
+      if (followRepository && !stop) {
+        try {
+          await checkLiveness()
+        } catch (error) {
+          tickStreak.onFailure(error)
+        }
+      }
       // ── The poll loop ──
       const deadline = timeoutMs === 0 ? Number.POSITIVE_INFINITY : now().getTime() + timeoutMs
       const aborted = (): boolean => opts.signal?.aborted === true
@@ -875,10 +1154,13 @@ export async function abWatch(opts: AbWatchOpts): Promise<void> {
 
         for (const stream of streams.values()) if (!shouldStop) launch(stream)
 
-        if (slugs.length === 0 && !shouldStop) {
+        if ((slugs.length === 0 || followRepository) && !shouldStop) {
           void remoteRunner.runDiscovery({
             step: async (): Promise<void> => {
-              await discoverBuilds()
+              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
             // launch loop ran: streams registered before a mid-discovery

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

@@ -12,8 +12,10 @@ export const DISPATCHER_CONFIG_ARTIFACT = 'dispatcher-config'
  * behavior.
  */
 export const CONFIG_RELOAD_CLASSIFICATION = {
+  store: 'restart',
   baseBranch: 'hot',
   capacity: 'hot',
+  ticketScanIntervalSeconds: 'hot',
   forge: 'restart',
   plugins: 'restart',
   pr: 'hot',
@@ -48,6 +50,7 @@ export const CONFIG_RELOAD_CLASSIFICATION = {
 }
 
 export const RESTART_REQUIRED_CONFIG_PATHS = [
+  'store',
   'forge',
   'plugins',
   'workspace.provider',
@@ -117,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,