@defrex/autobuild 0.8.0 → 0.9.0

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

@@ -20,9 +20,20 @@ import {
   updateTicket,
 } from '../ports/tickets/operations'
 import type { Ticket, TicketSource, TicketUpdate } from '../ports/types'
-import type { Exec } from '../ports/workspace/git-worktree'
+import { reduceBuild } from '../kernel/reducer'
+import type { BuildStore } from '../store/types'
+import { spawnExec, type Exec } from '../ports/workspace/git-worktree'
+import type { TicketAssetSummary } from '../store/ticket-assets'
 import { parseArgs, stringFlag } from './args'
 import { resolveMainRepo, resolveRepoStatePaths } from './repo-state'
+import { withSessionlessStore, type StoreOpener } from './store-opening'
+import {
+  buildAssetInput,
+  formatAssetSize,
+  ticketAssetNote,
+  walkAssetPath,
+  writeAssetTo,
+} from './ticket-assets'
 
 export type TicketSourceFactory = (
   config: TicketsConfig,
@@ -41,6 +52,11 @@ export interface TicketCommandOpts {
   stdout: (line: string) => void
   /** Injectable for tests; defaults to the real adapter factory. */
   sourceFactory?: TicketSourceFactory
+  /** Store seam for the ticket-asset commands and `show`'s asset list. */
+  openStore?: StoreOpener
+  /** Explicit `--store` for the store-backed commands; precedence is applied
+   * by repo-state.ts. */
+  storeRef?: string
 }
 
 export interface TicketCreateOpts extends TicketCommandOpts {
@@ -88,6 +104,35 @@ export interface TicketShowOpts extends TicketCommandOpts {
   json?: boolean
 }
 
+export interface TicketAttachOpts extends TicketCommandOpts {
+  id: string
+  kind: string
+  path: string
+  /** Defaults to the path's basename. */
+  name?: string
+  json?: boolean
+  /** Warning sink (active-build notice); stdout stays the command's result. */
+  stderr?: (line: string) => void
+}
+
+export interface TicketAssetGetOpts extends TicketCommandOpts {
+  id: string
+  kind: string
+  name: string
+  dest: string
+  rev?: number
+  json?: boolean
+}
+
+export interface TicketAssetRmOpts extends TicketCommandOpts {
+  id: string
+  kind: string
+  name: string
+  json?: boolean
+  /** Warning sink (active-build notice); stdout stays the command's result. */
+  stderr?: (line: string) => void
+}
+
 export interface TicketMoveOpts extends TicketCommandOpts {
   id: string
   /** Source-local workflow state; validation belongs to the adapter. */
@@ -95,7 +140,17 @@ export interface TicketMoveOpts extends TicketCommandOpts {
   json?: boolean
 }
 
-type TicketCommandName = 'create' | 'update' | 'block' | 'unblock' | 'list' | 'show' | 'move'
+type TicketCommandName =
+  | 'create'
+  | 'update'
+  | 'block'
+  | 'unblock'
+  | 'list'
+  | 'show'
+  | 'move'
+  | 'attach'
+  | 'asset get'
+  | 'asset rm'
 
 export interface ResolvedTicketCommand {
   config: Config
@@ -173,7 +228,11 @@ function ticketSummary(ticket: Ticket): string {
   return fields.join(' ')
 }
 
-function ticketDetail(ticket: Ticket): string[] {
+function assetLine(asset: TicketAssetSummary): string {
+  return `    ${asset.kind}/${asset.name}  rev ${asset.revision}  ${formatAssetSize(asset.size)}`
+}
+
+function ticketDetail(ticket: Ticket, assets: TicketAssetSummary[] = []): string[] {
   const lines = [
     `ticket ${ticket.ref.source}:${ticket.ref.id}`,
     `  title:   ${ticket.title}`,
@@ -184,6 +243,7 @@ function ticketDetail(ticket: Ticket): string[] {
     lines.push(`  blocked by: ${ticket.blockedBy.join(', ')}`)
   }
   if (ticket.ref.url !== undefined) lines.push(`  url:     ${ticket.ref.url}`)
+  if (assets.length > 0) lines.push('  assets:', ...assets.map(assetLine))
   lines.push('  body:')
   return lines
 }
@@ -291,16 +351,169 @@ export async function abTicketList(opts: TicketListOpts): Promise<void> {
 export async function abTicketShow(opts: TicketShowOpts): Promise<void> {
   const { source } = await resolveTicketCommand(opts, 'show')
   const ticket = await requireTicket(source, opts.id)
+  // An asset-listing failure fails the command rather than hiding the assets.
+  const assets = await withTicketStore(opts, ({ store, repo }) =>
+    store.listTicketAssets(repo, opts.id),
+  )
   if (opts.json === true) {
-    opts.stdout(JSON.stringify(ticket, null, 2))
+    opts.stdout(
+      JSON.stringify(
+        {
+          ...ticket,
+          assets: assets.map(({ kind, name, revision, size, layout, fileCount }) => ({
+            kind,
+            name,
+            revision,
+            size,
+            layout,
+            fileCount,
+          })),
+        },
+        null,
+        2,
+      ),
+    )
     return
   }
-  for (const line of ticketDetail(ticket)) opts.stdout(line)
+  for (const line of ticketDetail(ticket, assets)) opts.stdout(line)
   // Keep the adapter-provided body untouched. It may itself be multiline and
   // may intentionally end (or not end) with a newline.
   opts.stdout(ticket.body)
 }
 
+function withTicketStore<T>(
+  opts: TicketCommandOpts,
+  use: (context: { store: BuildStore; repo: string }) => Promise<T>,
+): Promise<T> {
+  return withSessionlessStore(
+    {
+      targetRepo: opts.targetRepo,
+      env: opts.env,
+      exec: opts.exec ?? spawnExec,
+      ...(opts.storeRef !== undefined ? { storeRef: opts.storeRef } : {}),
+      ...(opts.openStore !== undefined ? { openStore: opts.openStore } : {}),
+    },
+    use,
+  )
+}
+
+/** Slugs of this repo's non-terminal builds for the ticket. A build freezes its
+ * ticket assets at the claim (SPEC §6.3), so a change to them does not reach
+ * it. The notice is advisory: a failed lookup yields none and never blocks. */
+async function activeBuildsFor(store: BuildStore, repo: string, id: string): Promise<string[]> {
+  try {
+    const active: string[] = []
+    for (const record of await store.listBuilds()) {
+      if (record.repo !== repo || record.ticket?.id !== id) continue
+      const { status } = reduceBuild(await store.getEvents(record.slug))
+      if (status !== 'done' && status !== 'aborted') active.push(record.slug)
+    }
+    return active
+  } catch {
+    return []
+  }
+}
+
+function warnActiveBuilds(
+  opts: { stderr?: (line: string) => void; id: string },
+  slugs: string[],
+): void {
+  for (const slug of slugs) {
+    opts.stderr?.(
+      `warning: build ${slug} is active for ticket ${opts.id}; it keeps the assets it froze at ` +
+        `the claim unless its spec is revised from the ticket (ab answer ${slug} --revise-spec-from-ticket)`,
+    )
+  }
+}
+
+/** `ab ticket attach <id> <kind> <path>` — store a file or folder as a ticket
+ * asset, then leave a note on the ticket in its source. Order matters: the
+ * source is asked first, so an unknown id stores nothing; the note follows the
+ * store write, so it never points at nothing. */
+export async function abTicketAttach(opts: TicketAttachOpts): Promise<void> {
+  const { source } = await resolveTicketCommand(opts, 'attach')
+  await requireTicket(source, opts.id)
+  const walk = await walkAssetPath(opts.path)
+  const name = opts.name ?? walk.basename
+  const stored = await withTicketStore(opts, async ({ store, repo }) => {
+    const limits = await store.ticketAssetLimits(repo)
+    const input = await buildAssetInput(walk, { kind: opts.kind, name }, limits)
+    const live = await store.listTicketAssets(repo, opts.id)
+    const replacing = live.some((asset) => asset.kind === opts.kind && asset.name === name)
+    const meta = await store.putTicketAsset(repo, opts.id, input)
+    return { meta, replacing, active: await activeBuildsFor(store, repo, opts.id) }
+  })
+  const { meta } = stored
+  warnActiveBuilds(opts, stored.active)
+  try {
+    await source.comment(opts.id, ticketAssetNote(stored.replacing ? 'replaced' : 'attached', meta))
+  } catch (error) {
+    throw new Error(
+      `ticket asset ${meta.kind}/${meta.name} was stored as revision ${meta.revision}, but the note on ` +
+        `${source.name}:${opts.id} failed: ${error instanceof Error ? error.message : String(error)} ` +
+        '(re-running attach stores another revision)',
+    )
+  }
+  if (opts.json === true) {
+    opts.stdout(JSON.stringify(meta, null, 2))
+    return
+  }
+  opts.stdout(
+    `ticket asset attached: ${source.name}:${opts.id} ${meta.kind}/${meta.name} revision ${meta.revision} ` +
+      `(${formatAssetSize(meta.size)})`,
+  )
+}
+
+/** `ab ticket asset get <id> <kind> <name> <dest>` — exact bytes at the
+ * latest or a named revision. */
+export async function abTicketAssetGet(opts: TicketAssetGetOpts): Promise<void> {
+  const asset = await withTicketStore(opts, ({ store, repo }) =>
+    store.getTicketAsset(repo, opts.id, opts.kind, opts.name, opts.rev),
+  )
+  if (asset === null) {
+    const revision = opts.rev === undefined ? '' : ` revision ${opts.rev}`
+    throw new Error(
+      `ticket ${opts.id} has no asset ${opts.kind}/${opts.name}${revision}` +
+        (opts.rev === undefined ? ' (it may have been removed — try --rev <n>)' : ''),
+    )
+  }
+  const written = await writeAssetTo(asset, opts.dest)
+  if (opts.json === true) {
+    opts.stdout(JSON.stringify({ ...asset.meta, path: written }, null, 2))
+    return
+  }
+  opts.stdout(
+    `ticket asset downloaded: ${opts.kind}/${opts.name} revision ${asset.meta.revision} → ${written}`,
+  )
+}
+
+/** `ab ticket asset rm <id> <kind> <name>` — remove from the current assets
+ * (earlier revisions stay retrievable) and note the removal on the ticket. */
+export async function abTicketAssetRm(opts: TicketAssetRmOpts): Promise<void> {
+  const { source } = await resolveTicketCommand(opts, 'asset rm')
+  const { removed, active } = await withTicketStore(opts, async ({ store, repo }) => ({
+    removed: await store.removeTicketAsset(repo, opts.id, opts.kind, opts.name),
+    active: await activeBuildsFor(store, repo, opts.id),
+  }))
+  if (removed === null) {
+    throw new Error(`ticket ${opts.id} has no current asset ${opts.kind}/${opts.name} to remove`)
+  }
+  warnActiveBuilds(opts, active)
+  try {
+    await source.comment(opts.id, ticketAssetNote('removed', removed))
+  } catch (error) {
+    throw new Error(
+      `ticket asset ${opts.kind}/${opts.name} was removed, but the note on ${source.name}:${opts.id} ` +
+        `failed: ${error instanceof Error ? error.message : String(error)}`,
+    )
+  }
+  if (opts.json === true) {
+    opts.stdout(JSON.stringify(removed, null, 2))
+    return
+  }
+  opts.stdout(`ticket asset removed: ${source.name}:${opts.id} ${opts.kind}/${opts.name}`)
+}
+
 /** `ab ticket move <id> <state>` — adapter-owned state validation and move. */
 export async function abTicketMove(opts: TicketMoveOpts): Promise<void> {
   const { source } = await resolveTicketCommand(opts, 'move')
@@ -319,7 +532,13 @@ const UPDATE_USAGE =
 const BLOCK_USAGE = 'usage: ab ticket block <id> <blocker-id[,blocker-id...]> [--json] (§8.8)'
 const UNBLOCK_USAGE = 'usage: ab ticket unblock <id> <blocker-id[,blocker-id...]> [--json] (§8.8)'
 const LIST_USAGE = 'usage: ab ticket list [--state <state>] [--labels a,b] [--json] (§8.8)'
-const SHOW_USAGE = 'usage: ab ticket show <id> [--json] (§8.8)'
+const SHOW_USAGE = 'usage: ab ticket show <id> [--store <ref>] [--json] (§8.8)'
+const ATTACH_USAGE =
+  'usage: ab ticket attach <id> <kind> <path> [--name <name>] [--store <ref>] [--json] (§8.8)'
+const ASSET_GET_USAGE =
+  'usage: ab ticket asset get <id> <kind> <name> <dest> [--rev <n>] [--store <ref>] [--json] (§8.8)'
+const ASSET_RM_USAGE =
+  'usage: ab ticket asset rm <id> <kind> <name> [--store <ref>] [--json] (§8.8)'
 const MOVE_USAGE = 'usage: ab ticket move <id> <state> [--json] (§8.8)'
 export const TICKET_USAGE = [
   CREATE_USAGE,
@@ -329,6 +548,9 @@ export const TICKET_USAGE = [
   LIST_USAGE,
   SHOW_USAGE,
   MOVE_USAGE,
+  ATTACH_USAGE,
+  ASSET_GET_USAGE,
+  ASSET_RM_USAGE,
 ].join('\n')
 
 function commaList(value: string): string[] {
@@ -444,19 +666,97 @@ export async function abTicket(argv: string[], opts: TicketCliOpts): Promise<voi
     }
 
     case 'show': {
-      const parsed = parseArgs(args, { json: 'boolean' }, TICKET_USAGE)
+      const parsed = parseArgs(args, { json: 'boolean', store: 'value' }, TICKET_USAGE)
       const [id, ...extra] = parsed.positionals
       if (id === undefined || id.trim() === '' || extra.length > 0) {
         throw new Error(TICKET_USAGE)
       }
+      const store = stringFlag(parsed, 'store')
       await abTicketShow({
         ...opts,
+        ...(store !== undefined ? { storeRef: store } : {}),
         id,
         json: parsed.flags.has('json'),
       })
       return
     }
 
+    case 'attach': {
+      const parsed = parseArgs(
+        args,
+        { name: 'value', store: 'value', json: 'boolean' },
+        TICKET_USAGE,
+      )
+      const [id, kind, path, ...extra] = parsed.positionals
+      if (!id?.trim() || !kind?.trim() || !path?.trim() || extra.length > 0) {
+        throw new Error(TICKET_USAGE)
+      }
+      const name = stringFlag(parsed, 'name')
+      if (name !== undefined && name.trim() === '') throw new Error(TICKET_USAGE)
+      const store = stringFlag(parsed, 'store')
+      await abTicketAttach({
+        ...opts,
+        ...(store !== undefined ? { storeRef: store } : {}),
+        id,
+        kind,
+        path,
+        ...(name !== undefined ? { name } : {}),
+        json: parsed.flags.has('json'),
+      })
+      return
+    }
+
+    case 'asset': {
+      const [action, ...assetArgs] = args
+      if (action === 'get') {
+        const parsed = parseArgs(
+          assetArgs,
+          { rev: 'value', store: 'value', json: 'boolean' },
+          TICKET_USAGE,
+        )
+        const [id, kind, name, dest, ...extra] = parsed.positionals
+        if (!id?.trim() || !kind?.trim() || !name?.trim() || !dest?.trim() || extra.length > 0) {
+          throw new Error(TICKET_USAGE)
+        }
+        const rawRev = stringFlag(parsed, 'rev')
+        if (rawRev !== undefined && !/^\d+$/.test(rawRev)) {
+          throw new Error(
+            `--rev must be a nonnegative integer, got "${rawRev}" — ${ASSET_GET_USAGE}`,
+          )
+        }
+        const store = stringFlag(parsed, 'store')
+        await abTicketAssetGet({
+          ...opts,
+          ...(store !== undefined ? { storeRef: store } : {}),
+          id,
+          kind,
+          name,
+          dest,
+          ...(rawRev !== undefined ? { rev: Number(rawRev) } : {}),
+          json: parsed.flags.has('json'),
+        })
+        return
+      }
+      if (action === 'rm') {
+        const parsed = parseArgs(assetArgs, { store: 'value', json: 'boolean' }, TICKET_USAGE)
+        const [id, kind, name, ...extra] = parsed.positionals
+        if (!id?.trim() || !kind?.trim() || !name?.trim() || extra.length > 0) {
+          throw new Error(TICKET_USAGE)
+        }
+        const store = stringFlag(parsed, 'store')
+        await abTicketAssetRm({
+          ...opts,
+          ...(store !== undefined ? { storeRef: store } : {}),
+          id,
+          kind,
+          name,
+          json: parsed.flags.has('json'),
+        })
+        return
+      }
+      throw new Error(TICKET_USAGE)
+    }
+
     case 'move': {
       const parsed = parseArgs(args, { json: 'boolean' }, TICKET_USAGE)
       const [id, state, ...extra] = parsed.positionals

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

@@ -9,7 +9,7 @@
  *
  * The command shares `ab watch`'s machinery — target selection, ambient
  * scoping (via the extracted `assertReadScope`), the cursor codec, the record
- * projection, the poll cadence, and the read-failure policy — but ends on the
+ * projection, the cadence, and the read-failure policy — but ends on the
  * first satisfied condition instead of streaming. Conditions are derived from
  * the same reducer that produces `ab build status` (`status`, `prState`,
  * `phase`), so "blocked" means an open escalation exactly as it does
@@ -17,6 +17,17 @@
  * wait`, a state condition that already holds when the command starts returns
  * immediately with the build's latest event.
  *
+ * Cadence follows the store kind, exactly as `ab watch` does since AUT-334
+ * (verified and corrected for `ab wait` in AUT-368). Against a local store
+ * the loop is the sequential interval tick. Against an `http(s)` store every
+ * tracked build long-polls instead: one held `getEvents` request per stream
+ * is in flight (tasks run concurrently), `--interval` is the floor between
+ * request starts (elapsed request time counts toward the gap), and a hold's
+ * window is the remote default (25 s, whole seconds, under the store's
+ * ceiling) capped at the remaining `--timeout` budget. Every stop — a
+ * satisfied condition, an all-terminal named set, the timeout, an interrupt —
+ * cancels the in-flight holds promptly instead of waiting out a full window.
+ *
  * Read-only: it appends no event, claims or renews no lease, and creates no
  * build or repository record. Output carries no ANSI, ever, in either form.
  */
@@ -26,7 +37,13 @@ import type { BuildState, PrLifecycle } from '../kernel/reducer'
 import { reduceBuild } from '../kernel/reducer'
 import { isPhase, type BuildStatus, type Phase } from '../ontology'
 import type { Exec } from '../ports/workspace/git-worktree'
-import { buildInRepository, normalizeGitRemoteUrl } from './repo-state'
+import {
+  createRemotePollRunner,
+  defaultDelay,
+  makeFailureStreak,
+  type RemotePollReadOpts,
+} from './remote-poll'
+import { buildInRepository, isRemoteStoreRef, normalizeGitRemoteUrl } from './repo-state'
 import type { BuildRecord } from '../store/types'
 import { withAmbientReadStore, type StoreOpener } from './store-opening'
 import {
@@ -245,23 +262,6 @@ interface WaitStream {
   status: BuildStatus
 }
 
-function defaultDelay(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve) => {
-    if (signal?.aborted === true) {
-      resolve()
-      return
-    }
-    const finish = (): void => {
-      clearTimeout(timer)
-      signal?.removeEventListener('abort', onAbort)
-      resolve()
-    }
-    const timer = setTimeout(finish, ms)
-    const onAbort = (): void => finish()
-    signal?.addEventListener('abort', onAbort, { once: true })
-  })
-}
-
 /**
  * `ab wait` — block until a targeted build satisfies a condition, then print
  * one record and exit 0; exit 2 when every named build went terminal without
@@ -386,6 +386,12 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
         if (streams.has(slug)) return
         const record = await store.getBuild(slug)
         if (record === null) return
+        // AUT-545: this full-log read is deliberate, accepted growth — the
+        // retained prefix is consumed at full replay depth by every later
+        // reduction (approvals, findings, answered escalations, PR facts,
+        // observations), so bounding it would need reducer-partition store
+        // machinery out of AUT-545's scope. Required for `--since` replay and
+        // the registration state check over the full reduction.
         const events = await store.getEvents(slug)
         const stream = registerStream(slug, events, slugs.includes(slug))
         if (resumeSeq !== undefined) {
@@ -419,8 +425,24 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
        * build to appear.
        */
       const discoverBuilds = async (): Promise<void> => {
+        // AUT-545: the terminal filter is the AUT-487 digest, not a full-log read —
+        // one flat batch read replaces a full getEvents per candidate build, per
+        // discovery pass; `terminal` is reduceBuild's exact terminal rule
+        // (store/digest.ts, pinned by contract). The per-build full read below
+        // remains deliberate for builds the digest cannot retire: its retained
+        // prefix is consumed at full replay depth by every later reduction
+        // (approvals, findings, answered escalations, PR facts, observations), so
+        // bounding it would need reducer-partition store machinery out of
+        // AUT-545's scope. The reduceBuild re-check stays: it is the
+        // legacy-record fallback (a record whose `repo` predates origin
+        // normalization is in `mine` via `repoOrigin` but absent from the digest
+        // map, which keys on `record.repo`) and it keeps this filter unable to
+        // diverge from reduceBuild.
+        const digests = await store.getRepoBuildDigests(repo)
         for (const record of (await store.listBuilds()).filter(mine)) {
           if (streams.has(record.slug)) continue
+          const digest = digests.get(record.slug)
+          if (digest !== undefined && digest.terminal !== undefined) continue
           const events = await store.getEvents(record.slug)
           const status = reduceBuild(events).status
           if (!NONTERMINAL_STATUSES.includes(status)) continue
@@ -429,8 +451,11 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
         }
       }
 
-      const pollBuild = async (stream: WaitStream): Promise<void> => {
-        const fresh = await store.getEvents(stream.slug, stream.lastSeq)
+      const pollBuild = async (
+        stream: WaitStream,
+        readOpts?: RemotePollReadOpts,
+      ): Promise<void> => {
+        const fresh = await store.getEvents(stream.slug, stream.lastSeq, readOpts)
         for (const event of fresh) {
           stream.events.push(event)
           stream.lastSeq = event.seq
@@ -482,13 +507,7 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
       /** One poll cycle: discovery, then per-stream reads. A failed read is
        * reported once per failure streak, advances nothing, and is retried at
        * the next interval; a fully successful cycle re-arms the report. */
-      let readFailureReported = false
-      const reportReadFailure = (error: unknown): void => {
-        if (readFailureReported) return
-        readFailureReported = true
-        const message = error instanceof Error ? error.message : String(error)
-        opts.stderr(`ab wait: a store read failed (${message}); retrying at the next interval`)
-      }
+      const tickStreak = makeFailureStreak('wait', opts.stderr)
 
       const tick = async (): Promise<void> => {
         let allReadsOk = true
@@ -497,7 +516,7 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
             await discoverBuilds()
           } catch (error) {
             allReadsOk = false
-            reportReadFailure(error)
+            tickStreak.onFailure(error)
           }
         }
         for (const stream of [...streams.values()]) {
@@ -506,10 +525,10 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
             await pollBuild(stream)
           } catch (error) {
             allReadsOk = false
-            reportReadFailure(error)
+            tickStreak.onFailure(error)
           }
         }
-        if (allReadsOk) readFailureReported = false
+        if (allReadsOk) tickStreak.onSuccess()
       }
 
       const finishSatisfied = (): number =>
@@ -561,17 +580,106 @@ export async function abWait(opts: AbWaitOpts): Promise<number> {
       const timeoutText = opts.timeout ?? '30m'
       const deadline = timeoutMs === 0 ? Number.POSITIVE_INFINITY : now().getTime() + timeoutMs
       const aborted = (): boolean => opts.signal?.aborted === true
-      while (!hasMatch()) {
-        if (aborted() || now().getTime() >= deadline) break
-        await sleep(interval, opts.signal)
-        if (aborted()) break
-        await tick()
-        if (!hasMatch() && namedAllTerminal()) {
-          const terminal = pickTerminalRecord()
-          return finish(null, terminal.event, terminal.state)
+
+      if (!isRemoteStoreRef(storeRef)) {
+        // Local cadence: one sequential tick per interval.
+        while (!hasMatch()) {
+          if (aborted() || now().getTime() >= deadline) break
+          await sleep(interval, opts.signal)
+          if (aborted()) break
+          await tick()
+          if (!hasMatch() && namedAllTerminal()) {
+            const terminal = pickTerminalRecord()
+            return finish(null, terminal.event, terminal.state)
+          }
         }
+      } else {
+        // Remote cadence (AUT-334, verified and corrected in AUT-368): one
+        // long-poll task per tracked stream, running concurrently — a quiet
+        // stream keeps one held `getEvents` request in flight, so an appended
+        // event is seen within about a second of its append instead of at the
+        // next interval tick. Gap-fill spaces each stream's request starts at
+        // least `interval` apart (elapsed request time counts toward the
+        // gap), so a server that answers immediately still sees today's
+        // request rate. Discovery keeps its interval cadence. The pre-launch
+        // guard mirrors the local loop's top-of-cycle checks: a satisfied
+        // match, an abort, an elapsed deadline, or an all-terminal named set
+        // ends the wait before any held request (an already-satisfied wait
+        // issues zero held reads).
+        // Every stop is prompt: a satisfied condition, an all-terminal named
+        // set, an external abort, or an elapsed --timeout cancels the
+        // in-flight held reads (via `requestStop`) and wakes the gap sleeps
+        // (via the runner's stop controller) instead of waiting out a full
+        // hold. The held read's own bound is additionally capped at the
+        // wait's remaining time budget, so a hold can never outlive the
+        // deadline.
+        const shouldStop =
+          hasMatch() || aborted() || now().getTime() >= deadline || namedAllTerminal()
+        const remoteRunner = createRemotePollRunner({
+          command: 'wait',
+          stderr: opts.stderr,
+          now,
+          sleep,
+          intervalMs: interval,
+          deadlineMs: deadline,
+          aborted,
+          shouldStop: () =>
+            hasMatch() || aborted() || now().getTime() >= deadline || namedAllTerminal(),
+          drain: 'quiesce',
+        })
+        const requestStop = (): void => remoteRunner.requestStop()
+
+        const launch = (stream: WaitStream): void => {
+          remoteRunner.launch(
+            stream.slug,
+            (readOpts) => pollBuild(stream, readOpts),
+            () => hasMatch() || namedAllTerminal(),
+          )
+        }
+
+        // An external abort (SIGINT) is a stop like any other: it cancels
+        // the in-flight held reads and wakes the gap sleeps.
+        opts.signal?.addEventListener('abort', requestStop, { once: true })
+
+        if (!shouldStop) {
+          for (const stream of streams.values()) launch(stream)
+
+          if (slugs.length === 0) {
+            // Discovery keeps its interval cadence, launching a new per-
+            // stream task for each newly discovered nonterminal build. A
+            // discovered build that already satisfies ends the wait. The
+            // launch loop stays unconditional, after the catch — exactly
+            // where the inline loop ran: streams registered before a
+            // mid-discovery throw still get tasks whose polls then run
+            // independently.
+            void remoteRunner.runDiscovery({
+              step: async (): Promise<void> => {
+                await discoverBuilds()
+              },
+              launchPending: (): void => {
+                for (const stream of streams.values()) launch(stream)
+              },
+              endCheck: () => hasMatch(),
+            })
+          }
+        }
+
+        await remoteRunner.drain()
+        opts.signal?.removeEventListener('abort', requestStop)
       }
+
       if (hasMatch()) return finishSatisfied()
+      if (namedAllTerminal()) {
+        // Decision 5, loop form: every named build went terminal without
+        // satisfying anything. The local loop checks this after each tick;
+        // on the remote path the runner records only that a stop was
+        // requested — its `shouldStop`/`endCheck` callbacks re-derive the
+        // conditions live — so after the quiesce drain this decision re-reads
+        // the same live predicates (`hasMatch`, `namedAllTerminal`, `aborted`,
+        // the deadline) to pick the exit.
+        const terminal = pickTerminalRecord()
+        return finish(null, terminal.event, terminal.state)
+      }
       if (aborted()) {
         opts.stderr('ab wait: interrupted — no condition was satisfied before the signal')
         if (json) opts.stdout(JSON.stringify({ cursor: encodeCurrent() }))