@defrex/autobuild 0.12.0 → 0.14.0

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

@@ -1,3 +1,6 @@
+import { parseConfig } from '../config/load'
+import { HostedTicketSource } from '../ports/tickets/remote'
+import { ticketLifecycle } from '../ports/tickets/lifecycle'
 import { createHash, randomBytes, randomUUID } from 'node:crypto'
 import { access, readFile, rename, unlink, writeFile } from 'node:fs/promises'
 import { constants } from 'node:fs'
@@ -14,6 +17,8 @@ import { resolveMainRepo } from './repo-state'
 import { ProjectCredentials } from './project-credentials'
 
 interface ConnectOptions {
+  tickets?: boolean
+  builds?: boolean
   cwd: string
   env: Record<string, string | undefined>
   exec: Exec
@@ -45,8 +50,15 @@ async function project(opts: ConnectOptions) {
   const store = table.store as { url?: unknown } | undefined
   if (store && (typeof store !== 'object' || Array.isArray(store)))
     throw new Error('Invalid [store] configuration')
-  const service = store?.url === undefined ? undefined : normalizeServiceURL(String(store.url))
-  return { checkout, repo, path, text, table, service }
+  const tickets = table.tickets as { source?: string; url?: string } | undefined
+  const buildService = opts.env.AB_STORE?.trim() || store?.url
+  const ticketService = tickets?.source === 'hosted' ? (tickets.url ?? buildService) : undefined
+  const selected = opts.tickets ? ticketService : buildService
+  const service =
+    typeof selected === 'string' && /^https?:/.test(selected)
+      ? normalizeServiceURL(selected)
+      : undefined
+  return { checkout, repo, path, text, table, service, buildService, ticketService }
 }
 async function request(
   opts: ConnectOptions,
@@ -84,45 +96,64 @@ async function atomicConfig(path: string, before: string, after: string) {
   }
 }
 export async function abConnect(raw: string | undefined, opts: ConnectOptions): Promise<void> {
+  if (opts.tickets && opts.builds) throw new Error('Choose --tickets or --builds')
   const p = await project(opts)
+  if (opts.tickets && (p.table.tickets as { source?: string } | undefined)?.source !== 'hosted')
+    throw new Error('ab connect --tickets requires [tickets] source = "hosted"')
   const credentials = new ProjectCredentials(opts.env)
   if (raw === undefined) {
-    if (!p.service) {
-      opts.print(
-        `Project: ${p.repo}\nService: unconfigured\nCredential: missing; run ab connect <url>`,
-      )
+    const connections = new Map<string, string[]>()
+    for (const [use, candidate] of [
+      ['builds', p.buildService],
+      ['tickets', p.ticketService],
+    ] as const) {
+      if (typeof candidate !== 'string' || !/^https?:/.test(candidate)) continue
+      const service = normalizeServiceURL(candidate)
+      connections.set(service, [...(connections.get(service) ?? []), use])
+    }
+    if (connections.size === 0) {
+      opts.print(`Project: ${p.repo}\nService: unconfigured`)
       return
     }
-    const entry = credentials.load(p.service, p.repo)
-    let status = 'missing; run ab connect'
-    if (entry) {
-      try {
-        const response = await request(opts, p.service, 'status', undefined, entry.token)
-        if (response.ok) {
-          const body = (await response.json()) as {
-            repo?: string
-            credentialId?: string
-            accepted?: boolean
+    for (const [service, uses] of connections) {
+      opts.print(`Uses: ${uses.join(', ')}`)
+      if (!service) {
+        opts.print(
+          `Project: ${p.repo}\nService: unconfigured\nCredential: missing; run ab connect <url>`,
+        )
+        return
+      }
+      const entry = credentials.load(service, p.repo)
+      let status = 'missing; run ab connect'
+      if (entry) {
+        try {
+          const response = await request(opts, service, 'status', undefined, entry.token)
+          if (response.ok) {
+            const body = (await response.json()) as {
+              repo?: string
+              credentialId?: string
+              accepted?: boolean
+            }
+            if (body.repo !== p.repo || body.credentialId !== entry.id || body.accepted !== true)
+              throw new Error('Invalid status response')
           }
-          if (body.repo !== p.repo || body.credentialId !== entry.id || body.accepted !== true)
-            throw new Error('Invalid status response')
+          status = response.ok
+            ? 'accepted'
+            : response.status === 401 || response.status === 403
+              ? 'rejected; run ab connect'
+              : 'unreachable'
+        } catch {
+          status = 'unreachable'
         }
-        status = response.ok
-          ? 'accepted'
-          : response.status === 401 || response.status === 403
-            ? 'rejected; run ab connect'
-            : 'unreachable'
-      } catch {
-        status = 'unreachable'
       }
+      opts.print(`Service: ${service}\nProject: ${p.repo}\nCredential: ${status}`)
     }
-    opts.print(`Service: ${p.service}\nProject: ${p.repo}\nCredential: ${status}`)
     return
   }
   const service = normalizeServiceURL(raw)
-  if (p.service && p.service !== service)
+  if (!opts.tickets && p.service && p.service !== service)
     throw new Error(
-      'Configured [store] url differs; update it explicitly before connecting to another service',
+      `Configured [${opts.tickets ? 'tickets' : 'store'}] url differs; update it explicitly before connecting to another service`,
     )
   await access(p.path, constants.W_OK)
   await access(dirname(p.path), constants.W_OK)
@@ -169,6 +200,7 @@ export async function abConnect(raw: string | undefined, opts: ConnectOptions):
   let approved = false
   let configChanged = false
   let saved = false
+  let updatedText = p.text
   try {
     let outcome: ConnectionOutcome | undefined
     while (!opts.signal?.aborted && now() <= Date.parse(started.expiresAt) + interval) {
@@ -199,15 +231,42 @@ export async function abConnect(raw: string | undefined, opts: ConnectOptions):
     approved = true
     if (outcome.repo !== p.repo || outcome.credentialId !== id)
       throw new Error('Approval identity mismatch')
-    if (!p.service) {
-      // Dotted root key also supports an existing empty [store] table after it.
-      const after = `store.url = ${JSON.stringify(service)}\n${p.text}`
-      const parsed = parse(after)
-      if ((parsed.store as { url?: string })?.url !== service)
-        throw new Error('Cannot safely update [store] url; add it manually and retry')
-      await atomicConfig(p.path, p.text, after)
+    if (!p.service || (opts.tickets && (p.table.tickets as { url?: string }).url !== service)) {
+      updatedText = setConnectionURL(p.text, opts.tickets ? 'tickets' : 'store', service)
+      if (opts.tickets) parseConfig(updatedText)
+      else parse(updatedText)
+      await atomicConfig(p.path, p.text, updatedText)
       configChanged = true
     }
+    const configuredTickets = p.table.tickets as { source?: string; url?: string } | undefined
+    if (
+      opts.tickets ||
+      (configuredTickets?.source === 'hosted' &&
+        (!configuredTickets.url || normalizeServiceURL(configuredTickets.url) === service))
+    ) {
+      const tickets = parseConfig(updatedText).tickets
+      const lifecycle = ticketLifecycle(tickets)
+      await new HostedTicketSource({
+        url: service,
+        token,
+        repo: p.repo,
+        teamKey: tickets.teamKey!,
+        ...(opts.fetch ? { fetchFn: (input, init) => opts.fetch!(String(input), init) } : {}),
+      }).synchronizePolicy({
+        version: 1,
+        tickets: {
+          source: 'hosted',
+          teamKey: tickets.teamKey!,
+          readyState: lifecycle.ready,
+          triageState: lifecycle.triage,
+          claimedState: lifecycle.doing,
+          doneState: lifecycle.done,
+          createState: lifecycle.create,
+          proposalState: lifecycle.proposal,
+          ...(tickets.readyLabels !== undefined ? { readyLabels: tickets.readyLabels } : {}),
+        },
+      })
+    }
     credentials.save({ service, repo: p.repo, id, token })
     saved = true
     if (previous) {
@@ -233,21 +292,35 @@ export async function abConnect(raw: string | undefined, opts: ConnectOptions):
       }
       if (configChanged) {
         try {
-          await atomicConfig(p.path, `store.url = ${JSON.stringify(service)}\n${p.text}`, p.text)
+          await atomicConfig(p.path, updatedText, p.text)
         } catch {
-          opts.print('Restore [store] url manually if needed; configuration changed concurrently.')
+          opts.print(
+            `Restore [${opts.tickets ? 'tickets' : 'store'}] url manually if needed; configuration changed concurrently.`,
+          )
         }
       }
     }
     throw new Error(
       approved
-        ? 'Connection could not be saved; previous credential retained. Repair local storage and run ab connect again.'
+        ? `Connection could not be saved; previous credential retained. ${(error as Error).message}. Repair the reported error and run ab connect again.`
         : (error as Error).message,
     )
   }
 }
 export async function abDisconnect(opts: ConnectOptions): Promise<void> {
+  if (opts.tickets && opts.builds) throw new Error('Choose --tickets or --builds')
   const p = await project(opts)
+  if (
+    !opts.tickets &&
+    !opts.builds &&
+    p.ticketService &&
+    p.service &&
+    normalizeServiceURL(String(p.ticketService)) !== p.service
+  )
+    throw new Error(
+      'Multiple services: use ab disconnect --tickets for tickets; set AB_STORE to the build service and select --builds for builds',
+    )
+  if (!p.service && !opts.builds && p.ticketService) return abDisconnect({ ...opts, tickets: true })
   if (!p.service) throw new Error('No configured service')
   const credentials = new ProjectCredentials(opts.env)
   const entry = credentials.load(p.service, p.repo)
@@ -255,7 +328,37 @@ export async function abDisconnect(opts: ConnectOptions): Promise<void> {
     opts.print('No stored credential; project configuration and service data retained.')
     return
   }
+  if (p.ticketService && p.buildService === p.ticketService)
+    opts.print('Builds and tickets share this credential; disconnecting affects both uses.')
   await revoke(opts, p.service, entry.token)
   credentials.remove(p.service, p.repo)
   opts.print('Disconnected; project registration, data, and [store] url retained.')
 }
+
+/** Edit only the selected table; preserve unrelated configuration and comments. */
+export function setConnectionURL(
+  text: string,
+  table: 'tickets' | 'store',
+  service: string,
+): string {
+  const lines = text.split('\n')
+  let inside = false
+  let start = -1
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!
+    if (/^\s*\[/.test(line)) {
+      if (inside) {
+        lines.splice(i, 0, `url = ${JSON.stringify(service)}`)
+        return lines.join('\n')
+      }
+      inside = new RegExp(`^\\s*\\[${table}\\]\\s*(?:#.*)?$`).test(line)
+      if (inside) start = i
+    } else if (inside && /^\s*url\s*=/.test(line)) {
+      lines[i] = `url = ${JSON.stringify(service)}`
+      return lines.join('\n')
+    }
+  }
+  if (start >= 0) lines.splice(start + 1, 0, `url = ${JSON.stringify(service)}`)
+  else lines.push(`[${table}]`, `url = ${JSON.stringify(service)}`)
+  return lines.join('\n')
+}

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

@@ -1,3 +1,4 @@
+import { readBuildFacts, type CurrentBuildFacts } from '../store/reduced-reads'
 /**
  * The `ab context` materializer (SPEC §8.3): a phase-scoped hydration of the
  * gitignored `.ab/` scratch dir. Everything derives from
@@ -16,14 +17,13 @@ import { mkdir, rm, writeFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { parseConfig } from '../config/load'
 import type { VerifyStepConfig } from '../config/schema'
-import type { AbEvent } from '../events/catalog'
 import {
   allowedTerminals,
   phaseSpecFor,
   type PhaseSpec,
   type TerminalCommand,
 } from '../kernel/phases'
-import { reduceBuild, type BuildState } from '../kernel/reducer'
+import type { BuildState } from '../kernel/reducer'
 import {
   isVerifyPhase,
   verifyReportKind,
@@ -113,69 +113,12 @@ function requiredKinds(spec: PhaseSpec, phase: Phase): string[] {
 
 /** All finding objects ever deposited, by id — verdict payloads carry them in
  * full (§15.3), so feedback-by-id resolves without touching artifacts. */
-function findingsById(events: AbEvent[]): Map<string, Finding> {
-  const byId = new Map<string, Finding>()
-  for (const event of events) {
-    if (event.type === 'plan-review.verdict' || event.type === 'code-review.verdict') {
-      for (const finding of event.payload.findings) byId.set(finding.id, finding)
-    }
-  }
-  return byId
+function findingsById(events: CurrentBuildFacts): Map<string, Finding> {
+  return new Map(Object.values(events.findings).map((finding) => [finding.id, finding]))
 }
-
-/**
- * The feedback carried by this occurrence's `*.started` event (§15.3).
- * `implement.started`, `plan.started`, and agent `verify.started` may carry
- * feedback — the carrier that gets answered guidance to a fresh session after
- * a parked build re-attaches (§15.6-B). A `plan.started` without one (logs
- * predating the field) falls
- * back to deriving round-N feedback from the round-(N-1)
- * `plan-review.verdict` — the plan loop's verdicts ARE its findings channel
- * (§8.3: "prior plan rev + findings").
- */
-function currentFeedback(events: AbEvent[], phase: Phase, round: number): Feedback | null {
-  if (isVerifyPhase(phase)) {
-    const step = verifyStep(phase)
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-      const event = events[i]!
-      if (
-        event.type === 'verify.started' &&
-        event.payload.step === step &&
-        event.payload.attempt === round
-      ) {
-        return event.payload.feedback ?? null
-      }
-    }
-    return null
-  }
-  if (phase === 'implement') {
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-      const event = events[i]!
-      if (event.type === 'implement.started' && event.payload.round === round) {
-        return event.payload.feedback ?? null
-      }
-    }
-    return null
-  }
-  if (phase === 'plan') {
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-      const event = events[i]!
-      if (event.type === 'plan.started' && event.payload.round === round) {
-        if (event.payload.feedback !== undefined) return event.payload.feedback
-        break // legacy start without the field — derive from the prior verdict
-      }
-    }
-    if (round <= 1) return null
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-      const event = events[i]!
-      if (event.type === 'plan-review.verdict' && event.payload.round === round - 1) {
-        return event.payload.verdict === 'revise'
-          ? { findings: event.payload.findings.map((finding) => finding.id) }
-          : null
-      }
-    }
-  }
-  return null
+function currentFeedback(events: CurrentBuildFacts, phase: Phase, round: number): Feedback | null {
+  const explicit = events.feedback[JSON.stringify([phase, round])]
+  return explicit ?? (phase === 'plan' ? (events.planFeedback[String(round)] ?? null) : null)
 }
 
 /** Empty and recreate `.ab/`; callers restore any tracked legacy entries. */
@@ -184,7 +127,7 @@ async function wipeAbDir(abDir: string): Promise<void> {
   await mkdir(abDir, { recursive: true })
 }
 
-function dismissedIds(state: BuildState, events: AbEvent[]): string[] {
+function dismissedIds(state: BuildState, events: CurrentBuildFacts): string[] {
   const known = findingsById(events)
   const ids = new Set<string>()
   for (const escalation of state.answeredEscalations) {
@@ -205,8 +148,8 @@ export async function buildContext(deps: ContextDeps): Promise<ContextManifest>
   const { build, phase, round } = env
   const spec = phaseSpecFor(phase)
   const inputs = spec.inputs
-  const events = await store.getEvents(build)
-  const state = reduceBuild(events)
+  const events = (await readBuildFacts(store, build)).value
+  const state = events.state
 
   // Preserve legacy tracked scratch exactly while replacing disposable files.
   // Some adapter contract fixtures intentionally use a non-Git workspace;
@@ -271,9 +214,15 @@ export async function buildContext(deps: ContextDeps): Promise<ContextManifest>
   }
 
   if (inputs.ticket === true) {
-    const created = events.find((event) => event.type === 'build.created')
+    const created = events.created
     if (created !== undefined && created.type === 'build.created') {
-      const ticket = created.payload.ticket
+      const original = created.payload.ticket
+      const current =
+        original.source === 'hosted' ? (await store.getBuild(build))?.ticket : undefined
+      const ticket = {
+        ...original,
+        ...(current?.source === original.source ? { id: current.id } : {}),
+      }
       const lines = [
         `# Ticket: ${ticket.title ?? ticket.id}`,
         '',
@@ -436,13 +385,8 @@ export async function buildContext(deps: ContextDeps): Promise<ContextManifest>
     // records the execution input in reconcile.started. A crashed same-attempt
     // rerun can therefore have multiple starts; the newest matching AB_PHASE
     // attempt is authoritative.
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-      const event = events[i]!
-      if (event.type === 'reconcile.started' && event.payload.attempt === round) {
-        manifest.conflict = { baseSha: event.payload.baseSha }
-        break
-      }
-    }
+    const baseSha = events.reconcileBases[String(round)]
+    if (baseSha !== undefined) manifest.conflict = { baseSha }
     if (manifest.conflict === undefined) {
       throw new Error(
         `reconcile@${round} context requires a matching reconcile.started event ` +
@@ -482,10 +426,10 @@ export async function buildContext(deps: ContextDeps): Promise<ContextManifest>
   // Legacy tracked scratch is repository debt, not content Autobuild rewrites.
   // Record it once per build from the provisioned base so harvest can groom it.
   if (gitWorkspace && deps.ids !== undefined) {
-    const provisioned = events.find((event) => event.type === 'workspace.provisioned')
+    const provisioned = events.firstWorkspace
     const marker = 'phase-scratch:tracked-at-provisioned-base'
-    const alreadyRecorded = events.some(
-      (event) => event.type === 'observation.recorded' && event.payload.refs?.includes(marker),
+    const alreadyRecorded = events.observations.some((observation) =>
+      observation.refs?.includes(marker),
     )
     if (
       provisioned !== undefined &&

package/packages/core/src/cli/dashboard/model.ts

@@ -1,3 +1,4 @@
+import type { RepositoryReadFacts } from '../../store/reduced-reads'
 /**
  * The dashboard's pure projection: `BuildState` → what the operator sees.
  *
@@ -920,7 +921,7 @@ function escalationAttentionDismissed(events: RepositoryEvent[], terminalSeq: nu
 }
 
 function selectDashboardHarvestRun(
-  events: RepositoryEvent[],
+  events: RepositoryEvent[] | RepositoryReadFacts,
   state: HarvestState,
 ): HarvestRunState | undefined {
   const attention = state.runs.find((run) => {
@@ -928,7 +929,12 @@ function selectDashboardHarvestRun(
       return run.recoveryExhaustion?.attentionAcknowledgedSeq === undefined
     }
     if (run.status !== 'escalated') return false
-    return run.terminalSeq === undefined || !escalationAttentionDismissed(events, run.terminalSeq)
+    return (
+      run.terminalSeq === undefined ||
+      !(Array.isArray(events)
+        ? escalationAttentionDismissed(events, run.terminalSeq)
+        : events.dismissedThrough > run.terminalSeq)
+    )
   })
   return attention ?? openHarvestRun(state)
 }
@@ -937,7 +943,7 @@ function selectDashboardHarvestRun(
  * exhausted, or escalated attention outranks merely open work; completed and
  * acknowledged terminal history never hides an older actionable run. */
 function projectHarvestRun(
-  events: RepositoryEvent[],
+  events: RepositoryEvent[] | RepositoryReadFacts,
   state: HarvestState,
 ): DashboardHarvest | undefined {
   const run = selectDashboardHarvestRun(events, state)
@@ -968,25 +974,27 @@ function projectHarvestRun(
   const approved = run.reviews.some((review) => review.verdict === 'approve')
   const synthOutput = run.proposals.length > 0
   const reviewOutput = run.reviews.length > 0
-  const failedEvent =
-    run.status === 'failed'
-      ? [...events]
-          .reverse()
-          .find(
-            (event) =>
-              event.type === 'harvest.failed' &&
-              event.payload.run === run.run &&
-              event.payload.willRetry === false,
-          )
-      : undefined
+  const failureStoppedAt =
+    run.status !== 'failed'
+      ? undefined
+      : Array.isArray(events)
+        ? [...events]
+            .reverse()
+            .find(
+              (event) =>
+                event.type === 'harvest.failed' &&
+                event.payload.run === run.run &&
+                !event.payload.willRetry,
+            )?.ts
+        : events.failedAt[JSON.stringify(run.run)]
   // Both durable stop states freeze any open occurrence. A failure normally
   // closes its step immediately afterward, but projecting the boundary itself
   // must never make an errored row look like work is still accumulating time.
   const frozenAt =
     state.pausedAt !== undefined
       ? Date.parse(state.pausedAt)
-      : failedEvent !== undefined
-        ? Date.parse(failedEvent.ts)
+      : failureStoppedAt !== undefined
+        ? Date.parse(failureStoppedAt)
         : undefined
   const steps: PipelineStep[] = [
     step('scan', hasOutcome('scan', 'completed'), current('scan'), {
@@ -1073,8 +1081,10 @@ interface RepositoryHarvestProjection {
 /** The repository-journal half of a legacy dashboard frame (AUT-545): the
  * harvest projection and the pause flag exactly as `buildDashboardFromProjected`
  * derives them, exposed for tests that pin the bounded read's equivalence. */
-export function projectRepositoryHarvest(events: RepositoryEvent[]): RepositoryHarvestProjection {
-  const state = reduceHarvest(events)
+export function projectRepositoryHarvest(
+  events: RepositoryEvent[] | RepositoryReadFacts,
+): RepositoryHarvestProjection {
+  const state = Array.isArray(events) ? reduceHarvest(events) : events.harvest
   const harvest = projectHarvestRun(events, state)
   return {
     harvestPaused: state.paused,
@@ -1082,7 +1092,9 @@ export function projectRepositoryHarvest(events: RepositoryEvent[]): RepositoryH
   }
 }
 
-export function projectHarvest(events: RepositoryEvent[]): DashboardHarvest | undefined {
+export function projectHarvest(
+  events: RepositoryEvent[] | RepositoryReadFacts,
+): DashboardHarvest | undefined {
   return projectRepositoryHarvest(events).harvest
 }
 
@@ -1112,11 +1124,13 @@ export interface DashboardHeader extends DashboardFrameHeader {
 export function buildDashboardFromProjected(
   projectedBuilds: readonly DashboardBuild[],
   header: DashboardHeader,
-  repositoryEvents: RepositoryEvent[] = [],
+  repositoryEvents: RepositoryEvent[] | RepositoryReadFacts = [],
 ): DashboardModel {
   const builds = [...projectedBuilds].sort((a, b) => a.slug.localeCompare(b.slug))
   const harvestProjection = projectRepositoryHarvest(repositoryEvents)
-  const settings = reduceDispatchSettings(repositoryEvents)
+  const settings = Array.isArray(repositoryEvents)
+    ? reduceDispatchSettings(repositoryEvents)
+    : repositoryEvents.settings
   return {
     repo: header.repo,
     queued: header.queued,
@@ -1143,7 +1157,7 @@ export function buildDashboard(
   entries: { record: BuildRecord; state: BuildState; events: AbEvent[] }[],
   config: Config,
   header: DashboardFrameHeader,
-  repositoryEvents: RepositoryEvent[] = [],
+  repositoryEvents: RepositoryEvent[] | RepositoryReadFacts = [],
 ): DashboardModel {
   const builds = entries
     .map(({ record, state, events }) => projectBuild(record, state, config, events))

package/packages/core/src/cli/dashboard/poll.ts

@@ -211,7 +211,7 @@ export class DashboardBuildPollCache {
         // both the cached reduction and projected row untouched.
         next.set(
           record.slug,
-          configChanged
+          configChanged || current.build?.ticketId !== record.ticket?.id
             ? {
                 ...current,
                 build: await this.projectRow(record, current.state, current.events, config),