@vzn/vx 0.0.642 → 0.0.644

package/src/cache/scoped-cache.ts

@@ -1,20 +1,12 @@
-// The run's `cache.scope` over every layer at once (owner, 2026-10-14): a
-// scoped run reads the default key, then the scope's, and writes only the
-// scope's, in the local store and every remote alike. Below this wrapper no
-// layer knows a scope exists: the scope's key is a key like any other.
+// A branch's cache scope (owner, 2026-10-17): the local store never knows
+// one, so every branch shares one local pool under the task keys. Scopes
+// decide only which remote entry a task asks for: a task the branch changed
+// reads the scope's key, every other task the default key, and a scoped run
+// writes every remote under the scope's key. An artifact is packed under its
+// task key wherever it is stored, so a remote entry ingests under that key.
 
 import { xxh3hex } from '../util/index.js'
-import type {
-  CacheEntry,
-  CacheGetContext,
-  CacheLayer,
-  DeclaredOutputs,
-  IngestMeta,
-  InvocationRecord,
-  OutputDirRow,
-  RunRecord,
-  SaveArgs,
-} from './layer.js'
+import type { RemoteCacheLayer, RemoteKey } from './layered-cache.js'
 
 /** The key a scope stores `hash` under: task-key shaped, 16 hex, so every wire stores it unchanged. */
 export function scopedKey(scope: string, hash: string): string {
@@ -22,231 +14,74 @@ export function scopedKey(scope: string, hash: string): string {
 }
 
 /**
- * A layer as a scoped run sees it. Callers speak task keys; each answer is
- * remembered under the key that served it (the default key on a default hit,
- * the scope's on a scope hit or a save), so the restore, the output index and
- * the run's history all reach the entry that answered. An artifact records
- * the key it was packed under and ingest refuses another, so a derived-key
- * collision degrades to a miss. A default artifact a remote ingest refuses is
- * a miss there, and the scope's key is asked next (Security F6).
+ * Which remote key each task asks for, in a run with a scope. The routes
+ * come from the branch's diff, which only a remote call awaits: a run the
+ * local cache answers never waits on git.
  */
-export class ScopedCache implements CacheLayer {
-  readonly local?: CacheLayer['local']
-  readonly hasRemote?: boolean
-  readonly drainUploads?: () => Promise<void>
-  readonly stopUploads?: () => void
-  readonly remoteHasMany?: (hashes: readonly string[]) => Promise<Set<string> | null>
-  /** A scoped run saves under the scope's key, so that is the key asked. */
-  readonly probeBeforeUpload?: (hashes: Promise<readonly string[]>) => void
-  readonly getMany?: (
-    hashes: readonly string[],
-    ctx?: (hash: string) => CacheGetContext,
-  ) => Promise<Map<string, CacheEntry>>
-  /** Task key → the key that answers for it this run. */
-  private readonly served = new Map<string, string>()
-
-  constructor(
-    private readonly inner: CacheLayer,
-    private readonly scope: string,
-  ) {
-    if (inner.local !== undefined) this.local = inner.local
-    if (inner.hasRemote !== undefined) this.hasRemote = inner.hasRemote
-    if (inner.drainUploads !== undefined) this.drainUploads = () => inner.drainUploads!()
-    if (inner.stopUploads !== undefined) this.stopUploads = () => inner.stopUploads!()
-    if (inner.remoteHasMany !== undefined) this.remoteHasMany = (h) => this.scopedHasMany(h)
-    if (inner.probeBeforeUpload !== undefined)
-      this.probeBeforeUpload = (h) =>
-        inner.probeBeforeUpload!(h.then((keys) => keys.map((k) => this.own(k))))
-    if (inner.getMany !== undefined) this.getMany = (h, ctx) => this.scopedGetMany(h, ctx)
-  }
-
-  private own(hash: string): string {
-    const key = scopedKey(this.scope, hash)
-    this.local?.traffic.aliases.set(key, hash)
-    return key
-  }
-
-  private keyOf(hash: string): string {
-    return this.served.get(hash) ?? hash
-  }
-
-  /** A batch keyed by served keys, keyed back by task key. */
-  private batch<T>(
-    hashes: readonly string[],
-    read: (keys: string[]) => Map<string, T>,
-  ): Map<string, T> {
-    const keys = hashes.map((h) => this.keyOf(h))
-    const found = read(keys)
-    const out = new Map<string, T>()
-    for (let i = 0; i < hashes.length; i++) {
-      const v = found.get(keys[i]!)
-      if (v !== undefined) out.set(hashes[i]!, v)
+export class BranchScope {
+  /** Finds the tasks that read the scope, at the first remote call; null: every task does. */
+  private route: (() => Promise<ReadonlySet<string>>) | null = null
+  private routes: Promise<ReadonlySet<string>> | null = null
+  /** Task key → its task. */
+  private readonly taskOf = new Map<string, string>()
+
+  constructor(readonly scope: string) {}
+
+  /** Only the tasks `ids` finds read the scope; set before any remote call. */
+  routeTasks(ids: () => Promise<ReadonlySet<string>>): void {
+    this.route = ids
+  }
+
+  noteKey(taskId: string, hash: string): void {
+    this.taskOf.set(hash, taskId)
+  }
+
+  /** The remote key `hash` is read under, and the scope it is read in (none: the default key). */
+  private async readKey(hash: string): Promise<{ key: string; at: RemoteKey }> {
+    const id = this.taskOf.get(hash)
+    if (this.route !== null) this.routes ??= this.route()
+    const tasks = this.routes === null ? null : await this.routes
+    return tasks !== null && id !== undefined && !tasks.has(id)
+      ? { key: hash, at: {} }
+      : { key: scopedKey(this.scope, hash), at: { scope: this.scope } }
+  }
+
+  /**
+   * `inner` as this run asks it: each task key under its route's key; every
+   * write under the scope's. Each call also names its scope, for a backend
+   * that keeps one store per scope; no wire vx ships sends it.
+   */
+  remote(inner: RemoteCacheLayer): RemoteCacheLayer {
+    const read = (h: string) => this.readKey(h)
+    const at: RemoteKey = { scope: this.scope }
+    const hasMany = inner.hasMany
+    return {
+      ...(inner.endpoint !== undefined ? { endpoint: inner.endpoint } : {}),
+      ...(inner.open !== undefined ? { open: (ctx) => inner.open!(ctx) } : {}),
+      has: async (h) => {
+        const r = await read(h)
+        return inner.has(r.key, r.at)
+      },
+      ...(hasMany !== undefined
+        ? {
+            hasMany: async (hashes) => {
+              const reads = await Promise.all(hashes.map(read))
+              const keys = reads.map((r) => r.key)
+              const found = await hasMany.call(
+                inner,
+                keys,
+                reads.map((r) => r.at),
+              )
+              if (!(found instanceof Set)) return found
+              return new Set(hashes.filter((_, i) => found.has(keys[i]!)))
+            },
+          }
+        : {}),
+      get: async (h) => {
+        const r = await read(h)
+        return inner.get(r.key, r.at)
+      },
+      put: (h, body, meta) => inner.put(scopedKey(this.scope, h), body, { ...meta, ...at }),
     }
-    return out
-  }
-
-  /** A task key the store holds under the default key or the scope's. */
-  async localHasMany(hashes: readonly string[]): Promise<Set<string>> {
-    const held = await this.inner.localHasMany?.([...hashes, ...hashes.map((h) => this.own(h))])
-    if (held === undefined) return new Set()
-    return new Set(hashes.filter((h) => held.has(h) || held.has(this.own(h))))
-  }
-
-  private async scopedHasMany(hashes: readonly string[]): Promise<Set<string> | null> {
-    const scoped = hashes.map((h) => this.own(h))
-    const [plain, own] = await Promise.all([
-      this.inner.remoteHasMany!(hashes),
-      this.inner.remoteHasMany!(scoped),
-    ])
-    if (plain == null || own == null) return null
-    const found = new Set(plain)
-    const scopeOnly: string[] = []
-    for (let i = 0; i < hashes.length; i++) {
-      if (plain.has(hashes[i]!) || !own.has(scoped[i]!)) continue
-      found.add(hashes[i]!)
-      scopeOnly.push(hashes[i]!)
-    }
-    // Their default key is known absent: its GET is skipped.
-    this.inner.markRemoteAbsent?.(scopeOnly)
-    return found
-  }
-
-  markRemoteAbsent(hashes: Iterable<string>): void {
-    const all: string[] = []
-    for (const h of hashes) all.push(h, this.own(h))
-    this.inner.markRemoteAbsent?.(all)
-  }
-
-  key(input: Parameters<CacheLayer['key']>[0]): Promise<string> {
-    return this.inner.key(input)
-  }
-
-  async get(hash: string, ctx?: CacheGetContext): Promise<CacheEntry | null> {
-    // The scope's key first when only it is local: the default key's
-    // remote GET would cost a round-trip for the same inputs.
-    const own = this.own(hash)
-    const keys = (await this.inner.localHasMany?.([hash, own]))?.has(own)
-      ? [own, hash]
-      : [hash, own]
-    for (const key of keys) {
-      const entry = await this.inner.get(key, ctx)
-      if (entry === null) continue
-      this.served.set(hash, key)
-      return key === hash ? entry : { ...entry, hash }
-    }
-    return null
-  }
-
-  private async scopedGetMany(
-    hashes: readonly string[],
-    ctx?: (hash: string) => CacheGetContext,
-  ): Promise<Map<string, CacheEntry>> {
-    const out = await this.inner.getMany!(hashes, ctx)
-    for (const h of out.keys()) this.served.set(h, h)
-    const rest = hashes.filter((h) => !out.has(h))
-    if (rest.length === 0) return out
-    const byOwn = new Map(rest.map((h) => [this.own(h), h]))
-    const scoped = await this.inner.getMany!(
-      [...byOwn.keys()],
-      ctx === undefined ? undefined : (key) => ctx(byOwn.get(key)!),
-    )
-    for (const [key, entry] of scoped) {
-      const hash = byOwn.get(key)!
-      this.served.set(hash, key)
-      out.set(hash, { ...entry, hash })
-    }
-    return out
-  }
-
-  async has(hash: string): Promise<'local' | 'remote' | null> {
-    return (await this.inner.has(hash)) ?? (await this.inner.has(this.own(hash)))
-  }
-
-  async prefetch(hash: string, ctx?: CacheGetContext): Promise<boolean> {
-    return (await this.inner.prefetch(hash, ctx)) || this.inner.prefetch(this.own(hash), ctx)
-  }
-
-  loadOutputFilesBatch(hashes: readonly string[]): ReturnType<CacheLayer['loadOutputFilesBatch']> {
-    return this.batch(hashes, (keys) => this.inner.loadOutputFilesBatch(keys))
-  }
-
-  isOutputsCurrent(
-    ...args: Parameters<CacheLayer['isOutputsCurrent']>
-  ): ReturnType<CacheLayer['isOutputsCurrent']> {
-    return this.inner.isOutputsCurrent(...args)
-  }
-
-  async recordOutputDirs(
-    hash: string,
-    projectDir: string,
-    prefixes: readonly string[],
-    holds?: (files: readonly string[]) => boolean,
-  ): Promise<void> {
-    await this.inner.recordOutputDirs?.(this.keyOf(hash), projectDir, prefixes, holds)
-  }
-
-  recordOutputStamps(hash: string, projectDir: string, workspaceRoot: string): void {
-    this.inner.recordOutputStamps?.(this.keyOf(hash), projectDir, workspaceRoot)
-  }
-
-  loadOutputDirsBatch(hashes: readonly string[]): Map<string, OutputDirRow[]> {
-    return this.batch(hashes, (keys) => this.inner.loadOutputDirsBatch?.(keys) ?? new Map())
-  }
-
-  async outputDirsCurrent(projectDir: string, rows: readonly OutputDirRow[]): Promise<boolean> {
-    return (await this.inner.outputDirsCurrent?.(projectDir, rows)) ?? false
-  }
-
-  restoreOutputs(
-    hash: string,
-    projectDir: string,
-    workspaceRoot?: string,
-    outputs?: DeclaredOutputs,
-  ): Promise<void> {
-    return this.inner.restoreOutputs(this.keyOf(hash), projectDir, workspaceRoot, outputs)
-  }
-
-  save(args: SaveArgs): Promise<void> {
-    const key = this.own(args.hash)
-    this.served.set(args.hash, key)
-    return this.inner.save({ ...args, hash: key })
-  }
-
-  ingest(hash: string, body: Blob | Response, meta: IngestMeta): Promise<void> {
-    const key = this.own(hash)
-    this.served.set(hash, key)
-    return this.inner.ingest(key, body, meta)
-  }
-
-  /** History names the key that answered, so `vx why` reads that entry's components. */
-  recordRunBundle(bundle: { runs: readonly RunRecord[]; invocation: InvocationRecord }): void {
-    this.inner.recordRunBundle({
-      ...bundle,
-      runs: bundle.runs.map((r) => (r.hash === undefined ? r : { ...r, hash: this.keyOf(r.hash) })),
-    })
-  }
-
-  stats(...args: Parameters<CacheLayer['stats']>): ReturnType<CacheLayer['stats']> {
-    return this.inner.stats(...args)
-  }
-
-  hashFile(filePath: string): Promise<string> {
-    return this.inner.hashFile(filePath)
-  }
-
-  outputsPath(hash: string): string {
-    return this.inner.outputsPath(this.keyOf(hash))
-  }
-
-  artifactSize(hash: string): number | undefined {
-    return this.inner.artifactSize?.(this.keyOf(hash))
-  }
-
-  prune(...args: Parameters<CacheLayer['prune']>): ReturnType<CacheLayer['prune']> {
-    return this.inner.prune(...args)
-  }
-
-  close(): void {
-    this.inner.close()
   }
 }

package/src/cache/tar-stream.ts

@@ -122,14 +122,19 @@ class Source {
   constructor(private readonly reader: AsyncIterator<Uint8Array>) {}
 
   private async fill(): Promise<boolean> {
-    if (this.done) return false
-    const { done, value } = await this.reader.next()
-    if (done === true || value === undefined) {
-      this.done = true
-      return false
+    // An empty chunk is skipped, never reported as data: the callers read
+    // `chunks[0]` after a true (the tar a tree packs back yields them).
+    for (;;) {
+      if (this.done) return false
+      const { done, value } = await this.reader.next()
+      if (done === true || value === undefined) {
+        this.done = true
+        return false
+      }
+      if (value.byteLength === 0) continue
+      this.chunks.push(value)
+      return true
     }
-    if (value.byteLength > 0) this.chunks.push(value)
-    return true
   }
 
   /** Exactly `n` bytes, or null at a clean end (nothing buffered), or a TarFormatError mid-entry. */

package/src/cli/format.ts

@@ -1,4 +1,3 @@
-// `formatBytes` moved to util/size.ts beside the parsers (item 658): a run
-// names what the workspace's `cacheRetention` evicted, and the orchestrator
+// `formatBytes` lives in util/size.ts beside the parsers: the orchestrator
 // may not import the CLI.
 export { formatBytes } from '../util/index.js'

package/src/cli/help.ts

@@ -134,8 +134,8 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     '                             foo, @scope/*, ./packages/foo, foo..., ...foo,',
     '                             foo^..., !foo, [<since>]',
     '      --affected[=<base>]  Projects changed since <base>, and dependents',
-    '                             (--filter "...[<base>]"); default run.affectedBase,',
-    '                             else origin/HEAD, main, master, HEAD~1.',
+    '                             (--filter "...[<base>]"); default the merge base',
+    '                             with origin/<baseBranch>; none on that branch.',
     "  pkg#task                 Run a specific project's task directly.",
     '',
     'Execution (for run):',
@@ -159,12 +159,16 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     '                                  flags; unnamed layers keep theirs. Examples:',
     '                                  local:rw,remote:r (remote read-only), remote:',
     '                                  (remote off), local:r (local read-only).',
-    "      --cache-scope <name>        This run's cache.scope (pr-123): write there,",
-    '                                  read the default keys first.',
     '      --cache-dir <path>          Cache directory (cwd-relative); default',
     '                                  .vx/cache, entries in ~/.vx/<id>/cache.',
     '      --cache-download <mode>     all (default) | toplevel | none:',
     '                                  where remote outputs land.',
+    '      --cache-concurrency-download <n>',
+    '                                  Remote downloads at once.',
+    '      --cache-concurrency-upload <n>',
+    '                                  Uploads at once, per remote.',
+    '      --cache-concurrency-restore <n>',
+    '                                  Local hits restoring at once.',
     '      --retries <n>               Up to <n> more runs of a failed task, for',
     '                                  tasks without their own exec.retries. Not',
     '                                  folded into cache keys.',

package/src/cli/info.ts

@@ -100,9 +100,6 @@ export function renderInfo(f: InfoFacts, colors: ColorSupport = { enabled: false
     ...(Object.values(f.settings).some((s) => s.source !== 'default')
       ? ([['settings', describeSettings(f.settings)]] as [string, string][])
       : []),
-    ...(f.cacheRetention !== null
-      ? ([['cache retention', describeRetention(f.cacheRetention)]] as [string, string][])
-      : []),
     // Only when there is something to say.
     ...(f.orphans.artifacts > 0
       ? ([
@@ -128,14 +125,9 @@ export function renderInfo(f: InfoFacts, colors: ColorSupport = { enabled: false
   return ui.report('vx info', rows).lines(colors).join('\n')
 }
 
-/** `812 (1.2 GB)`, or against `cacheRetention.maxSize`: `812 (1.2 GB of 10 GB, 12%)`. */
+/** `812 (1.2 GB)`. */
 function describeEntries(f: InfoFacts): string {
-  const max = f.cacheRetention?.maxBytes
-  const size =
-    max === undefined
-      ? formatBytes(f.cacheBytes)
-      : `${formatBytes(f.cacheBytes)} of ${formatBytes(max)}, ${Math.round((f.cacheBytes / max) * 100)}%`
-  return `${f.cacheEntries} (${size})`
+  return `${f.cacheEntries} (${formatBytes(f.cacheBytes)})`
 }
 
 /**
@@ -152,15 +144,6 @@ function describeSettings(settings: InfoFacts['settings']): string {
     .join(', ')
 }
 
-/** What a run's end evicts: `entries unused for 30d, and the oldest entries past 10G`. */
-function describeRetention(r: NonNullable<InfoFacts['cacheRetention']>): string {
-  const parts = [
-    ...(r.olderThan !== undefined ? [`entries unused for ${r.olderThan}`] : []),
-    ...(r.maxSize !== undefined ? [`the oldest entries past ${r.maxSize}`] : []),
-  ]
-  return `each run evicts ${parts.join(', and ')}`
-}
-
 /** A path under the home directory as `~/…`: shorter, and no user name in a pasted report. */
 function tildePath(p: string): string {
   const home = os.homedir()

package/src/cli/plugin-commands.ts

@@ -9,8 +9,8 @@
 
 import type { CachePolicy, PluginCache, ResolvedRemote } from '../cache/index.js'
 import type { WorkspaceConfig } from '../config.js'
-import type { VxPlugin, PluginCommand, CommandContext } from '../orchestrator/index.js'
-import { cacheScopeEnvError, findWorkspaceRoot, isCacheScope } from '../workspace/index.js'
+import type { BranchFacts, VxPlugin, PluginCommand, CommandContext } from '../orchestrator/index.js'
+import { configuredBaseBranch, findWorkspaceRoot } from '../workspace/index.js'
 import { machineParallelism, maskedLine } from '../util/index.js'
 import { resolveSetting } from '../settings.js'
 
@@ -49,6 +49,7 @@ async function workspacePlugins(cwd: string): Promise<
       workspaceConfig: WorkspaceConfig | null
       concurrency: number
       plugins: readonly VxPlugin[]
+      branch: BranchFacts
     }
   | UnresolvedPluginCommand
   | null
@@ -76,6 +77,7 @@ async function workspacePlugins(cwd: string): Promise<
       (resolveSetting('run.concurrency', ws.workspaceConfig).value as number | undefined) ??
       machineParallelism(),
     plugins: ws.plugins,
+    branch: ws.branch,
   }
 }
 
@@ -136,13 +138,16 @@ async function verbCache(
   ws: Exclude<Awaited<ReturnType<typeof workspacePlugins>>, UnresolvedPluginCommand | null>,
   plugin: string,
 ): Promise<PluginCache> {
-  const [{ Cache, pluginCache }, { resolveCache }] = await Promise.all([
+  const [{ Cache, pluginCache }, { resolveCache, resolveCacheScope }] = await Promise.all([
     import('../cache/index.js'),
     import('../orchestrator/index.js'),
   ])
-  const envScope = process.env['VX_CACHE_SCOPE'] || undefined
-  if (envScope !== undefined && !isCacheScope(envScope)) throw cacheScopeEnvError()
-  const scope = envScope ?? ws.workspaceConfig?.cache?.scope
+  const scope = resolveCacheScope(
+    ws.workspaceRoot,
+    ws.branch.trusted === true ? null : ws.branch.scope,
+    ws.plugins.some((p) => p.cache !== undefined),
+    configuredBaseBranch(ws.workspaceConfig),
+  )
   const localCache = new Cache(
     ws.cacheDir,
     { read: true, write: false },

package/src/cli/run.ts

@@ -1,5 +1,5 @@
 import { isatty } from 'node:tty'
-import { cacheScopeError, findWorkspaceRoot, isCacheScope } from '../workspace/index.js'
+import { findWorkspaceRoot } from '../workspace/index.js'
 import { translateForeign } from './foreign-flags.js'
 import { flagHint, refuse, seeHelp } from './help.js'
 import {
@@ -60,8 +60,6 @@ export interface RunArgs {
   remoteRequested?: boolean
   /** `--cache-dir <path>`: override the cache directory (cwd-relative). */
   cacheDir: string | undefined
-  /** `--cache-scope <name>`: this run's `cache.scope`, above `VX_CACHE_SCOPE` and the workspace's. */
-  cacheScope?: string
   /** `vx watch --poll` (`watch.poll`). */
   poll?: true
   forwardArgs: string[]
@@ -90,9 +88,7 @@ function flagOf(a: string | undefined, name: string): string | undefined {
 // The settings parsed by their kind alone; the cache flags, `--continue`
 // and `--cache-dir` keep their own branches above.
 const GENERIC_FLAGS = SETTINGS.filter(
-  (s) =>
-    s.flag?.verb === 'run' &&
-    !['run.continue', 'cache.dir', 'cache.policy', 'cache.scope'].includes(s.path),
+  (s) => s.flag?.verb === 'run' && !['run.continue', 'cache.dir', 'cache.policy'].includes(s.path),
 )
 
 /** The setting a flag names. */
@@ -113,6 +109,9 @@ const SETTING_OPTIONS = [
   ['run.retries', 'retries'],
   ['run.outputLogs', 'outputLogs'],
   ['cache.download', 'download'],
+  ['cache.concurrency.download', 'downloadConcurrency'],
+  ['cache.concurrency.upload', 'uploadConcurrency'],
+  ['cache.concurrency.restore', 'restoreConcurrency'],
 ] as const satisfies readonly (readonly [string, keyof RunOptions])[]
 
 /** `verb` is the one being parsed for: `vx watch` reads `vx run`'s flags, and
@@ -204,11 +203,6 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
         }
       }
       out.cacheDir = v
-    } else if (a === '--cache-scope' || a?.startsWith('--cache-scope=')) {
-      const v = a === '--cache-scope' ? before[++i] : a.slice('--cache-scope='.length)
-      if (v === undefined || !isCacheScope(v))
-        return { ...out, error: cacheScopeError('--cache-scope') }
-      out.cacheScope = v
     } else if (flagOf(a, '--cache-policy')) {
       cacheFlag = true
       const name = flagOf(a, '--cache-policy')!
@@ -494,7 +488,6 @@ export async function resolveRunOptions(
       ? { cacheFlags: parsed.cacheFlags }
       : { cache: parsed.cache }),
     ...(parsed.remoteRequested ? { remoteRequested: true } : {}),
-    ...(parsed.cacheScope !== undefined ? { cacheScope: parsed.cacheScope } : {}),
     // A laptop reads the shared cache and never writes it (owner,
     // 2026-10-03); naming the remote in `--cache-policy` is asking to.
     ...(!parsed.remoteRequested && !onCI(process.env['CI'])
@@ -524,6 +517,8 @@ export async function resolveRunOptions(
     if (parsed.settings[path] !== undefined) Object.assign(opts, { [field]: parsed.settings[path] })
   }
   if (parsed.profile !== undefined) opts.profile = parsed.profile
+  // `--affected`'s base is the branch's for the cache scope too.
+  if (affectedFilter !== undefined) opts.scopeBase = affectedFilter.slice(4, -1)
 
   return opts
 }

package/src/cli/select.ts

@@ -12,6 +12,7 @@ import {
   refIsHead,
   applyFilters,
   buildPackageGraph,
+  configuredBaseBranch,
   defaultAffectedBase,
   findWorkspaceRoot,
   type FingerprintClaims,
@@ -49,7 +50,6 @@ import {
   loadCliProjects,
   loadCliWorkspace,
 } from './workspace-config.js'
-import { resolveSetting } from '../settings.js'
 
 /**
  * The projects whose tasks declare an `inputs.workspaceFiles` glob
@@ -244,20 +244,18 @@ function refusalOf(err: unknown): Refusal {
 
 /**
  * The filter `--affected[=<base>]` stands for: `...[<base>]`, the changed
- * projects and their dependents. An empty base is `run.affectedBase`
- * (its variable, then the workspace's, which a plugin's `config` stage may set from nx.json's
- * `defaultBase` or `TURBO_SCM_BASE`), then the guess.
+ * projects and their dependents. An empty base is a plugin's (`setBranch`:
+ * a pull request's base commit), else the merge base with `baseBranch`.
  */
 export async function affectedFilterFor(cwd: string, affected: string): Promise<string | Refusal> {
   const root = await findWorkspaceRoot(cwd)
   let base = affected
   if (base === '') {
-    const ws = (await loadCliWorkspace(root)).workspaceConfig
-    base = (resolveSetting('run.affectedBase', ws).value as string | undefined) ?? ''
-  }
-  if (base === '') {
+    const ws = await loadCliWorkspace(root)
     try {
-      base = await defaultAffectedBase(root)
+      base =
+        ws.branch.base ??
+        (await defaultAffectedBase(root, configuredBaseBranch(ws.workspaceConfig)))
     } catch (err) {
       if (!isUserError(err)) throw err
       return refusalOf(err)