@defrex/autobuild 0.13.0 → 0.14.0

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

@@ -1,3 +1,9 @@
+import { readBuildDigests } from '../store/reduced-reads'
+import {
+  readBuildFacts,
+  readRepositoryFacts,
+  type RepositoryReadFacts,
+} from '../store/reduced-reads'
 import { readDispatcherLiveness } from '../cli/dispatcher-liveness'
 import { composeBuildConfig } from '../config/live'
 import type { PipelineSourceMeta } from '../config/pipeline-source'
@@ -9,26 +15,25 @@ import {
 } from '../processes/build-execution-state'
 import type { Artifact } from '../store/types'
 import {
-  detail,
+  detailFromFacts,
   statusFilter,
   summarizeFrom,
   type BuildDetail,
   type BuildSummary,
 } from '../cli/status'
-import { projectRepositoryStatus, type RepositoryStatus } from '../cli/repository-status'
+import { repositoryStatusFromFacts, type RepositoryStatus } from '../cli/repository-status'
 import { projectHarvestStatus, type HarvestStatusView } from '../cli/harvest'
 import {
   buildDashboardFromProjected,
   effectiveStatus,
-  projectBuild,
   projectBuildFromFacts,
   type DashboardBuild,
   type DashboardModel,
 } from '../cli/dashboard/model'
-import { reduceBuild, type BuildState } from '../kernel/reducer'
+import type { BuildState } from '../kernel/reducer'
 import { DISPATCHER_EFFECTIVE_CONFIG_ARTIFACT } from '../store/retention'
 import { reduceDispatchStatus } from '../kernel/dispatch-status'
-import { readRepoEventsIfRecorded, unclaimedObservationCount } from '../processes/harvest'
+import { unclaimedObservationCount } from '../processes/harvest'
 import type { RepoViewStore } from '../processes/repo-view'
 import { withOperatorView } from './read-view'
 import type { RepositoryEvent } from '../events/repository'
@@ -74,7 +79,7 @@ async function listFromView(
   // finished builds accumulate. The `--all` scope includes terminal statuses,
   // so it takes no digest read and skips nothing; its terminal builds are
   // restored from the reducer snapshots the dispatcher leaves at settlement.
-  const digests = opts.scope === 'all' ? undefined : await view.getRepoBuildDigests(opts.repo)
+  const digests = opts.scope === 'all' ? undefined : await readBuildDigests(view, opts.repo)
   const output: BuildSummary[] = []
   for (const record of records) {
     if (record.repo !== opts.repo) continue
@@ -114,14 +119,19 @@ export async function effectiveConfig(
   repo: string,
   /** The bounded journal, when the caller already holds it (a repository
    * view); otherwise it is read from the store. */
-  journal?: RepositoryEvent[],
+  journal?: RepositoryReadFacts,
 ): Promise<{
   config: Config
-  repositoryEvents: RepositoryEvent[]
+  repositoryEvents: RepositoryReadFacts
   status: ReturnType<typeof reduceDispatchStatus>
 }> {
-  const repositoryEvents = journal ?? (await readRepoEventsIfRecorded(store, repo))
-  const status = selectEffectiveConfig(repositoryEvents, repo)
+  const repositoryEvents = journal ?? (await readRepositoryFacts(store, repo)).value
+  const status = repositoryEvents.status
+  if (status?.effectiveConfig === undefined)
+    throw new OperatorQueryError(
+      'effective-config-unavailable',
+      `effective config unavailable for repository "${repo}"${repositoryEvents.config.run === undefined ? ': no dispatcher run is recorded' : ''}`,
+    )
   const ref = status.effectiveConfig!
   const artifact = await store.getRepoArtifact(repo, ref.kind, ref.rev)
   if (artifact === null) {
@@ -258,19 +268,19 @@ export async function getOperatorBuild(opts: {
   now: Date
 }): Promise<OperatorBuildView> {
   const record = await requireBuild(opts.store, opts.repo, opts.slug)
-  const events = await opts.store.getEvents(opts.slug)
-  const state = reduceBuild(events)
+  const facts = (await readBuildFacts(opts.store, opts.slug)).value
+  const state = facts.state
   const { config } = await effectiveConfig(opts.store, opts.repo)
   let dashboardRow: DashboardBuild | null = null
   if (!projectsNoDashboardRow(state)) {
     const pinned = await readPinnedConfig(opts.store, opts.slug, config)
-    const row = projectBuild(record, state, config, events, undefined, pinned.config)
+    const row = projectBuildFromFacts(record, state, facts, config, undefined, pinned.config)
     // Implied by the gate; kept as an explicit check (not an assertion) so the
     // code never lies if `effectiveStatus` and `projectBuild` ever drift.
     if (row !== null) dashboardRow = decorateWithPinnedMeta(row, pinned)
   }
   return {
-    detail: detail(record, events, opts.now),
+    detail: detailFromFacts(record, facts, opts.now),
     dashboardRow,
   }
 }
@@ -281,8 +291,12 @@ export async function getRepositoryStatus(
   now = new Date(),
 ): Promise<RepositoryStatus> {
   return withOperatorView(store, repo, 'journal', async (view) => {
-    const { dispatcher } = await readDispatcherLiveness(store, repo, now, view.recordedJournal())
-    return projectRepositoryStatus(repo, view.recordedJournal(), dispatcher)
+    const { dispatcher } = await readDispatcherLiveness(store, repo, now)
+    return repositoryStatusFromFacts(
+      repo,
+      (await readRepositoryFacts(view, repo)).value,
+      dispatcher,
+    )
   })
 }
 
@@ -291,7 +305,7 @@ export async function getHarvestStatus(
   repo: string,
 ): Promise<HarvestStatusView> {
   return withOperatorView(store, repo, 'journal', async (view) =>
-    projectHarvestStatus(repo, view.recordedJournal()),
+    projectHarvestStatus(repo, view.repositoryFacts()),
   )
 }
 
@@ -321,7 +335,7 @@ async function dashboardFromView(
   const { config, repositoryEvents, status } = await effectiveConfig(
     view,
     opts.repo,
-    view.recordedJournal(),
+    view.repositoryFacts(),
   )
   const records = await view.listBuilds()
   // One digest read covers every build of the repository (AUT-487): the
@@ -330,7 +344,7 @@ async function dashboardFromView(
   // builds accumulate. Row-rendering builds derive from the repository view's
   // reducer snapshots plus a delta read (AUT-650); every snapshot is a cache
   // the event log regenerates, so the response equals a full replay's.
-  const digests = await view.getRepoBuildDigests(opts.repo)
+  const digests = await readBuildDigests(view, opts.repo)
   const projected: DashboardBuild[] = []
   let activeCount = 0
   for (const record of records) {
@@ -372,7 +386,10 @@ async function dashboardFromView(
   // `effectiveConfig` already returned — no per-build history reads (AUT-487).
   // The pure core writes nothing — a snapshot performs no store writes and
   // never creates or locks the repository record.
-  const observationCount = unclaimedObservationCount({ digests, harvestEvents: repositoryEvents })
+  const observationCount = unclaimedObservationCount({
+    digests,
+    harvestEvents: repositoryEvents.harvest,
+  })
   const warningLines = [
     ...status.roleWarnings,
     ...(status.warningNotice !== undefined ? [status.warningNotice] : []),

package/packages/core/src/operator/read-view.ts

@@ -1,16 +1,15 @@
 /**
  * The operator read paths' repository view: every poll-driven route (dashboard,
  * repository and harvest status, build listings) derives its state from a
- * `RepoViewStore` cold-started from stored reducer snapshots and advanced with
- * delta reads, so a poll's event-row cost follows the events appended since the
- * last one, never the history, the open tabs, or the watchers.
+ * `RepoViewStore` backed by persisted reduced values. Each pass refreshes
+ * repository facts and metadata without hydrating raw history.
  *
  * Passes are single-flight per `(store, repo)` within one serving process: at
  * most one pass runs at a time, and requests arriving while it runs join the
  * one trailing pass (each needs state at least as new as its arrival, which the
  * running pass cannot promise). That trailing pass restores from the snapshot
- * the previous pass persisted, so N concurrent pollers cost one delta read per
- * pass, not N. The coordination is scheduling inside this process; every datum
+ * the previous pass persisted for builds, so N concurrent pollers cost one
+ * build delta read per pass, not N. The coordination is scheduling inside this process; every datum
  * still comes from durable state, and a second serving process simply reads the
  * same delta once itself (duplicate reads are bounded by the process count).
  */
@@ -58,14 +57,6 @@ async function pass(store: BuildStore, repo: string, waiters: Waiter[]): Promise
     return
   }
   await Promise.all(waiters.map((waiter) => waiter.run(view).then(waiter.resolve, waiter.reject)))
-  // Leave the advanced state behind for the next pass (this process's or
-  // another's). `held` also writes a settled build read for a listing. The
-  // cache never fails a read.
-  try {
-    await view.persistSnapshots({ force: true, held: true })
-  } catch {
-    // A cache: the next pass retries.
-  }
 }
 
 async function drain(store: BuildStore, repo: string, flight: Flight): Promise<void> {

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

@@ -1,16 +1,4 @@
-/**
- * The route-level glue the operator HTTP server applies around the shared
- * services, re-derived for the agent tool registry (operator/registry.ts).
- *
- * This module is registry-owned on purpose: the operator API routes were
- * declared out of scope for the registry ticket, so the parity between a
- * tool and its route is *proven* by the contract suite
- * (packages/hosted-store-service/src/registry.contract.test.ts) rather than
- * obtained by extraction. Every refusal text here is load-bearing — it must
- * stay byte-identical to the hosted package's `operator-server.ts` so the
- * suite's full-body comparisons hold.
- */
-import { reduceBuild } from '../kernel/reducer'
+import { readBuildFacts } from '../store/reduced-reads'
 import { effectiveStatus } from '../cli/dashboard/model'
 import { BuildControlError, type BuildControlAction } from '../cli/build-control'
 import type { BuildStore } from '../store/types'
@@ -80,7 +68,7 @@ export async function controlPrechecks(
 ): Promise<void> {
   await requireRouteBuild(store, repo, slug)
   if (action === 'pause' || action === 'cancel-pause') {
-    const state = reduceBuild(await store.getEvents(slug))
+    const state = (await readBuildFacts(store, slug)).value.state
     const display = effectiveStatus(state)
     if (action === 'pause' && display === 'pausing') {
       throw new BuildControlError(

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

@@ -13,7 +13,6 @@
 import { createHash } from 'node:crypto'
 import { humanActor } from '../events/envelope'
 import type { Via } from '../events/envelope'
-import type { RepositoryEvent } from '../events/repository'
 import type { Forge } from '../ports/types'
 import {
   SANDBOX_FORBIDDEN_ENV,
@@ -23,8 +22,7 @@ import {
   type SandboxWaitResult,
 } from '../ports/workspace/operator-sandbox'
 import type { WorkspaceProvider } from '../ports/types'
-import { readRepoEventsIfRecorded } from '../processes/harvest'
-import { sandboxStates } from '../processes/sandbox-state'
+import { readRepositoryFacts } from '../store/reduced-reads'
 import { systemClock, type BuildStore, type Clock } from '../store/types'
 
 /** Hard bound on one sandbox command wait, in seconds — shared with the
@@ -253,8 +251,11 @@ export async function createOperatorSandboxService(
   }
 
   /** The operator's journal state, or undefined when no environment exists. */
-  const operatorState = (identity: string, events: RepositoryEvent[]) =>
-    sandboxStates(events)
+  const operatorState = (
+    identity: string,
+    events: import('../store/reduced-reads').RepositoryReadFacts,
+  ) =>
+    events.sandboxes
       .filter((state) => state.operator === identity && state.state !== 'released')
       .at(-1)
 
@@ -327,7 +328,7 @@ export async function createOperatorSandboxService(
   ): Promise<T> => {
     const key = `${repo}\0${identity}`
     return serialize(key, async () => {
-      const events = await readRepoEventsIfRecorded(store, repo)
+      const events = (await readRepositoryFacts(store, repo)).value
       const state = operatorState(identity, events)
       const resolved = await ensureWithFacts(identity, state).catch((error: unknown) => {
         if (error instanceof SandboxOperationError) throw error
@@ -337,7 +338,7 @@ export async function createOperatorSandboxService(
           { cause: error },
         )
       })
-      const freshEvents = await readRepoEventsIfRecorded(store, repo)
+      const freshEvents = (await readRepositoryFacts(store, repo)).value
       const freshState = operatorState(identity, freshEvents)
       try {
         const result = await operation(resolved, freshState)
@@ -630,7 +631,7 @@ export async function createOperatorSandboxService(
       requireRepo(input.repo)
       const key = `${repo}\0${identity}`
       await serialize(key, async () => {
-        const events = await readRepoEventsIfRecorded(store, repo)
+        const events = (await readRepositoryFacts(store, repo)).value
         const state = operatorState(identity, events)
         const resolved = await capability.describe({ repo, operator: identity })
         await append(identity, 'orchestrator.sandbox.reset', {
@@ -662,7 +663,7 @@ export async function createOperatorSandboxService(
       requireRepo(input.repo)
       const key = `${repo}\0${identity}`
       await serialize(key, async () => {
-        const events = await readRepoEventsIfRecorded(store, repo)
+        const events = (await readRepositoryFacts(store, repo)).value
         const state = operatorState(identity, events)
         // No environment ever provisioned: a no-op, with no fact and no
         // provider traffic beyond the pure describe.

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

@@ -1,7 +1,7 @@
+import { readBuildFacts } from '../store/reduced-reads'
 import { samplePinnedAssets, preparePinnedAssets } from '../store/ticket-assets'
 import type { TicketRef } from '../ontology'
 import type { Config } from '../config/schema'
-import { reduceBuild } from '../kernel/reducer'
 import {
   TicketOperationError,
   changeBlockers,
@@ -141,7 +141,7 @@ async function matchingBuild(
   const projected = await Promise.all(
     matches.map(async (record) => ({
       record,
-      state: reduceBuild(await store.getEvents(record.slug)),
+      state: (await readBuildFacts(store, record.slug)).value.state,
     })),
   )
   projected.sort((a, b) => {

package/packages/core/src/plugin-sdk/index.ts

@@ -229,3 +229,16 @@ export type {
   TicketAssetMeta,
   TicketAssetSummary,
 } from '../store/ticket-assets'
+
+export {
+  readReducerValue,
+  resolveReducerValue,
+  reducerValueRequestSchema,
+  reducerValueSchema,
+} from '../store/reducer-values'
+export type {
+  ReducerValue,
+  ReducerValueRequest,
+  ReducerValueStorage,
+  ValueCacheRow,
+} from '../store/reducer-values'

package/packages/core/src/processes/build-child.ts

@@ -1,3 +1,4 @@
+import { readBuildFacts } from '../store/reduced-reads'
 import { hostname } from 'node:os'
 import { createForge } from '../ports/forge/create'
 import { createProductionRuntimes } from '../ports/runner/production'
@@ -13,7 +14,6 @@ import {
   buildOwnedSectionsDiffer,
   diagnosticArtifact,
   parseEffectiveBuildConfig,
-  selectOpenWorkspace,
   type BuildRunnerDiagnosticOutcome,
 } from './build-execution-state'
 import type { BuildExecutionStart } from '../ports/workspace/build-execution'
@@ -40,7 +40,7 @@ export async function runBuildChild(
   try {
     const record = await store.getBuild(input.slug)
     if (record === null) throw new Error(`unknown build ${JSON.stringify(input.slug)}`)
-    const workspace = selectOpenWorkspace(await store.getEvents(input.slug))
+    const workspace = (await readBuildFacts(store, input.slug)).value.workspace
     if (workspace === null) {
       throw new Error(`build ${JSON.stringify(input.slug)} has no open durable workspace`)
     }
@@ -55,20 +55,20 @@ export async function runBuildChild(
       throw new Error(`build ${JSON.stringify(input.slug)} has no effective config artifact`)
     }
     let currentConfig = parseEffectiveBuildConfig(configArtifact)
-    const plugins = await loadPlugins(currentConfig.plugins, workspace.path, {
+    const plugins = await loadPlugins(currentConfig.plugins, workspace.path ?? workspace.ref, {
       packageRoot: record.repo,
       ...(opts.guest === true ? { guest: true } : {}),
     })
     const { runtimes: builtins } = createProductionRuntimes()
     const runtimes = await materializePluginRuntimes(builtins, plugins, {
-      repoRoot: workspace.path,
+      repoRoot: workspace.path ?? workspace.ref,
       env,
     })
     const forge = await createForge({
       name: currentConfig.forge,
       registry: plugins,
       env,
-      repoRoot: workspace.path,
+      repoRoot: workspace.path ?? workspace.ref,
     })
     const getConfig = async () => {
       const latest = await store.getArtifact(input.slug, BUILD_EFFECTIVE_CONFIG_ARTIFACT)
@@ -94,7 +94,7 @@ export async function runBuildChild(
       config: currentConfig,
       getConfig,
       runtimes,
-      workspacePath: workspace.path,
+      workspacePath: workspace.path ?? workspace.ref,
       branch: workspace.branch,
       slug: input.slug,
       exec: spawnExec,