@defrex/autobuild 0.12.0 → 0.14.0

package/packages/core/src/cli/dispatcher-liveness.ts

@@ -1,30 +1,30 @@
+import { readRepositoryFacts, readDispatcherRunFacts } from '../store/reduced-reads'
 import type { RepositoryEvent } from '../events/repository'
 import type { BuildStore, RepositoryRecord } from '../store/types'
 import { formatDispatcherIdentity, projectDispatcherLiveness } from '../kernel/dispatcher-liveness'
 
-/** Bounded first; a later yielding invocation can hide the owner's identity or
- * an earlier stop. Only this correlation query falls back to full history. */
+/** Correlate only the latest, stopped and lease-holder runs through persisted values. */
 export async function readDispatcherLiveness(
   store: BuildStore,
   repo: string,
   now = new Date(),
-  subset?: RepositoryEvent[],
+  _subset?: RepositoryEvent[],
 ) {
   const record = await store.getRepo(repo)
-  let events = record === null ? [] : (subset ?? (await store.getRepoStateEvents(repo)))
-  const bounded = projectDispatcherLiveness(record, events, now)
-  if (
-    record &&
-    ((record.lease &&
-      !events.some(
-        (e) => e.type === 'dispatcher.run-started' && e.payload.run === record.lease!.holder,
-      )) ||
-      (bounded.state !== 'held' &&
-        events.some((e) => e.type === 'dispatcher.run-started') &&
-        !events.some((e) => e.type === 'dispatcher.run-stopped')))
-  ) {
-    events = await store.getRepoEvents(repo)
-  }
+  const facts = record === null ? undefined : (await readRepositoryFacts(store, repo)).value
+  const runs = new Set(
+    [facts?.latestRun, facts?.latestStoppedRun, record?.lease?.holder].filter(
+      (run): run is string => run !== undefined,
+    ),
+  )
+  const correlations = await Promise.all(
+    [...runs].map(async (run) => (await readDispatcherRunFacts(store, repo, run)).value),
+  )
+  const events = correlations.flatMap((run) =>
+    [run.start, run.latestStart, run.stop, run.tick].filter(
+      (event): event is RepositoryEvent => event !== undefined,
+    ),
+  )
   return { record, events, dispatcher: projectDispatcherLiveness(record, events, now) }
 }
 
@@ -39,6 +39,10 @@ export class StandbyIdentityResolver {
   constructor(
     private readonly store: BuildStore,
     private readonly repo: string,
+    private readonly history?: {
+      allowLookup: () => boolean
+      remember: (events: RepositoryEvent[], complete: boolean) => void
+    },
   ) {}
 
   ingest(events: readonly RepositoryEvent[]): void {
@@ -51,11 +55,14 @@ export class StandbyIdentityResolver {
     const pending = this.pending.get(holder)
     if (pending !== undefined) return pending
     if (this.starts.has(holder) || this.attempted.has(holder)) return
+    if (this.history && !this.history.allowLookup()) return
     this.attempted.add(holder)
     const lookup = (async () => {
       try {
-        this.ingest(await this.store.getRepoStateEvents(this.repo))
-        if (!this.starts.has(holder)) this.ingest(await this.store.getRepoEvents(this.repo, 0))
+        const facts = (await readDispatcherRunFacts(this.store, this.repo, holder)).value
+        this.ingest(facts.start ? [facts.start] : [])
+        const complete = false // This lookup correlates one holder, not the complete journal.
+        this.history?.remember([...this.starts.values()], complete)
       } catch {
         // Identity is best effort; the sampled holder id remains sufficient.
       }

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

@@ -1,3 +1,4 @@
+import { readRepositoryFacts, type RepositoryReadFacts } from '../store/reduced-reads'
 /** 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. */
@@ -67,8 +68,8 @@ async function writeJson(path: string, value: unknown): Promise<void> {
   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)
+function runForEnv(events: RepositoryReadFacts, env: HarvestCliEnv): HarvestRunState {
+  const run = events.harvest.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(
@@ -78,34 +79,44 @@ function runForEnv(events: RepositoryEvent[], env: HarvestCliEnv): HarvestRunSta
   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}`,
-      )
-    }
-  }
+function assertNoSessionTerminal(events: RepositoryReadFacts, env: HarvestCliEnv): void {
+  const run = events.harvest.runs.find((run) => run.run === env.run)
+  const proposal =
+    env.phase === 'synthesize'
+      ? run?.proposals.find((proposal) => proposal.round === env.round)
+      : undefined
+  const review =
+    env.phase === 'review'
+      ? events.harvestVerdicts[JSON.stringify([env.run, env.round])]?.first
+      : undefined
+  const ended = events.harvestSessionEndings[JSON.stringify(env.session)]
+  const errors = [
+    ...(proposal
+      ? [
+          {
+            seq: proposal.seq,
+            message: `second harvest terminal rejected: proposals for ${env.run} synthesize@${env.round} already landed at repo seq ${proposal.seq}`,
+          },
+        ]
+      : []),
+    ...(review
+      ? [
+          {
+            seq: review.seq,
+            message: `second harvest terminal rejected: verdict for ${env.run} review@${env.round} already landed at repo seq ${review.seq}`,
+          },
+        ]
+      : []),
+    ...(ended
+      ? [
+          {
+            seq: ended,
+            message: `harvest terminal rejected: session "${env.session}" already ended at repo seq ${ended}`,
+          },
+        ]
+      : []),
+  ].sort((a, b) => a.seq - b.seq)
+  if (errors[0]) throw new Error(errors[0].message)
 }
 
 async function readArtifactJson(
@@ -122,7 +133,7 @@ async function readArtifactJson(
 export async function buildHarvestContext(deps: HarvestCliDeps): Promise<HarvestContextManifest> {
   const { store, env, workspacePath } = deps
   // Bounded read (AUT-489): runForEnv reduces harvest facts only.
-  const events = await store.getRepoStateEvents(env.repo)
+  const events = (await readRepositoryFacts(store, env.repo)).value
   const run = runForEnv(events, env)
   const packet = await loadScanPacket(store, env.repo, run.scan)
   const abDir = join(workspacePath, '.ab')
@@ -184,10 +195,20 @@ export async function buildHarvestContext(deps: HarvestCliDeps): Promise<Harvest
 }
 
 async function readJsonFile(path: string): Promise<unknown> {
-  const file = Bun.file(path)
-  if (!(await file.exists())) throw new Error(`file not found: ${path}`)
+  let text: string
   try {
-    return JSON.parse(await file.text())
+    text = await Bun.file(path).text()
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      throw new Error(`file not found: ${path}`, { cause: error })
+    }
+    throw new Error(
+      `cannot read ${path}: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error },
+    )
+  }
+  try {
+    return JSON.parse(text)
   } catch (error) {
     throw new Error(
       `${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
@@ -220,7 +241,7 @@ export async function submitHarvestProposals(
   }
   // Bounded read (AUT-489): runForEnv and assertNoSessionTerminal consume
   // harvest facts only.
-  const events = await store.getRepoStateEvents(env.repo)
+  const events = (await readRepositoryFacts(store, env.repo)).value
   const run = runForEnv(events, env)
   assertNoSessionTerminal(events, env)
 
@@ -312,7 +333,7 @@ export async function submitHarvestVerdict(
   }
   // Bounded read (AUT-489): runForEnv and assertNoSessionTerminal consume
   // harvest facts only.
-  const events = await store.getRepoStateEvents(env.repo)
+  const events = (await readRepositoryFacts(store, env.repo)).value
   const run = runForEnv(events, env)
   assertNoSessionTerminal(events, env)
   if (proposalArtifactForRound(run, env.round) === undefined) {
@@ -592,19 +613,35 @@ function projectHarvestRunStatus(run: HarvestRunState): Omit<HarvestRunStatusVie
 
 export function projectHarvestStatus(
   repo: string,
-  events: RepositoryEvent[],
+  events: RepositoryEvent[] | RepositoryReadFacts,
   newestEvents?: number,
   streams?: readonly StreamRecord[],
 ): HarvestStatusView {
-  const state = reduceHarvest(events)
+  const state = Array.isArray(events) ? reduceHarvest(events) : events.harvest
   const history =
-    newestEvents === undefined ? undefined : events.filter(isHarvestEvent).slice(-newestEvents)
+    newestEvents === undefined || !Array.isArray(events)
+      ? 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 sessionsByRun = projectHarvestSessions(events, streams)
+  const sessionsByRun = Array.isArray(events)
+    ? projectHarvestSessions(events, streams)
+    : new Map<string, HarvestSessionStatusView[]>()
+  if (!Array.isArray(events))
+    for (const { run, ...session } of events.harvestSessions) {
+      const record = streams?.find(
+        (record) => record.scope.kind === 'repo' && record.label === `session:${session.session}`,
+      )
+      const list = sessionsByRun.get(run) ?? []
+      list.push({
+        ...session,
+        ...(record ? { stream: record.id, streamStatus: record.status } : {}),
+      })
+      sessionsByRun.set(run, list)
+    }
   const runs = state.runs
     .filter((run) => included.has(run.run))
     .map((run) => ({
@@ -792,7 +829,7 @@ export async function abHarvestStatus(opts: HarvestStatusOpts): Promise<void> {
     async ({ store, repo }) => {
       const record = await store.getRepo(repo)
       // Bounded read (AUT-489): projectHarvestStatus reduces harvest facts only.
-      const events = record === null ? [] : await store.getRepoStateEvents(repo)
+      const events = (await readRepositoryFacts(store, repo)).value
       // Best-effort stream enrichment for the session rows, mirroring the
       // degrade-gracefully pattern of 'ab build status': a store that cannot
       // list streams keeps the payload-derived projection instead of failing.
@@ -804,7 +841,12 @@ export async function abHarvestStatus(opts: HarvestStatusOpts): Promise<void> {
           streams = undefined
         }
       }
-      const view = projectHarvestStatus(repo, events, opts.events, streams)
+      const view = projectHarvestStatus(repo, events, undefined, streams)
+      if (opts.events !== undefined)
+        view.events =
+          record === null
+            ? []
+            : (await store.getRepoEvents(repo)).filter(isHarvestEvent).slice(-opts.events)
       if (opts.json === true) opts.stdout(JSON.stringify(view, null, 2))
       else for (const line of renderHarvestStatus(view)) opts.stdout(line)
     },

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

@@ -74,14 +74,14 @@ export const HELP_CATALOG: readonly HelpEntry[] = [
     audience: 'human',
     summary: 'Connect this project to a hosted service with browser approval.',
     detail:
-      'Usage: ab connect [url]\nWith a URL, approve the printed URL and code in your browser. Stores the credential in user configuration and adds [store] url to autobuild.toml. Without a URL, reports the saved credential status. Runs outside sessions.',
+      'Usage: ab connect [--tickets] [url]\nWith a URL, approve the printed URL and code in your browser. Stores the credential in user configuration and adds [store] url to autobuild.toml. Use --tickets to save [tickets] url and keep builds local. Without a URL, reports every service connection and its uses. Runs outside sessions.',
   },
   {
     name: 'disconnect',
     audience: 'human',
     summary: 'Revoke and remove this project’s saved credential.',
     detail:
-      'Usage: ab disconnect\nRevokes the saved credential remotely before removing it locally. Keeps project registration, data and [store] url. Runs outside sessions.',
+      'Usage: ab disconnect [--tickets | --builds]\nRevokes the saved credential remotely before removing it locally. Keeps project registration, data and [store] url. Runs outside sessions.',
   },
   {
     name: 'upgrade',
@@ -173,20 +173,26 @@ export const HELP_CATALOG: readonly HelpEntry[] = [
     detail: page([
       'Usage:',
       '  ab ticket create <title> --body <file> [--state <state>] [--labels a,b] [--blocked-by id,id] [--json]',
-      '  ab ticket update <id> [--title <title>] [--body <file>] [--labels a,b] [--json]',
-      '  ab ticket block <id> <blocker-id[,blocker-id...]> [--json]',
-      '  ab ticket unblock <id> <blocker-id[,blocker-id...]> [--json]',
+      '  ab ticket edit <id>',
+      '  ab ticket export <dir> [--store <ref>]',
+      '  ab ticket import <dir> [--store <ref>]',
+      '  ab ticket update <id> [--title <title>] [--body <file>] [--labels a,b] [--expected-revision <opaque>] [--json]',
+      '  ab ticket block <id> <blocker-id[,blocker-id...]> [--expected-revision <opaque>] [--json]',
+      '  ab ticket unblock <id> <blocker-id[,blocker-id...]> [--expected-revision <opaque>] [--json]',
       '  ab ticket list [--state <state>] [--labels a,b] [--json]',
       '  ab ticket show <id> [--store <ref>] [--json]',
-      '  ab ticket move <id> <state> [--json]',
+      '  ab ticket move <id> <state> [--expected-revision <opaque>] [--json]',
       '  ab ticket states [--json]',
       '  ab ticket state create <name> [--about <text>] [--json]',
       '  ab ticket attach <id> <kind> <path> [--name <name>] [--store <ref>] [--json]',
       '  ab ticket asset get <id> <kind> <name> <dest> [--rev <n>] [--store <ref>] [--json]',
       '  ab ticket asset rm <id> <kind> <name> [--store <ref>] [--json]',
       '',
-      'Operate on the configured [tickets] source (§8.8); all ticket commands run',
-      'outside sessions. create files a ticket and may establish initial blockers.',
+      'Operate on the configured [tickets] source (§8.8); commands run outside sessions.',
+      'Every JSON ticket read includes an opaque revision. update, move, block and',
+      'unblock accept --expected-revision to refuse stale writes. Linear refuses checks.',
+      'edit opens VISUAL or EDITOR, checks the opening revision, and preserves failed buffers.',
+      'create files a ticket and may establish initial blockers.',
       '--state overrides [tickets].createState (or the provider default) for that',
       'create only; it is passed through unchanged and validated by the source.',
       'update partially replaces editable fields: omitted fields survive, --labels',

package/packages/core/src/cli/historical-build-state.ts

@@ -0,0 +1,27 @@
+import type { BuildStore } from '../store/types'
+import { buildStreamSeedReducer, type BuildStreamSeed } from '../kernel/read-facts'
+
+/** Only explicit old --since cursors need historical reconstruction. Ordinary
+ * registration and the first event batch must use the persisted seed. */
+export async function historicalBuildState(
+  store: BuildStore,
+  slug: string,
+  requested: number,
+  current: { cursor: number; value: BuildStreamSeed },
+) {
+  if (requested >= current.cursor) return current.value
+  const events = await store.getEvents(slug)
+  return buildStreamSeedReducer.reduce(events.filter((event) => event.seq <= requested))
+}
+
+import { repositoryAttentionReducer } from '../kernel/repository-attention'
+export async function historicalRepositoryAttention(
+  store: BuildStore,
+  repo: string,
+  requested: number,
+  current: { cursor: number; value: ReturnType<typeof repositoryAttentionReducer.finish> },
+) {
+  if (requested >= current.cursor) return current.value
+  const events = await store.getRepoEvents(repo)
+  return repositoryAttentionReducer.reduce(events.filter((event) => event.seq <= requested))
+}

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

@@ -1,5 +1,5 @@
 import { stat, readFile, realpath } from 'node:fs/promises'
-import { join, resolve, sep } from 'node:path'
+import { dirname, join, resolve, sep } from 'node:path'
 import semver from 'semver'
 import { PLUGIN_API_VERSION } from '../plugins/manifest'
 import { defaultDistRoot } from './init'
@@ -155,6 +155,57 @@ function ownerRootForPackage(identity: DistributionIdentity): string | undefined
   return owner === '' ? sep : owner
 }
 
+/** Store-internal fallback links cannot establish project ownership. */
+function inBunStore(path: string): boolean {
+  return path
+    .split(sep)
+    .some((part, index, parts) => part === '.bun' && parts[index - 1] === 'node_modules')
+}
+
+function ancestors(path: string): string[] {
+  const result: string[] = []
+  for (let current = resolve(path); ; current = dirname(current)) {
+    result.push(current)
+    if (dirname(current) === current) return result
+  }
+}
+
+async function discoverOwner(
+  identity: DistributionIdentity,
+  cwd: string,
+): Promise<string | undefined> {
+  const direct = ownerRootForPackage(identity)
+  if (direct !== undefined && !inBunStore(direct)) return direct
+  // Reject invalid package names before constructing candidate public paths.
+  if (identity.packageName.split('/').some((part) => part === '' || part === '.' || part === '..'))
+    return undefined
+  const candidates = new Set([...ancestors(identity.root), ...ancestors(cwd)])
+  for (const candidate of candidates) {
+    if (inBunStore(candidate)) continue
+    if (!(await samePath(join(candidate, 'node_modules', identity.packageName), identity.root)))
+      continue
+    const manifestPath = join(candidate, 'package.json')
+    if (!(await exists(manifestPath))) continue
+    const manifest = await parseJson(manifestPath)
+    if (declaredSection(manifest, identity.packageName) !== undefined) return candidate
+  }
+  return undefined
+}
+
+async function readMetadata(path: string): Promise<string> {
+  try {
+    return await readFile(path, 'utf8')
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      throw new Error(`${path} does not exist`, { cause: error })
+    }
+    throw new Error(
+      `cannot read ${path}: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error },
+    )
+  }
+}
+
 function githubDependency(value: unknown): { owner: string; repository: string } | undefined {
   if (typeof value !== 'string') return undefined
   const match = /^github:([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)(?:#([^\s]+))?$/.exec(value)
@@ -172,8 +223,9 @@ function registryDependency(value: unknown, installedVersion: string): boolean {
 }
 
 async function parseJson(path: string): Promise<Record<string, unknown>> {
+  const text = await readMetadata(path)
   try {
-    return object(JSON.parse(await readFile(path, 'utf8'))) ?? {}
+    return object(JSON.parse(text)) ?? {}
   } catch (error) {
     throw new Error(
       `${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
@@ -182,8 +234,9 @@ async function parseJson(path: string): Promise<Record<string, unknown>> {
 }
 
 async function parseJsonc(path: string): Promise<Record<string, unknown>> {
+  const text = await readMetadata(path)
   try {
-    const value = Bun.JSONC.parse(await readFile(path, 'utf8'))
+    const value = Bun.JSONC.parse(text)
     return object(value) ?? {}
   } catch (error) {
     throw new Error(
@@ -241,6 +294,7 @@ async function samePath(left: string, right: string): Promise<boolean> {
 export async function inspectInstallation(options: {
   distRoot?: string
   globalBin: string
+  cwd?: string
 }): Promise<InstallationInspection> {
   const identity = await readDistributionIdentity(options.distRoot)
   if (identity.sourceCheckout) {
@@ -251,18 +305,18 @@ export async function inspectInstallation(options: {
     }
   }
 
-  const ownerRoot = ownerRootForPackage(identity)
-  if (ownerRoot === undefined) {
-    return {
-      kind: 'unknown',
-      identity,
-      reason: 'the distribution is not a direct Bun node_modules package',
+  try {
+    const ownerRoot = await discoverOwner(identity, options.cwd ?? process.cwd())
+    if (ownerRoot === undefined) {
+      return {
+        kind: 'unknown',
+        identity,
+        reason: 'the distribution is not a direct Bun node_modules package',
+      }
     }
-  }
-  const ownerManifest = join(ownerRoot, 'package.json')
-  const ownerLock = join(ownerRoot, 'bun.lock')
+    const ownerManifest = join(ownerRoot, 'package.json')
+    const ownerLock = join(ownerRoot, 'bun.lock')
 
-  try {
     const manifest = await parseJson(ownerManifest)
     const lock = await parseJsonc(ownerLock)
     const declared = declaredSection(manifest, identity.packageName)

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

@@ -1,3 +1,6 @@
+import { readBuildFacts } from '../store/reduced-reads'
+import { preparePinnedAssets } from '../store/ticket-assets'
+import type { PinnedAsset } from '../events/payloads'
 import { abConnect, abDisconnect } from './connect'
 /**
  * `ab` — the only channel between agents and the store, and the enforcement
@@ -19,7 +22,6 @@ import { textContent } from '../store/types'
 import type { Forge } from '../ports/types'
 import { spawnExec, type Exec } from '../ports/workspace/git-worktree'
 import type { IdSource } from '../ids'
-import { reduceBuild } from '../kernel/reducer'
 import { artifactDownload, artifactDownloadStream, artifactGet, artifactPut } from './artifact'
 import { multiFlag, parseArgs, stringFlag, type ParsedArgs } from './args'
 import { abBuildControl, type BuildControlAction, type BuildControlResult } from './build-control'
@@ -308,6 +310,7 @@ async function runBuildControl(
   action: BuildControlAction,
   storeRef?: string,
   readTicketBody?: (ref: TicketRef) => Promise<string>,
+  prepareTicketAssets?: (ref: TicketRef, store: BuildStore, repo: string) => Promise<PinnedAsset[]>,
 ): Promise<void> {
   if (deps.exec === undefined) {
     throw new Error(
@@ -322,6 +325,7 @@ async function runBuildControl(
     action,
     ...(storeRef !== undefined ? { storeRef } : {}),
     ...(readTicketBody !== undefined ? { readTicketBody } : {}),
+    ...(prepareTicketAssets ? { prepareTicketAssets } : {}),
     ...(deps.openStore !== undefined ? { openStore: deps.openStore } : {}),
   })
   deps.stdout(buildControlConfirmation(result))
@@ -451,9 +455,11 @@ async function dispatch(argv: string[], deps: SessionlessCliDeps): Promise<numbe
     case 'connect':
     case 'disconnect': {
       const usage = command === 'connect' ? 'usage: ab connect [url]' : 'usage: ab disconnect'
-      const parsed = parseArgs(rest, {}, usage)
+      const parsed = parseArgs(rest, { tickets: 'boolean', builds: 'boolean' }, usage)
       if (parsed.positionals.length > (command === 'connect' ? 1 : 0)) throw new Error(usage)
       const options = {
+        tickets: parsed.flags.get('tickets') === true,
+        builds: parsed.flags.get('builds') === true,
         cwd: deps.workspacePath,
         env: deps.processEnv ?? process.env,
         exec: deps.exec ?? spawnExec,
@@ -1127,6 +1133,7 @@ async function dispatch(argv: string[], deps: SessionlessCliDeps): Promise<numbe
           : parsed.flags.has('revise-spec-from-ticket')
             ? ({ kind: 'revise-spec', body: { kind: 'ticket' } } as const)
             : undefined
+      let revisionTicketSource: import('../ports/types').TicketSource | undefined
       const readTicketBody =
         resolve?.kind === 'revise-spec' && resolve.body.kind === 'ticket'
           ? async (ref: TicketRef): Promise<string> => {
@@ -1140,6 +1147,7 @@ async function dispatch(argv: string[], deps: SessionlessCliDeps): Promise<numbe
                 },
                 'ab answer --revise-spec-from-ticket',
               )
+              revisionTicketSource = source
               if (source.name !== ref.source) {
                 throw new Error(
                   `build ticket source is "${ref.source}", but this repository is configured for "${source.name}"; refusing to read a same-id ticket from a different source`,
@@ -1151,7 +1159,10 @@ async function dispatch(argv: string[], deps: SessionlessCliDeps): Promise<numbe
                   `ticket "${ref.id}" was not found in the configured ${source.name} source`,
                 )
               }
-              if (ticket.ref.source !== ref.source || ticket.ref.id !== ref.id) {
+              if (
+                ticket.ref.source !== ref.source ||
+                (source.name !== 'hosted' && ticket.ref.id !== ref.id)
+              ) {
                 throw new Error(
                   `ticket adapter returned ${ticket.ref.source}:${ticket.ref.id}, expected ${ref.source}:${ref.id}`,
                 )
@@ -1170,6 +1181,13 @@ async function dispatch(argv: string[], deps: SessionlessCliDeps): Promise<numbe
         },
         storeRef,
         readTicketBody,
+        readTicketBody
+          ? async (ref, store, repo) => {
+              if (!revisionTicketSource)
+                throw new Error('ticket body must be read before preparing assets')
+              return preparePinnedAssets(revisionTicketSource, store, repo, ref.id)
+            }
+          : undefined,
       )
       return 0
     }
@@ -1354,8 +1372,8 @@ async function dispatch(argv: string[], deps: SessionlessCliDeps): Promise<numbe
         // external side effect is best-effort after the atomic designation.
         if (attach) {
           try {
-            const events = await session.store.getEvents(session.env.build)
-            const pr = reduceBuild(events).pr
+            const events = (await readBuildFacts(session.store, session.env.build)).value
+            const pr = events.state.pr
             if (pr !== undefined) {
               try {
                 await preparePrAttachments(session, events, pr.url)

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

@@ -120,7 +120,8 @@ export async function buildMcpTicketBackend(
       }
       return source
     },
-    statesFor: async () => states,
+    statesFor: async (_context, source) =>
+      source.listStates ? (await source.listStates()).map((s) => s.name) : states,
   }
 }
 

package/packages/core/src/cli/pr-attachments.ts

@@ -1,11 +1,8 @@
-import type { AbEvent, EventEnvelope } from '../events/catalog'
+import type { CurrentBuildFacts } from '../store/reduced-reads'
+import type { EventEnvelope } from '../events/catalog'
 import { KERNEL } from '../events/envelope'
 import type { IdSource } from '../ids'
-import {
-  currentPrAttachments,
-  frozenPrImageHost,
-  hostedPrAttachments,
-} from '../kernel/pr-attachments'
+import type { currentPrAttachments } from '../kernel/pr-attachments'
 import { hostedPrAttachmentAssetSchema, type HostedPrAttachmentAsset } from '../ontology'
 import type { Forge } from '../ports/types'
 import type { BuildStore } from '../store/types'
@@ -25,7 +22,7 @@ function errorMessage(error: unknown): string {
 
 async function recordHostingFailure(
   deps: PrAttachmentDeps,
-  events: AbEvent[],
+  events: CurrentBuildFacts,
   designation: ReturnType<typeof currentPrAttachments>[number],
   error: unknown,
   extraRefs: string[] = [],
@@ -44,7 +41,7 @@ async function recordHostingFailure(
         refs: [`${artifact.kind}@${artifact.rev}`, ...extraRefs],
       },
     })
-    events.push(observed)
+    events.observations.push(observed.payload)
   } catch {
     // Hosting is a best-effort review affordance. A secondary failure to
     // record its follow-up must not hide the complete text projection or turn
@@ -61,14 +58,14 @@ async function recordHostingFailure(
  */
 export async function preparePrAttachments(
   deps: PrAttachmentDeps,
-  events: AbEvent[],
+  events: CurrentBuildFacts,
   prUrl: string,
 ): Promise<void> {
-  const target = frozenPrImageHost(events)
+  const target = events.imageHost
   if (target === undefined) return
 
-  const designations = currentPrAttachments(events)
-  const hosted = hostedPrAttachments(events, designations)
+  const designations = events.designations
+  const hosted = new Map(events.hostedImages)
   for (const designation of designations) {
     if (!designation.payload.mediaType.startsWith('image/')) continue
     if (hosted.has(designation.seq)) continue
@@ -132,7 +129,7 @@ export async function preparePrAttachments(
       )
       throw error
     }
-    events.push(event)
+    events.hostedImages.push([designation.seq, event])
     hosted.set(designation.seq, event)
   }
 }