@defrex/autobuild 0.8.0

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

@@ -0,0 +1,698 @@
+/** Typed agent/operator surface for repository-scoped harvest workflows. Agent
+ * stdout is never interpreted: proposal sets and review verdicts land through
+ * this module as validated repository events and versioned artifacts. */
+import { mkdir, rm, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { z } from 'zod'
+import {
+  isHarvestEvent,
+  type HarvestEvent,
+  type RepositoryEvent,
+  type RepositoryEventEnvelope,
+} from '../events/repository'
+import { agentActor } from '../events/envelope'
+import {
+  harvestProposalSetSchema,
+  type HarvestProposalSet,
+  type HarvestScanPacket,
+} from '../harvest/schema'
+import type { IdSource } from '../ids'
+import {
+  DEFAULT_MAX_HARVEST_RECOVERY_ATTEMPTS,
+  openHarvestRuns,
+  parkedHarvestRuns,
+  proposalArtifactForRound,
+  reduceHarvest,
+  unresolvedHarvestAttentionRuns,
+  type HarvestPendingCommand,
+  type HarvestRunState,
+} from '../kernel/harvest'
+import { findingDraftSchema, type Finding } from '../ontology'
+import type { Exec } from '../ports/workspace/git-worktree'
+import {
+  HARVEST_PROPOSALS_ARTIFACT,
+  HARVEST_REVIEW_ARTIFACT,
+  loadScanPacket,
+  validateProposalCoverage,
+} from '../processes/harvest'
+import type { BuildStore } from '../store/types'
+import type { HarvestCliEnv } from './env'
+import { withSessionlessStore, type StoreOpener } from './store-opening'
+
+export interface HarvestCliDeps {
+  store: BuildStore
+  env: HarvestCliEnv
+  workspacePath: string
+  ids: IdSource
+}
+
+export interface HarvestContextManifest {
+  repo: string
+  run: string
+  phase: 'synthesize' | 'review'
+  round: number
+  required: string[]
+  allowedTerminal: 'submit' | 'verdict'
+  materialized: string[]
+}
+
+async function wipeAbDir(dir: string): Promise<void> {
+  await rm(dir, { recursive: true, force: true })
+  await mkdir(dir, { recursive: true })
+  await writeFile(join(dir, '.gitignore'), '*\n')
+}
+
+async function writeJson(path: string, value: unknown): Promise<void> {
+  await mkdir(dirname(path), { recursive: true })
+  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`)
+}
+
+function runForEnv(events: RepositoryEvent[], env: HarvestCliEnv): HarvestRunState {
+  const run = reduceHarvest(events).runs.find((candidate) => candidate.run === env.run)
+  if (!run) throw new Error(`unknown harvest run "${env.run}" in repo "${env.repo}"`)
+  if (run.status !== 'running') {
+    throw new Error(
+      `harvest run "${env.run}" is already ${run.status} — its agent session may not deposit another terminal`,
+    )
+  }
+  return run
+}
+
+function assertNoSessionTerminal(events: RepositoryEvent[], env: HarvestCliEnv): void {
+  for (const event of events) {
+    if (
+      event.type === 'harvest.proposals.submitted' &&
+      env.phase === 'synthesize' &&
+      event.payload.run === env.run &&
+      event.payload.round === env.round
+    ) {
+      throw new Error(
+        `second harvest terminal rejected: proposals for ${env.run} synthesize@${env.round} already landed at repo seq ${event.seq}`,
+      )
+    }
+    if (
+      event.type === 'harvest.review.verdict' &&
+      env.phase === 'review' &&
+      event.payload.run === env.run &&
+      event.payload.round === env.round
+    ) {
+      throw new Error(
+        `second harvest terminal rejected: verdict for ${env.run} review@${env.round} already landed at repo seq ${event.seq}`,
+      )
+    }
+    if (event.type === 'harvest.session.ended' && event.payload.session === env.session) {
+      throw new Error(
+        `harvest terminal rejected: session "${env.session}" already ended at repo seq ${event.seq}`,
+      )
+    }
+  }
+}
+
+async function readArtifactJson(
+  store: BuildStore,
+  repo: string,
+  kind: string,
+  rev: number,
+): Promise<unknown> {
+  const artifact = await store.getRepoArtifact(repo, kind, rev)
+  if (!artifact) throw new Error(`missing repository artifact ${kind}@${rev}`)
+  return JSON.parse(new TextDecoder().decode(artifact.content))
+}
+
+export async function buildHarvestContext(deps: HarvestCliDeps): Promise<HarvestContextManifest> {
+  const { store, env, workspacePath } = deps
+  const events = await store.getRepoEvents(env.repo)
+  const run = runForEnv(events, env)
+  const packet = await loadScanPacket(store, env.repo, run.scan)
+  const abDir = join(workspacePath, '.ab')
+  await wipeAbDir(abDir)
+
+  const materialized: string[] = []
+  const materialize = async (relative: string, value: unknown): Promise<void> => {
+    await writeJson(join(abDir, relative), value)
+    materialized.push(relative)
+  }
+
+  await materialize('observations.json', packet.observations)
+  await materialize('originating-tickets.json', packet.originatingTickets)
+  await materialize('ledger.json', packet.ledger)
+
+  const proposal = proposalArtifactForRound(run, env.round)
+  if (proposal !== undefined) {
+    await materialize(
+      'proposals.json',
+      await readArtifactJson(store, env.repo, proposal.kind, proposal.rev),
+    )
+  }
+
+  const priorReviews = run.reviews
+    .filter((review) => review.round < env.round)
+    .sort((a, b) => a.round - b.round)
+  for (const review of priorReviews) {
+    if (review.findings.length > 0) {
+      await materialize(`history/findings-r${review.round}.json`, review.findings)
+    }
+  }
+  if (env.phase === 'synthesize' && env.round > 1) {
+    const previous = [...run.reviews]
+      .reverse()
+      .find((review) => review.round === env.round - 1 && review.verdict === 'revise')
+    if (previous !== undefined) {
+      await materialize('findings.json', previous.findings)
+      const previousProposal = proposalArtifactForRound(run, env.round - 1)
+      if (previousProposal !== undefined && proposal === undefined) {
+        await materialize(
+          'proposals.json',
+          await readArtifactJson(store, env.repo, previousProposal.kind, previousProposal.rev),
+        )
+      }
+    }
+  }
+
+  const manifest: HarvestContextManifest = {
+    repo: env.repo,
+    run: env.run,
+    phase: env.phase,
+    round: env.round,
+    required: env.phase === 'synthesize' ? [HARVEST_PROPOSALS_ARTIFACT] : [HARVEST_REVIEW_ARTIFACT],
+    allowedTerminal: env.phase === 'synthesize' ? 'submit' : 'verdict',
+    materialized,
+  }
+  await writeJson(join(abDir, 'context.json'), manifest)
+  return manifest
+}
+
+async function readJsonFile(path: string): Promise<unknown> {
+  const file = Bun.file(path)
+  if (!(await file.exists())) throw new Error(`file not found: ${path}`)
+  try {
+    return JSON.parse(await file.text())
+  } catch (error) {
+    throw new Error(
+      `${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+    )
+  }
+}
+
+function validateJoinTargets(set: HarvestProposalSet, packet: HarvestScanPacket): void {
+  const allowed = new Set(packet.ledger.map((entry) => `${entry.ticket.source}:${entry.ticket.id}`))
+  for (const proposal of set.proposals) {
+    if (proposal.action !== 'join') continue
+    const key = `${proposal.ticket.source}:${proposal.ticket.id}`
+    if (!allowed.has(key)) {
+      throw new Error(
+        `join target ${key} was not supplied in the harvest ledger context — agents may only join a known prior proposal`,
+      )
+    }
+  }
+}
+
+export async function submitHarvestProposals(
+  deps: HarvestCliDeps,
+  file: string,
+): Promise<RepositoryEventEnvelope<'harvest.proposals.submitted'>> {
+  const { store, env } = deps
+  if (env.phase !== 'synthesize') {
+    throw new Error(
+      `'ab harvest submit' is only valid in synthesize@<round>; current phase is ${env.phase}@${env.round}`,
+    )
+  }
+  const events = await store.getRepoEvents(env.repo)
+  const run = runForEnv(events, env)
+  assertNoSessionTerminal(events, env)
+
+  const parsed = harvestProposalSetSchema.safeParse(await readJsonFile(file))
+  if (!parsed.success) {
+    throw new Error(`${file} does not match the harvest proposal schema: ${parsed.error.message}`)
+  }
+  const coverage = validateProposalCoverage(parsed.data, run.observations)
+  if (!coverage.ok) {
+    throw new Error(
+      `harvest proposals must cover every claimed observation exactly once: ${coverage.errors.join('; ')}`,
+    )
+  }
+  const packet = await loadScanPacket(store, env.repo, run.scan)
+  validateJoinTargets(parsed.data, packet)
+
+  const { event } = await store.appendRepoWithArtifacts(
+    env.repo,
+    [
+      {
+        kind: HARVEST_PROPOSALS_ARTIFACT,
+        content: `${JSON.stringify(parsed.data, null, 2)}\n`,
+        metadata: { run: env.run, round: env.round },
+      },
+    ],
+    (deposited) => ({
+      actor: agentActor('harvest', env.session),
+      type: 'harvest.proposals.submitted',
+      payload: {
+        run: env.run,
+        round: env.round,
+        artifact: {
+          kind: deposited[0]!.kind,
+          rev: deposited[0]!.revision,
+        },
+      },
+    }),
+  )
+  return event
+}
+
+const FINDINGS_SHAPE = z.array(findingDraftSchema)
+
+async function parseHarvestFindings(
+  deps: HarvestCliDeps,
+  file: string,
+  run: HarvestRunState,
+): Promise<Finding[]> {
+  const parsed = FINDINGS_SHAPE.safeParse(await readJsonFile(file))
+  if (!parsed.success) {
+    throw new Error(`${file} does not match the finding schema: ${parsed.error.message}`)
+  }
+  const known = new Set(
+    run.reviews
+      .filter((review) => review.round < deps.env.round)
+      .flatMap((review) => review.findings.map((finding) => finding.id)),
+  )
+  for (const finding of parsed.data) {
+    for (const id of finding.persists) {
+      if (!known.has(id)) {
+        throw new Error(`persists id "${id}" is not a finding from an earlier harvest review round`)
+      }
+    }
+  }
+  return parsed.data.map((finding) => ({ ...finding, id: deps.ids('hf') }))
+}
+
+export interface HarvestVerdictOpts {
+  verdict: string
+  notes: string
+  findings?: string
+  reason?: string
+}
+
+export async function submitHarvestVerdict(
+  deps: HarvestCliDeps,
+  opts: HarvestVerdictOpts,
+): Promise<RepositoryEventEnvelope<'harvest.review.verdict'>> {
+  const { store, env } = deps
+  if (env.phase !== 'review') {
+    throw new Error(
+      `'ab harvest verdict' is only valid in review@<round>; current phase is ${env.phase}@${env.round}`,
+    )
+  }
+  if (!['approve', 'revise', 'escalate'].includes(opts.verdict)) {
+    throw new Error(
+      `harvest verdict "${opts.verdict}" is invalid — expected approve | revise | escalate`,
+    )
+  }
+  const events = await store.getRepoEvents(env.repo)
+  const run = runForEnv(events, env)
+  assertNoSessionTerminal(events, env)
+  if (proposalArtifactForRound(run, env.round) === undefined) {
+    throw new Error(
+      `review@${env.round} has no proposal artifact to review — synthesize must submit first`,
+    )
+  }
+
+  const notesFile = Bun.file(opts.notes)
+  if (!(await notesFile.exists())) throw new Error(`--notes file not found: ${opts.notes}`)
+  const notes = await notesFile.text()
+  let findings: Finding[] = []
+  if (opts.verdict === 'revise') {
+    if (opts.findings === undefined) {
+      throw new Error(`'ab harvest verdict revise' requires --findings <json>`)
+    }
+    findings = await parseHarvestFindings(deps, opts.findings, run)
+    if (findings.length === 0) {
+      throw new Error(`'ab harvest verdict revise' requires at least one finding`)
+    }
+  } else if (opts.findings !== undefined) {
+    throw new Error(`--findings is only valid with the revise verdict`)
+  }
+  const reason = opts.reason?.trim()
+  if (opts.verdict === 'escalate' && !reason) {
+    throw new Error(`'ab harvest verdict escalate' requires --reason <text>`)
+  }
+
+  const { event } = await store.appendRepoWithArtifacts(
+    env.repo,
+    [
+      {
+        kind: HARVEST_REVIEW_ARTIFACT,
+        content: notes,
+        metadata: {
+          run: env.run,
+          round: env.round,
+          verdict: opts.verdict,
+        },
+      },
+    ],
+    (deposited) => ({
+      actor: agentActor('harvest-review', env.session),
+      type: 'harvest.review.verdict',
+      payload: {
+        run: env.run,
+        round: env.round,
+        verdict: opts.verdict as 'approve' | 'revise' | 'escalate',
+        findings,
+        artifact: {
+          kind: deposited[0]!.kind,
+          rev: deposited[0]!.revision,
+        },
+        ...(reason ? { reason } : {}),
+      },
+    }),
+  )
+  return event
+}
+
+export interface HarvestRecoveryStatus {
+  /** True only for an ordinary infrastructure stop the dispatcher may reopen. */
+  recoverable: boolean
+  /** Completed, escalated, and recovery-exhausted runs are genuinely terminal. */
+  finished: boolean
+  automatic: {
+    attempts: number
+    limit: number
+    exhausted: boolean
+  }
+  stopped?: {
+    step: NonNullable<HarvestRunState['failure']>['step']
+    round?: number
+  }
+  attention: {
+    required: boolean
+    acknowledged: boolean
+  }
+  pending: {
+    observations: Array<{ build: string; seq: number }>
+    proposalKeys: string[]
+  }
+}
+
+export interface HarvestFiledStatusView {
+  proposalKey: string
+  ticket: { source: string; id: string }
+  blockers?: { declared: string[]; derived: string[] }
+}
+
+export interface HarvestRunStatusView {
+  run: string
+  status: HarvestRunState['status']
+  startedSeq: number
+  startedAt: string
+  observations: number
+  trigger?: HarvestRunState['trigger']
+  steps: HarvestRunState['steps']
+  rounds: number
+  filed: HarvestFiledStatusView[]
+  escalation?: HarvestRunState['escalation']
+  failure?: HarvestRunState['failure']
+  recovery: HarvestRecoveryStatus
+}
+
+export interface HarvestStatusView {
+  repo: string
+  run?: string
+  /** Repository control takes display precedence while paused; runStatus keeps
+   * the primary run lifecycle queryable without making pause terminal. */
+  status: 'idle' | 'paused' | HarvestRunState['status']
+  runStatus?: HarvestRunState['status']
+  paused: boolean
+  pausedSeq?: number
+  pausedAt?: string
+  pendingCommands: HarvestPendingCommand[]
+  /** Every unresolved failed run plus all open runs and the latest historical
+   * summary, in durable start order and without duplicate entries. */
+  runs: HarvestRunStatusView[]
+  /** Backward-compatible primary-run fields. `runs` is authoritative when
+   * more than one workflow needs to be reported. */
+  observations: number
+  trigger?: HarvestRunState['trigger']
+  steps: HarvestRunState['steps']
+  rounds: number
+  filed: HarvestFiledStatusView[]
+  escalation?: HarvestRunState['escalation']
+  failure?: HarvestRunState['failure']
+  recovery: HarvestRecoveryStatus
+  events?: HarvestEvent[]
+}
+
+function projectRecovery(run: HarvestRunState | undefined): HarvestRecoveryStatus {
+  const exhaustion = run?.recoveryExhaustion
+  const attempts = run?.recoveryRequests.length ?? 0
+  const limit =
+    exhaustion?.limit ??
+    run?.recoveryRequests.at(-1)?.limit ??
+    DEFAULT_MAX_HARVEST_RECOVERY_ATTEMPTS
+  const stopped = run?.failure
+  return {
+    recoverable: run?.status === 'failed' && exhaustion === undefined,
+    finished:
+      run?.status === 'completed' || run?.status === 'escalated' || exhaustion !== undefined,
+    automatic: {
+      attempts,
+      limit,
+      exhausted: exhaustion !== undefined,
+    },
+    ...(stopped !== undefined
+      ? {
+          stopped: {
+            step: stopped.step,
+            ...(stopped.round !== undefined ? { round: stopped.round } : {}),
+          },
+        }
+      : {}),
+    attention: {
+      required: exhaustion !== undefined && exhaustion.attentionAcknowledgedSeq === undefined,
+      acknowledged: exhaustion?.attentionAcknowledgedSeq !== undefined,
+    },
+    pending: {
+      // Before give-up the immutable claimed snapshot is the exact retained
+      // work. Exhaustion classifies it atomically, after which only the
+      // selectively released subset remains pending.
+      observations: structuredClone(
+        exhaustion?.releasedObservations ?? (run?.status === 'failed' ? run.observations : []),
+      ),
+      proposalKeys: exhaustion?.pendingProposals.map((proposal) => proposal.proposalKey) ?? [],
+    },
+  }
+}
+
+function projectHarvestRunStatus(run: HarvestRunState): HarvestRunStatusView {
+  return {
+    run: run.run,
+    status: run.status,
+    startedSeq: run.startedSeq,
+    startedAt: run.startedAt,
+    observations: run.observations.length,
+    ...(run.trigger !== undefined ? { trigger: run.trigger } : {}),
+    steps: run.steps,
+    rounds: Math.max(0, ...run.reviews.map((review) => review.round)),
+    filed: run.filed.map((entry) => ({
+      proposalKey: entry.proposalKey,
+      ticket: { source: entry.ticket.source, id: entry.ticket.id },
+      ...(entry.blockers !== undefined ? { blockers: structuredClone(entry.blockers) } : {}),
+    })),
+    ...(run.escalation !== undefined ? { escalation: run.escalation } : {}),
+    ...(run.failure !== undefined ? { failure: run.failure } : {}),
+    recovery: projectRecovery(run),
+  }
+}
+
+export function projectHarvestStatus(
+  repo: string,
+  events: RepositoryEvent[],
+  newestEvents?: number,
+): HarvestStatusView {
+  const state = reduceHarvest(events)
+  const history =
+    newestEvents === undefined ? undefined : events.filter(isHarvestEvent).slice(-newestEvents)
+  const unresolved = [...parkedHarvestRuns(state), ...unresolvedHarvestAttentionRuns(state)]
+  const open = openHarvestRuns(state)
+  const included = new Set(
+    [...unresolved, ...open, ...(state.latest ? [state.latest] : [])].map((run) => run.run),
+  )
+  const runs = state.runs.filter((run) => included.has(run.run)).map(projectHarvestRunStatus)
+  const unresolvedIds = new Set(unresolved.map((run) => run.run))
+  const primary =
+    runs.find((run) => unresolvedIds.has(run.run)) ??
+    runs.find((run) => run.status === 'running') ??
+    runs.at(-1)
+
+  const control = {
+    paused: state.paused,
+    ...(state.pausedSeq !== undefined ? { pausedSeq: state.pausedSeq } : {}),
+    ...(state.pausedAt !== undefined ? { pausedAt: state.pausedAt } : {}),
+    pendingCommands: state.pendingCommands,
+    runs,
+    ...(history !== undefined ? { events: history } : {}),
+  }
+  if (primary === undefined) {
+    return {
+      repo,
+      status: state.paused ? 'paused' : 'idle',
+      ...control,
+      observations: 0,
+      steps: [],
+      rounds: 0,
+      filed: [],
+      recovery: projectRecovery(undefined),
+    }
+  }
+
+  const { status: runStatus, startedSeq: _startedSeq, startedAt: _startedAt, ...summary } = primary
+  return {
+    repo,
+    status: state.paused ? 'paused' : runStatus,
+    runStatus,
+    ...control,
+    ...summary,
+  }
+}
+
+function renderHarvestRunStatus(run: HarvestRunStatusView, paused: boolean): string[] {
+  const displayStatus = paused ? 'paused' : run.status
+  const lines = [
+    `harvest ${run.run} — ${displayStatus}${paused ? ` (run ${run.status})` : ''}`,
+    `observations: ${run.observations}`,
+    ...(run.trigger !== undefined ? [`trigger: ${run.trigger}`] : []),
+    `review rounds: ${run.rounds}`,
+    'steps:',
+  ]
+  for (const step of run.steps) {
+    lines.push(
+      `  ${step.step}${step.round !== undefined ? ` r${step.round}` : ''}: ` +
+        `${step.outcome ?? (step.completedSeq === undefined ? 'running' : 'done')}`,
+    )
+  }
+  if (run.recovery.stopped !== undefined) {
+    lines.push(
+      `stopped at: ${run.recovery.stopped.step}${
+        run.recovery.stopped.round !== undefined ? ` r${run.recovery.stopped.round}` : ''
+      }`,
+    )
+  }
+  if (
+    run.recovery.recoverable ||
+    run.recovery.automatic.attempts > 0 ||
+    run.recovery.automatic.exhausted
+  ) {
+    lines.push(
+      `automatic recovery: ${run.recovery.automatic.attempts}/${run.recovery.automatic.limit}${
+        run.recovery.automatic.exhausted
+          ? ' exhausted'
+          : run.recovery.recoverable
+            ? ' available'
+            : ' resumed'
+      }`,
+    )
+  }
+  const observations = run.recovery.pending.observations.map(
+    (occurrence) => `${occurrence.build}:${occurrence.seq}`,
+  )
+  const proposals = run.recovery.pending.proposalKeys
+  if (observations.length > 0 || proposals.length > 0) {
+    lines.push(
+      `pending: ${observations.length} observation${observations.length === 1 ? '' : 's'}` +
+        `${observations.length > 0 ? ` (${observations.join(', ')})` : ''}` +
+        `${proposals.length > 0 ? `; proposals ${proposals.join(', ')}` : ''}`,
+    )
+  }
+  if (run.recovery.automatic.exhausted) {
+    lines.push(
+      run.recovery.attention.required
+        ? 'attention: human acknowledgement required'
+        : 'attention: acknowledged',
+    )
+  }
+  if (run.escalation) lines.push(`escalation: ${run.escalation.reason}`)
+  if (run.failure) lines.push(`failure: ${run.failure.error}`)
+  if (run.filed.length > 0) {
+    lines.push('filed:')
+    for (const entry of run.filed) {
+      lines.push(`  ${entry.proposalKey} -> ${entry.ticket.source}:${entry.ticket.id}`)
+      if (entry.blockers !== undefined) {
+        lines.push(
+          `    declared blockers: ${entry.blockers.declared.join(', ') || 'none'}`,
+          `    originating blockers: ${entry.blockers.derived.join(', ') || 'none'}`,
+        )
+      }
+    }
+  }
+  return lines
+}
+
+export function renderHarvestStatus(view: HarvestStatusView): string[] {
+  if (view.runs.length === 0) {
+    const lines = [
+      `harvest ${view.repo}: ${view.status === 'paused' ? 'paused' : 'idle'} (no runs)`,
+    ]
+    if (view.pendingCommands.length > 0) {
+      lines.push(
+        `control pending: ${view.pendingCommands.map((command) => command.command).join(', ')}`,
+      )
+    }
+    if (view.events !== undefined) {
+      lines.push('events:')
+      for (const event of view.events) {
+        lines.push(`  ${event.seq} ${event.ts} ${event.type}`)
+      }
+    }
+    return lines
+  }
+
+  const lines: string[] = []
+  for (const run of view.runs) {
+    if (lines.length > 0) lines.push('')
+    lines.push(...renderHarvestRunStatus(run, view.paused))
+  }
+  if (view.pendingCommands.length > 0) {
+    lines.splice(
+      1,
+      0,
+      `control pending: ${view.pendingCommands.map((command) => command.command).join(', ')}`,
+    )
+  }
+  if (view.events !== undefined) {
+    lines.push('events:')
+    for (const event of view.events) {
+      lines.push(`  ${event.seq} ${event.ts} ${event.type}`)
+    }
+  }
+  return lines
+}
+
+export interface HarvestStatusOpts {
+  /** Current directory; normalized to the main checkout before journal reads. */
+  repo: string
+  env: Record<string, string | undefined>
+  exec: Exec
+  stdout: (line: string) => void
+  storeRef?: string
+  json?: boolean
+  events?: number
+  /** Injectable store seam for command tests. */
+  openStore?: StoreOpener
+}
+
+export async function abHarvestStatus(opts: HarvestStatusOpts): Promise<void> {
+  await withSessionlessStore(
+    {
+      targetRepo: opts.repo,
+      env: opts.env,
+      exec: opts.exec,
+      ...(opts.storeRef !== undefined ? { storeRef: opts.storeRef } : {}),
+      ...(opts.openStore !== undefined ? { openStore: opts.openStore } : {}),
+    },
+    async ({ store, repo }) => {
+      const record = await store.getRepo(repo)
+      const events = record === null ? [] : await store.getRepoEvents(repo)
+      const view = projectHarvestStatus(repo, events, opts.events)
+      if (opts.json === true) opts.stdout(JSON.stringify(view, null, 2))
+      else for (const line of renderHarvestStatus(view)) opts.stdout(line)
+    },
+  )
+}