@defrex/autobuild 0.10.1 → 0.12.0

package/packages/core/src/store/remote/compatibility.ts

@@ -0,0 +1,90 @@
+import semver from 'semver'
+import { z } from 'zod'
+import { AUTOBUILD_VERSION, REMOTE_STORE_PROTOCOL_VERSION } from './version'
+
+/** Stable releases only: prefixes, whitespace, prereleases and build suffixes are not identities. */
+export function stableVersion(value: unknown): semver.SemVer | undefined {
+  if (typeof value !== 'string' || !/^\d+\.\d+\.\d+$/.test(value)) return undefined
+  const parsed = semver.parse(value)
+  return parsed && parsed.version === value ? parsed : undefined
+}
+
+const stableVersionSchema = z.string().refine((value) => stableVersion(value) !== undefined)
+export const supportedClientRangeSchema = z
+  .strictObject({
+    minVersion: stableVersionSchema,
+    maxVersionExclusive: stableVersionSchema,
+  })
+  .refine((range) => semver.lt(range.minVersion, range.maxVersionExclusive))
+export type SupportedClientRange = z.infer<typeof supportedClientRangeSchema>
+
+/** A major starts a new family: X.0 has one line, X.1 two, X.2+ three. */
+export function supportedClientRange(serviceVersion = AUTOBUILD_VERSION): SupportedClientRange {
+  const version = stableVersion(serviceVersion)
+  if (!version) throw new Error('service must have a stable release version')
+  return {
+    minVersion: `${version.major}.${Math.max(0, version.minor - 2)}.0`,
+    maxVersionExclusive: `${version.major}.${version.minor + 1}.0`,
+  }
+}
+
+export function classifyClient(
+  version: unknown,
+  range: SupportedClientRange,
+): 'supported' | 'older' | 'newer' | 'invalid' {
+  const parsed = stableVersion(version)
+  if (!parsed) return 'invalid'
+  if (semver.lt(parsed, range.minVersion)) return 'older'
+  if (semver.gte(parsed, range.maxVersionExclusive)) return 'newer'
+  return 'supported'
+}
+
+export function formatClientRange(range: SupportedClientRange): string {
+  return `>=${range.minVersion} <${range.maxVersionExclusive}`
+}
+
+export function compatibilityAdvice(
+  client: unknown,
+  serviceVersion: string,
+  range: SupportedClientRange,
+): string | undefined {
+  const classification = classifyClient(client, range)
+  const description = `service Autobuild ${serviceVersion} supports clients ${formatClientRange(range)}`
+  if (classification === 'supported') return undefined
+  if (classification === 'newer') {
+    const version = stableVersion(client)!
+    return `${description}; upgrade the service to at least ${version.major}.${version.minor}.0 before upgrading projects (service first)`
+  }
+  if (classification === 'older')
+    return `${description}; upgrade the project's Autobuild into ${formatClientRange(range)}`
+  return `${description}; supply a stable Autobuild client version`
+}
+
+/** Retain these wire identities and handlers until their lines leave the window.
+ * Historical lines require explicit entries; the service's own line uses its
+ * current protocol identity. Unknown historical protocols fail closed. */
+export const RELEASE_LINE_PROTOCOLS: Readonly<Record<string, string>> = {
+  '0.9': '3',
+  '0.10': '3',
+  '0.11': '3',
+  '0.12': '3',
+}
+
+export function clientIdentityError(
+  client: string | null,
+  protocol: string | null,
+  serviceVersion = AUTOBUILD_VERSION,
+  serviceProtocol = REMOTE_STORE_PROTOCOL_VERSION,
+): string | undefined {
+  const range = supportedClientRange(serviceVersion)
+  const service = stableVersion(serviceVersion)!
+  const advice = compatibilityAdvice(client, serviceVersion, range)
+  const parsed = stableVersion(client)
+  const expected =
+    parsed &&
+    (parsed.major === service.major && parsed.minor === service.minor
+      ? serviceProtocol
+      : RELEASE_LINE_PROTOCOLS[`${parsed.major}.${parsed.minor}`])
+  if (!advice && expected !== undefined && protocol === expected) return undefined
+  return `remote store version mismatch: client Autobuild ${client ?? '(missing)'} protocol ${protocol ?? '(missing)'}; server Autobuild ${serviceVersion} protocol ${serviceProtocol}; ${advice ?? `supported clients ${formatClientRange(range)}; unsupported protocol identity`}`
+}

package/packages/core/src/store/remote/credentials.ts

@@ -0,0 +1,28 @@
+import { delegateCredentialResponseSchema, type DelegateCredentialTarget } from './protocol'
+import {
+  AUTOBUILD_VERSION,
+  AUTOBUILD_VERSION_HEADER,
+  REMOTE_STORE_PROTOCOL_VERSION,
+  REMOTE_STORE_PROTOCOL_VERSION_HEADER,
+} from './version'
+
+/** Fail closed: a remote execution must never fall back to its parent token. */
+export async function delegateCredential(
+  storeRef: string,
+  token: string | undefined,
+  target: DelegateCredentialTarget,
+): Promise<string> {
+  if (!token) throw new Error('credential delegation requires parent authority')
+  const response = await fetch(`${storeRef.replace(/\/$/, '')}/credentials/delegate`, {
+    method: 'POST',
+    headers: {
+      authorization: `Bearer ${token}`,
+      'content-type': 'application/json',
+      [AUTOBUILD_VERSION_HEADER]: AUTOBUILD_VERSION,
+      [REMOTE_STORE_PROTOCOL_VERSION_HEADER]: REMOTE_STORE_PROTOCOL_VERSION,
+    },
+    body: JSON.stringify(target),
+  })
+  if (!response.ok) throw new Error(`credential delegation refused (${response.status})`)
+  return delegateCredentialResponseSchema.parse(await response.json()).token
+}

package/packages/core/src/store/remote/index.ts

@@ -4,7 +4,13 @@
 export { AuthError, RemoteBuildStore } from './client'
 export type { RemoteBuildStoreOptions, RemoteStoreIdentity } from './client'
 export { mintToken, tokenResource, verifyToken } from './token'
-export type { OperatorTokenScope, TokenScope } from './token'
+export type {
+  OperatorTokenScope,
+  InternalOperatorTokenScope,
+  AdminTokenScope,
+  TokenScope,
+  DelegatedTokenScope,
+} from './token'
 export {
   AUTOBUILD_VERSION,
   AUTOBUILD_VERSION_HEADER,
@@ -22,3 +28,10 @@ export type { SessionEvent, SessionEventWrite } from '../../events/sessions'
 export type { RepositoryEvent, RepositoryEventWrite } from '../../events/repository'
 export { SNAPSHOT_REDUCER_NAME } from '../snapshots'
 export type { ReducerSnapshot, SnapshotScope } from '../snapshots'
+
+export * from './compatibility'
+
+export { delegateCredential } from './credentials'
+
+export { reduceBuild } from '../../kernel/reducer'
+export { reduceHarvest } from '../../kernel/harvest'

package/packages/core/src/store/remote/protocol.ts

@@ -285,6 +285,7 @@ export const buildDigestWireSchema = z.object({
     }),
   ),
   merged: z.string().min(1).optional(),
+  readinessChangeSeq: z.number().int().positive().optional(),
   reclaimPending: z.literal(true).optional(),
   executionOpen: z.literal(true).optional(),
 })
@@ -449,3 +450,28 @@ export function substitutePlaceholderRefs(
   }
   return value
 }
+
+/** Issuance is an authentication operation, separate from the BuildStore port. */
+export const delegateCredentialBodySchema = z.discriminatedUnion('kind', [
+  z.strictObject({ kind: z.literal('build-runner'), id: z.string().min(1) }),
+  z.strictObject({
+    kind: z.literal('build-phase'),
+    id: z.string().min(1),
+    session: z.string().min(1),
+  }),
+  z.strictObject({
+    kind: z.literal('harvest-runner'),
+    execution: z.string().min(1),
+    repo: z.string().min(1),
+    id: z.string().min(1),
+    leaseHolder: z.string().min(1),
+  }),
+  z.strictObject({
+    kind: z.literal('harvest-phase'),
+    repo: z.string().min(1),
+    id: z.string().min(1),
+    session: z.string().min(1),
+  }),
+])
+export type DelegateCredentialTarget = z.infer<typeof delegateCredentialBodySchema>
+export const delegateCredentialResponseSchema = z.strictObject({ token: z.string().min(1) })

package/packages/core/src/store/remote/token.ts

@@ -1,13 +1,7 @@
-/**
- * HMAC-scoped store tokens (SPEC §8.1 [D8]): "the token is scoped to this
- * build and session — an agent physically cannot append to another build's
- * log or read another build's artifacts". Least privilege comes from the
- * runner minting a narrow token, not from prompt instructions.
- *
- * A token is `base64url(JSON scope) + '.' + base64url(hmac-sha256(secret,
- * payload))`. The scope IS the token — the server keeps no session state;
- * it verifies the signature (timing-safe) and the expiry, then trusts the
- * embedded scope.
+/** Signed lifecycle-bound execution grants, internal owner delegation and admin.
+ * Historical resource/deployment/operator scopes remain decodable for tests
+ * and migration diagnostics; hosted machine gates reject those retired forms.
+ * Project credentials are opaque stored secrets, not these stateless tokens.
  */
 import { createHmac, timingSafeEqual } from 'node:crypto'
 import { z } from 'zod'
@@ -52,8 +46,35 @@ export interface DeploymentTokenScope {
   exp: number
 }
 
-/** Legacy scopes remain valid on their existing routes. */
+/** Includes retired wire shapes for recognition, never server authorization. */
+export interface InternalOperatorTokenScope {
+  version: 1
+  internalOperator: { user: string; repo: string }
+  exp: number
+  via?: Via
+}
+export interface AdminTokenScope {
+  version: 1
+  ownerAdmin: { user: string }
+  exp: number
+}
+export interface DelegatedTokenScope {
+  version: 2
+  delegation: {
+    repo: string
+    kind: 'build-runner' | 'build-phase' | 'harvest-runner' | 'harvest-phase'
+    id: string
+    anchor: number
+    session?: string
+    execution?: string
+    leaseHolder?: string
+  }
+}
+
 export type TokenScope =
+  | DelegatedTokenScope
+  | InternalOperatorTokenScope
+  | AdminTokenScope
   | LegacyBuildTokenScope
   | ResourceTokenScope
   | OperatorTokenScope
@@ -63,7 +84,38 @@ const commonScope = {
   session: z.string().min(1),
   exp: z.number().int(),
 }
+const exactIdentity = z
+  .string()
+  .min(1)
+  .refine((value) => value !== '*')
+const delegatedClaims = z
+  .strictObject({
+    repo: exactIdentity,
+    kind: z.enum(['build-runner', 'build-phase', 'harvest-runner', 'harvest-phase']),
+    id: exactIdentity,
+    anchor: z.number().int().positive(),
+    session: exactIdentity.optional(),
+    execution: exactIdentity.optional(),
+    leaseHolder: exactIdentity.optional(),
+  })
+  .refine(
+    (claims) =>
+      claims.kind.endsWith('-phase') === (claims.session !== undefined) &&
+      claims.kind.startsWith('harvest') === (claims.execution !== undefined),
+  )
 const tokenScopeSchema = z.union([
+  z.strictObject({ version: z.literal(2), delegation: delegatedClaims }),
+  z.strictObject({
+    version: z.literal(1),
+    internalOperator: z.strictObject({ user: z.string().trim().min(1), repo: z.string().min(1) }),
+    exp: z.number().int(),
+    via: viaSchema.optional(),
+  }),
+  z.strictObject({
+    version: z.literal(1),
+    ownerAdmin: z.strictObject({ user: z.string().trim().min(1) }),
+    exp: z.number().int(),
+  }),
   z.strictObject({ build: z.string().min(1), ...commonScope }),
   z.strictObject({
     resource: z.strictObject({
@@ -85,6 +137,13 @@ export function tokenResource(scope: TokenScope): {
   kind: 'build' | 'repo' | 'session' | 'admin' | 'operator' | 'deployment'
   id: string
 } {
+  if ('delegation' in scope)
+    return {
+      kind: scope.delegation.kind.startsWith('build') ? 'build' : 'repo',
+      id: scope.delegation.kind.startsWith('build') ? scope.delegation.id : scope.delegation.repo,
+    }
+  if ('ownerAdmin' in scope) return { kind: 'admin', id: '*' }
+  if ('internalOperator' in scope) return { kind: 'operator', id: scope.internalOperator.user }
   if ('operator' in scope) {
     return scope.operator === true
       ? { kind: 'deployment', id: '*' }
@@ -108,7 +167,9 @@ export function mintToken(secret: string, scope: TokenScope): string {
 /**
  * Bad signature, malformed token, unparseable scope, or expired → null —
  * verification never explains itself to the caller (the server maps null to
- * 401). The signature compare is timing-safe via `crypto.timingSafeEqual`.
+ * 401). Version-2 grants deliberately have no fixed expiration: the service
+ * must additionally validate their registered project and durable lifecycle.
+ * The signature compare is timing-safe via `crypto.timingSafeEqual`.
  */
 export function verifyToken(secret: string, token: string, now: Date): TokenScope | null {
   const parts = token.split('.')
@@ -132,6 +193,6 @@ export function verifyToken(secret: string, token: string, now: Date): TokenScop
   }
   const scope = tokenScopeSchema.safeParse(raw)
   if (!scope.success) return null
-  if (scope.data.exp <= now.getTime()) return null
+  if ('exp' in scope.data && scope.data.exp <= now.getTime()) return null
   return scope.data
 }

package/packages/core/src/store/repo-state-events.ts

@@ -1,54 +1,12 @@
-/**
- * The bounded repository-journal read (AUT-489): a pure subset derivation
- * that stateless full-state readers can fetch instead of the whole journal
- * without changing what their reducers report.
- *
- * The hosted dispatcher appends ~4 journal events per invocation (run-started,
- * tick-started, tick-completed/tick-yielded, run-stopped) whether or not it
- * did anything, so the journal grows forever with wall-clock time while the
- * durable signal stays small. Every repository-state consumer reduces the
- * journal through one of four pure reducers whose event-type dependencies
- * partition the catalog:
- *
- * - `reduceDispatchSettings` — only the three dispatcher setting types
- *   (latest-wins by seq).
- * - `reduceDispatchStatus(events, latestRun)` — only run-correlated
- *   dispatcher facts, and it skips every event whose `payload.run` is not the
- *   latest run. A run's facts are appended under its own run id, which is
- *   minted at `dispatcher.run-started`, so all facts the reducer keeps live at
- *   or after the latest run-started.
- * - `reduceHarvest` (and everything built on it) — only `harvest.*` events
- *   plus the three setting types, which it explicitly ignores.
- * - `sandboxStates` — only `orchestrator.sandbox.*` events.
- *
- * So the bounded subset is: **every event of a durable (slow-growing) type —
- * all `harvest.*`, all `orchestrator.sandbox.*`, and the three dispatcher
- * setting types — plus, when the journal contains at least one
- * `dispatcher.run-started`, the tail from that latest run-started to the end
- * of the journal.** For a hosted repository with N no-op invocations this
- * subset's size is a constant (one invocation's ~4 facts plus the durable
- * signal), independent of N.
- *
- * INVARIANT FOR AUTHORS OF NEW REPOSITORY EVENT TYPES: a new type must either
- * (a) join `REPOSITORY_STATE_EVENT_TYPES` — it is durable, slow-growing state
- * some reducer depends on at full replay depth — or (b) join
- * `REPOSITORY_RUN_SCOPED_EVENT_TYPES` — it is run-correlated and its only
- * consumers reduce it for the latest run, so the tail from the latest
- * `dispatcher.run-started` covers it. `tests/store/repo-state-events.test.ts`
- * asserts the two sets exactly partition `REPOSITORY_EVENT_TYPES`; adding a
- * type to neither fails the build until the author makes the call. A type in
- * neither set would be silently dropped from bounded reads.
- *
- * Reducing this subset with the state readers yields exactly what a full
- * replay yields: `reduceDispatchSettings`, `reduceHarvest`, `sandboxStates`
- * see identical event lists, and `reduceDispatchStatus` sees every event it
- * keeps (the rest are skipped by the `payload.run !== latestRun` guard). The
- * journal itself stays append-only; no event is deleted, rewritten, or
- * re-ordered, and a replay from the start is untouched.
+/** Bounded journal state has three disjoint, exhaustive categories:
+ * durable facts retain all history; run-scoped facts retain the latest run
+ * tail; latest-only facts retain exactly the greatest sequence per type,
+ * including before any run anchor. The full journal remains append-only.
  */
 import type { RepositoryEvent, RepositoryEventType } from '../events/repository'
 import { defineReducer, type IncrementalReducer } from '../kernel/incremental'
 import {
+  ticketSourceHealthEventPayloadSchemas,
   dispatcherSettingEventPayloadSchemas,
   dispatcherStatusEventPayloadSchemas,
   harvestEventPayloadSchemas,
@@ -64,6 +22,7 @@ const RUN_STARTED = 'dispatcher.run-started'
  * setting types are enumerated because they share one schema group with the
  * run-correlated `dispatcher.config-reloaded`. */
 export const REPOSITORY_STATE_EVENT_TYPES: readonly RepositoryEventType[] = [
+  ...Object.keys(ticketSourceHealthEventPayloadSchemas),
   ...Object.keys(harvestEventPayloadSchemas),
   ...Object.keys(orchestratorSandboxEventPayloadSchemas),
   ...Object.keys(dispatcherSettingEventPayloadSchemas).filter(
@@ -71,11 +30,19 @@ export const REPOSITORY_STATE_EVENT_TYPES: readonly RepositoryEventType[] = [
   ),
 ] as RepositoryEventType[]
 
+/** Latest-only measurements survive run turnover without retaining scan history. */
+export const REPOSITORY_LATEST_EVENT_TYPES: readonly RepositoryEventType[] = [
+  'dispatcher.ticket-scan-completed',
+]
+const LATEST_TYPES = new Set<string>(REPOSITORY_LATEST_EVENT_TYPES)
+
 /** Run-correlated repository event types: facts whose only state consumers
  * reduce them for the latest dispatcher run, so the tail from the latest
  * `dispatcher.run-started` contains everything those consumers keep. */
 export const REPOSITORY_RUN_SCOPED_EVENT_TYPES: readonly RepositoryEventType[] = [
-  ...Object.keys(dispatcherStatusEventPayloadSchemas),
+  ...Object.keys(dispatcherStatusEventPayloadSchemas).filter(
+    (type) => !REPOSITORY_LATEST_EVENT_TYPES.includes(type as RepositoryEventType),
+  ),
   'dispatcher.config-reloaded',
 ] as RepositoryEventType[]
 
@@ -122,8 +89,8 @@ export async function readRepoStateEventsWithAnchorRecheck(
 }
 
 /** Carried state for the bounded read: the latest run-started seq (the last
- * in array order, as the whole-array pass overwrites it) and every event seen,
- * in array order. Nothing is pruned: a later run-started may carry a lower seq
+ * in array order, as the whole-array pass overwrites it) and every ordinary event seen,
+ * in array order, plus one latest-only fact per type. Ordinary history is retained: a later run-started may carry a lower seq
  * than an earlier one and restore events below the earlier anchor, so only
  * `finish` can apply the filter exactly. Pruning below a monotone anchor is
  * valid only for seq-ordered input and belongs with the cached-state
@@ -134,10 +101,11 @@ export interface RepositoryStateEventsAcc {
 }
 
 /** Bump when `RepositoryStateEventsAcc` or its fold changes. */
-export const REPOSITORY_STATE_EVENTS_REDUCER_VERSION = 1
+export const REPOSITORY_STATE_EVENTS_REDUCER_VERSION = 4
 
 const keeps = (event: RepositoryEvent, anchor: number | undefined): boolean =>
-  STATE_TYPES.has(event.type) || (anchor !== undefined && event.seq >= anchor)
+  STATE_TYPES.has(event.type) ||
+  (!LATEST_TYPES.has(event.type) && anchor !== undefined && event.seq >= anchor)
 
 export const repositoryStateEventsReducer: IncrementalReducer<
   RepositoryStateEventsAcc,
@@ -149,10 +117,24 @@ export const repositoryStateEventsReducer: IncrementalReducer<
   fold(acc, events) {
     for (const event of events) {
       if (event.type === RUN_STARTED) acc.anchor = event.seq
+      if (LATEST_TYPES.has(event.type)) {
+        const held = acc.retained.find((held) => held.type === event.type)
+        if (held !== undefined && held.seq >= event.seq) continue
+        acc.retained = acc.retained.filter((held) => held.type !== event.type)
+      }
       acc.retained.push(event)
     }
   },
-  finish: (acc) => acc.retained.filter((event) => keeps(event, acc.anchor)),
+  finish: (acc) => {
+    const latest = new Map<string, RepositoryEvent>()
+    for (const event of acc.retained) {
+      if (LATEST_TYPES.has(event.type) && event.seq > (latest.get(event.type)?.seq ?? -1))
+        latest.set(event.type, event)
+    }
+    return [...acc.retained.filter((event) => keeps(event, acc.anchor)), ...latest.values()].sort(
+      (a, b) => a.seq - b.seq,
+    )
+  },
 })
 
 /** Carried state for the pruned journal view: the latest run-started seq and
@@ -167,16 +149,23 @@ export interface JournalViewAcc {
 }
 
 /** Bump when `JournalViewAcc` or its fold changes. */
-export const JOURNAL_VIEW_REDUCER_VERSION = 1
+export const JOURNAL_VIEW_REDUCER_VERSION = 4
 
 /** Fold seq-ordered events into a journal view in place. */
 export function foldJournalView(acc: JournalViewAcc, events: readonly RepositoryEvent[]): void {
   for (const event of events) {
     if (event.type === RUN_STARTED) {
       acc.anchor = event.seq
-      acc.retained = acc.retained.filter((held) => STATE_TYPES.has(held.type))
+      acc.retained = acc.retained.filter(
+        (held) => STATE_TYPES.has(held.type) || LATEST_TYPES.has(held.type),
+      )
     }
-    if (STATE_TYPES.has(event.type) || acc.anchor !== undefined) acc.retained.push(event)
+    if (LATEST_TYPES.has(event.type)) {
+      const held = acc.retained.find((held) => held.type === event.type)
+      if (held !== undefined && held.seq >= event.seq) continue
+      acc.retained = acc.retained.filter((held) => held.type !== event.type)
+      acc.retained.push(event)
+    } else if (STATE_TYPES.has(event.type) || acc.anchor !== undefined) acc.retained.push(event)
   }
 }
 
@@ -193,9 +182,10 @@ export const journalViewReducer: IncrementalReducer<
 
 /** The normative subset derivation every adapter implements and the contract
  * tests use as the oracle: durable types across the whole journal, plus —
- * only when the journal has one — every event from the latest
- * `dispatcher.run-started` onward, ordered by seq. A journal with no
- * run-started has **no tail at all** (durable types only); the anchor is
+ * only when the journal has one — every non-latest-only event from the latest
+ * `dispatcher.run-started` onward, plus the maximum-sequence fact of each
+ * latest-only type across the whole journal, ordered by seq. A journal with no
+ * run-started has **no tail at all** (durable and latest-only facts only); the anchor is
  * never defaulted to 0, which would make a `seq >= anchor` clause select the
  * whole journal and defeat the bound. */
 export function projectRepositoryStateEvents(

package/packages/core/src/store/types.ts

@@ -105,6 +105,8 @@ export interface ArtifactMeta {
  * the event log on each call, so the log stays the sole authority and the
  * digest can always be discarded and rebuilt. */
 export interface BuildDigest {
+  /** Latest merge, completion or abort fact sequence. */
+  readinessChangeSeq?: number
   slug: string
   terminal?: 'done' | 'aborted'
   /** Ascending-seq `{seq, ts}` pairs for every `observation.recorded` in the
@@ -368,7 +370,9 @@ export interface BuildStore {
   ): Promise<RepositoryEvent[]>
   /** Bounded repository-journal read for stateless full-state readers
    * (AUT-489): every durable fact (REPOSITORY_STATE_EVENT_TYPES) plus — when
-   * the journal has one — the tail from the latest `dispatcher.run-started`.
+   * the journal has one — the tail from the latest `dispatcher.run-started`,
+   * excluding latest-only types; plus exactly the maximum-sequence fact for
+   * each REPOSITORY_LATEST_EVENT_TYPES type across the whole journal.
    * Reducing this subset with the state readers yields exactly what a full
    * replay yields (`projectRepositoryStateEvents` is the normative oracle).
    * Unknown repo rejects like `getRepoEvents`. */

package/packages/core/src/testing/index.ts

@@ -57,3 +57,10 @@ export {
   type E2eHarness,
   type SkillHandlers,
 } from '../integration/harness'
+
+// Harvest lifecycle and CLI seams for delegated-credential integration tests.
+export { HarvestRunner } from '../processes/harvest-runner'
+export { resolveHarvestCliEnv } from '../cli/env'
+export { buildHarvestContext, submitHarvestProposals, submitHarvestVerdict } from '../cli/harvest'
+export { abConnect, abDisconnect } from '../cli/connect'
+export { ProjectCredentials } from '../cli/project-credentials'