@vzn/vx 0.0.637 → 0.0.639

package/src/{orchestrator → util}/colors.ts

@@ -13,8 +13,15 @@ const RESET = '\x1b[0m'
 const BOLD = '\x1b[1m'
 const DIM = '\x1b[2m'
 
+// State hues every report shares with the run summary.
+export const SUCCESS = '#22c55e'
+export const WARN = '#eab308'
+export const ERROR = '#ef4444'
+
 export interface ColorSupport {
   enabled: boolean
+  /** The terminal's width, read live; none off a terminal. Bars and rules fit it. */
+  readonly columns?: number | undefined
 }
 
 export interface PaintOptions {
@@ -27,16 +34,32 @@ export interface PaintOptions {
  *   NO_COLOR non-empty          → off (overrides FORCE_COLOR)
  *   FORCE_COLOR=0 or =false     → off, even on a TTY
  *   FORCE_COLOR any other value → on (the empty string too)
- *   else: on iff stdout is a TTY.
+ *   else: on iff stdout is a TTY that is not `TERM=dumb`.
  * `0` and `false` are the convention's "off" (supports-color, chalk,
  * Node); reading every non-empty value as on painted a piped CI log that
  * set `FORCE_COLOR=0` (nx#35292's bug).
  */
 export function detectColors(stream: NodeJS.WriteStream = process.stdout): ColorSupport {
-  if (process.env['NO_COLOR']) return { enabled: false }
   const force = process.env['FORCE_COLOR']
-  if (force !== undefined) return { enabled: force !== '0' && force !== 'false' }
-  return { enabled: stream.isTTY === true }
+  const enabled = process.env['NO_COLOR']
+    ? false
+    : force !== undefined
+      ? force !== '0' && force !== 'false'
+      : stream.isTTY === true && !dumbTerminal()
+  return {
+    enabled,
+    get columns() {
+      return stream.isTTY === true ? stream.columns : undefined
+    },
+  }
+}
+
+/**
+ * `TERM=dumb` (Emacs `M-x shell`, some CI log viewers) can neither paint
+ * nor move the cursor: vx prints to it as off a terminal.
+ */
+export function dumbTerminal(): boolean {
+  return process.env['TERM'] === 'dumb'
 }
 
 // Bun.color() is pure for a given (hex, mode) pair but does FFI work
@@ -66,3 +89,25 @@ export function paint(
   if (prefix.length === 0) return text
   return `${prefix}${text}${RESET}`
 }
+
+/**
+ * Identity hues for the two halves of a `project#task` id, never a status
+ * colour: one name, one hue, in every run, list and row (M, 2026-10-15:
+ * every `#build` matches every other `#build`).
+ */
+const IDENTITY_PALETTE = [
+  '#a78bfa', // violet-400
+  '#60a5fa', // blue-400
+  '#e879f9', // fuchsia-400
+  '#818cf8', // indigo-400
+  '#c084fc', // purple-400
+  '#93c5fd', // blue-300
+  '#f472b6', // pink-400
+] as const
+
+/** A project's or a target's hue: a fold of the name into the palette. */
+export function identityColor(name: string): string {
+  let h = 0
+  for (let i = 0; i < name.length; i++) h = (h * 31 + name.charCodeAt(i)) >>> 0
+  return IDENTITY_PALETTE[h % IDENTITY_PALETTE.length]!
+}

package/src/util/config-frame.ts

@@ -7,8 +7,9 @@
 import { readFileSync } from 'node:fs'
 import path from 'node:path'
 
-// `<file>: tasks.<path>[:] …`, or a top-level `<file> has unknown field …`.
-const HEAD = /^(\/[^\n]*?\/vx\.config\.[cm]?[jt]s)(?:: (tasks\.[^\s:]+)(:?))? /
+// `<file>: tasks.<path>[:] …`, or a top-level `<file> has unknown field …`,
+// from a project's vx.config or the workspace's .vx/workspace.ts.
+const HEAD = /^(\/[^\n]*?\/(?:vx\.config|\.vx\/workspace)\.[cm]?[jt]s)(?:: (tasks\.[^\s:]+)(:?))? /
 
 /**
  * The message with its file named at `line:col`, relative to `cwd`, and a
@@ -88,3 +89,31 @@ function locate(
 function escapeRe(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
+
+/** A config refusal laid out for `ui.notice`: where, what, the allowed set, the fix, the frame. */
+export interface ConfigRefusal {
+  where: string
+  problem: string
+  allowed?: string
+  fix?: string
+  frame: string
+}
+
+/** `configErrorFrame`'s answer in parts, or undefined when it has none. */
+export function configRefusal(message: string, cwd: string): ConfigRefusal | undefined {
+  const framed = configErrorFrame(message, cwd)
+  if (framed === undefined) return undefined
+  const cut = framed.indexOf('\n\n')
+  const line = framed.slice(0, cut)
+  const frame = framed.slice(cut + 2)
+  const at = /^(\S+?:\d+:\d+):? (.*)$/s.exec(line)
+  if (at === null) return { where: line, problem: '', frame }
+  const said = /^(.*?)(?: \(allowed: ([^)]*)\))?(?: — did you mean ([^?]+)\?)?$/s.exec(at[2]!)!
+  return {
+    where: at[1]!,
+    problem: said[1]!.replace(/^has /, ''),
+    ...(said[2] !== undefined ? { allowed: said[2] } : {}),
+    ...(said[3] !== undefined ? { fix: `use ${said[3]}` } : {}),
+    frame,
+  }
+}

package/src/util/errors.ts

@@ -13,6 +13,8 @@ export class UserError extends Error {
    * does not. `VX_E_REFUSED` is any refusal without a code of its own.
    */
   readonly code: string
+  /** The refusal laid out for a terminal (`refusal`); the message is the same in one line. */
+  parts?: RefusalParts
   // Two signatures, not an optional parameter: the package-api record
   // keeps the one-argument form every plugin already calls.
   constructor(message: string)
@@ -24,6 +26,36 @@ export class UserError extends Error {
   }
 }
 
+/** A refusal in parts, as `ui.notice` draws it: one fact a line, why, and the fix. */
+export interface RefusalParts {
+  /** `info`: nothing is wrong, there is just nothing to show yet. Default `error`. */
+  readonly tone?: 'info'
+  readonly headline: string
+  readonly what?: readonly string[]
+  readonly why?: string
+  readonly fix?: string
+}
+
+/**
+ * A UserError whose terminal form is `parts`. Its message, what JSON and
+ * logs carry, is `message` when given, else the parts in one line.
+ */
+export function refusal(
+  parts: RefusalParts,
+  opts: { code?: string; message?: string } = {},
+): UserError {
+  const message =
+    opts.message ??
+    [
+      [parts.headline, ...(parts.what ?? [])].join(': '),
+      ...(parts.why !== undefined ? [parts.why] : []),
+      ...(parts.fix !== undefined ? [parts.fix] : []),
+    ].join('; ')
+  const err = new UserError(message, opts.code ?? 'VX_E_REFUSED')
+  err.parts = parts
+  return err
+}
+
 // A refusal that opens with the config that caused it: the schema's
 // `<file>: tasks.<name> …` and the loader's `<file> has unknown field …`.
 const CONFIG_REFUSAL = /^\/\S*\/(?:vx\.config|\.vx\/workspace)\.[cm]?[jt]s\b/

package/src/util/git-ignored.ts

@@ -0,0 +1,143 @@
+// Whether git ignores everything an output glob can write (M, 2026-10-15):
+// a key reads only what git lists, so such an output never reaches a
+// reader's key. Asked of git, never read from a `.gitignore`: git alone
+// knows every rule source (nested files, `info/exclude`, `core.excludesFile`)
+// and that a directory holding a tracked file is not ignored.
+
+import { gitEnv } from './hide-env.js'
+import { isLiteralPattern, normalizeGlob } from './paths.js'
+import { executablePath } from './which.js'
+
+/** A directory name no ignore rule names, standing for one a task may create. */
+const FRESH = '__vx_probe__'
+
+/**
+ * The paths git is asked about for a root-relative output glob: when git
+ * ignores each, it ignores every untracked path the glob can match. `deep`:
+ * the glob reaches below them (a `dist` at any depth is asked as `dist/` and
+ * a fresh `__vx_probe__/dist/`), so a listed file it matches must be looked
+ * for too (a tracked one, or one a `!` rule takes back). Null when no few paths
+ * stand for the glob (`*.js`): undecided, the output overlaps as before.
+ * `dir`: the glob's literal directory, where a listed file it matches lies.
+ */
+export function ignoreProbes(glob: string): { paths: string[]; deep: boolean; dir: string } | null {
+  const segs = normalizeGlob(glob).split('/')
+  let i = 0
+  while (i < segs.length && isLiteralPattern(segs[i]!)) i++
+  const lit = segs.slice(0, i).join('/')
+  if (i === segs.length) return { paths: [lit], deep: false, dir: lit }
+  const at = lit === '' ? '' : `${lit}/`
+  const name = segs[i + 1]
+  if (segs[i] === '**' && name !== undefined && isLiteralPattern(name)) {
+    const leaf = i + 2 < segs.length ? `${name}/` : name
+    return { paths: [at + leaf, `${at}${FRESH}/${leaf}`], deep: true, dir: lit }
+  }
+  return lit === '' ? null : { paths: [`${lit}/`], deep: false, dir: lit }
+}
+
+const CHECK_IGNORE = ['check-ignore', '--stdin', '-z']
+
+function ignoredOf(exitCode: number, stdout: Uint8Array): Set<string> | null {
+  // 0: some ignored; 1: none; anything else (no work tree): undecided.
+  if (exitCode === 1) return new Set()
+  if (exitCode !== 0) return null
+  return new Set(
+    new TextDecoder()
+      .decode(stdout)
+      .split('\0')
+      .filter((p) => p !== ''),
+  )
+}
+
+/** The `paths` (relative to `cwd`) git ignores; null when git cannot say. */
+export async function checkIgnore(
+  cwd: string,
+  paths: readonly string[],
+): Promise<Set<string> | null> {
+  if (paths.length === 0) return new Set()
+  try {
+    const proc = Bun.spawn({
+      cmd: [executablePath('git'), ...CHECK_IGNORE],
+      env: gitEnv(),
+      cwd,
+      stdin: Buffer.from(paths.map((p) => `${p}\0`).join('')),
+      stdout: 'pipe',
+      stderr: 'ignore',
+    })
+    const stdout = await new Response(proc.stdout).bytes()
+    return ignoredOf(await proc.exited, stdout)
+  } catch {
+    return null
+  }
+}
+
+/** {@link checkIgnore} for `vx lock`, which builds its graph synchronously. */
+export function checkIgnoreSync(cwd: string, paths: readonly string[]): Set<string> | null {
+  if (paths.length === 0) return new Set()
+  try {
+    const r = Bun.spawnSync({
+      cmd: [executablePath('git'), ...CHECK_IGNORE],
+      env: gitEnv(),
+      cwd,
+      stdin: Buffer.from(paths.map((p) => `${p}\0`).join('')),
+      stdout: 'pipe',
+      stderr: 'ignore',
+    })
+    return ignoredOf(r.exitCode, r.stdout)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * What git lists under `dirs` (relative to `cwd`): tracked files and the
+ * untracked ones it does not ignore, the set a key filters. Null when git
+ * cannot say. A run has it from its enumeration; this is `vx lock`'s.
+ */
+export function listedSync(cwd: string, dirs: readonly string[]): string[] | null {
+  try {
+    const r = Bun.spawnSync({
+      cmd: [
+        executablePath('git'),
+        'ls-files',
+        '-z',
+        '--cached',
+        '--others',
+        '--exclude-standard',
+        '--',
+        ...dirs.map((d) => (d === '' ? '.' : `:(literal)${d}`)),
+      ],
+      env: gitEnv(),
+      cwd,
+      stdout: 'pipe',
+      stderr: 'ignore',
+    })
+    if (r.exitCode !== 0) return null
+    return new TextDecoder()
+      .decode(r.stdout)
+      .split('\0')
+      .filter((p) => p !== '')
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Of `globs` (root-relative), those git ignores whole: each probe ignored
+ * and, for a deep glob, no listed file it matches (`listedMatch`).
+ */
+export function wholeIgnored(
+  globs: Iterable<string>,
+  ignored: ReadonlySet<string> | null,
+  listedMatch: (glob: string) => boolean,
+): Set<string> {
+  const out = new Set<string>()
+  if (ignored === null) return out
+  for (const g of globs) {
+    const ask = ignoreProbes(g)
+    if (ask === null || !ask.paths.every((p) => ignored.has(p))) continue
+    if (ask.deep && listedMatch(g)) continue
+    out.add(g)
+  }
+  return out
+}

package/src/util/index.ts

@@ -13,6 +13,8 @@ export {
   isPermissionError,
   isUserError,
   PERMISSION_HINT,
+  refusal,
+  type RefusalParts,
   UserError,
   gitSpawnRefusal,
   isExecutableMissing,
@@ -21,7 +23,21 @@ export {
   OUT_OF_FDS_HINT,
   wantsJson,
 } from './errors.js'
-export { configErrorFrame } from './config-frame.js'
+export { configErrorFrame, configRefusal } from './config-frame.js'
+export {
+  detectColors,
+  dumbTerminal,
+  ERROR,
+  identityColor,
+  paint,
+  SUCCESS,
+  WARN,
+  type ColorSupport,
+} from './colors.js'
+export { barWidth, gradientRule } from './report.js'
+import * as ui from './ui.js'
+export { refusalNotice, sayLine, sayNotice } from './refusal-notice.js'
+export { ui }
 export { xxh3, xxh3hex } from './hash.js'
 export {
   beginRun,
@@ -60,10 +76,9 @@ export {
   claimExitForSignal,
   exitClaimedBySignal,
   killGraceMs,
-  setSettleBounds,
-  type SettleBound,
   settleWithin,
   teardownTimeoutMs,
+  testTimerMs,
 } from './settle.js'
 export { formatBytes, parseDuration, parseSize, treeBytes } from './size.js'
 export {
@@ -84,6 +99,13 @@ export { procfsIsOwn } from './procfs.js'
 export { hangupIgnored } from './hangup.js'
 export { ESSENTIAL_ENV } from './essential-env.js'
 export { gitEnv, helperEnv, hideEnvFromTasks } from './hide-env.js'
+export {
+  checkIgnore,
+  checkIgnoreSync,
+  ignoreProbes,
+  listedSync,
+  wholeIgnored,
+} from './git-ignored.js'
 export { realPath, realpathOf } from './real-path.js'
 export {
   maskedCommand,

package/src/util/refusal-notice.ts

@@ -0,0 +1,111 @@
+// Every refusal vx prints, as one `ui.notice`: the parts a refusal
+// carries, a config refusal's frame, or a plain message laid out a fact a
+// line. The flat message stays what `--format json` and logs carry.
+
+import { configRefusal } from './config-frame.js'
+import type { RefusalParts } from './errors.js'
+import { notice, print, type Block, type Inline, type Tone } from './ui.js'
+
+// A sentence break before a capital, a backtick or a paren: vx joins
+// its facts with these.
+const BREAK = /(?<=[.?!])\s+(?=[A-Z`(])/
+// `(see \`vx run --help\`)`: where to read more.
+const SEE = /\s*\(see `([^`]+)`\)/
+// `(did you mean --concurrency?)`, `. Did you mean build?`: the fix.
+const MEANT = /\s*(?:\(did you mean ([^?]+)\?\)|(?:^|[.;—]\s*)[Dd]id you mean ([^?]+)\?)/
+
+const bare = (s: string): string => s.trim().replace(/[.:]$/, '')
+
+/** A plain message in parts: its first sentence heads, each later one is a line. */
+export function messageParts(message: string): RefusalParts {
+  const [head = '', ...rest] = message.split('\n')
+  let first = head
+  const see = SEE.exec(first)
+  if (see !== null) first = first.replace(SEE, '')
+  const meant = MEANT.exec(first)
+  if (meant !== null) first = first.replace(MEANT, '')
+  const sentences = first
+    .split(BREAK)
+    .map(bare)
+    .filter((s) => s !== '')
+  const [headline = bare(first), ...what] = sentences
+  for (const l of rest) {
+    if (l.trim() !== '') what.push(...l.replace(/^ {2}/, '').split(BREAK).map(bare))
+  }
+  const fix = meant !== null ? (meant[1] ?? meant[2])!.trim() : undefined
+  return {
+    headline,
+    ...(what.length > 0 ? { what } : {}),
+    ...(see !== null ? { why: `see ${see[1]}` } : {}),
+    ...(fix !== undefined ? { fix } : {}),
+  }
+}
+
+/**
+ * `✗ <verb>  <headline>` with what is wrong, why, and the fix under it.
+ * `headline` set: that is the status line and the refusal's own headline
+ * joins what is wrong (`vx lock  lock not written`).
+ */
+export function refusalNotice(
+  verb: string,
+  message: string,
+  parts?: RefusalParts,
+  opts: { headline?: string; cwd?: string } = {},
+): Block {
+  const c = parts === undefined ? configRefusal(message, opts.cwd ?? process.cwd()) : undefined
+  if (c !== undefined) {
+    const what: Inline[] = [{ style: 'bold', text: c.where }, c.problem]
+    return notice({
+      tone: 'error',
+      verb,
+      headline: opts.headline ?? 'config refused',
+      what,
+      ...(c.allowed !== undefined ? { why: `allowed: ${c.allowed}` } : {}),
+      code: c.frame,
+      ...(c.fix !== undefined ? { fix: c.fix } : {}),
+    })
+  }
+  const p = parts ?? messageParts(message)
+  const what = opts.headline !== undefined ? [p.headline, ...(p.what ?? [])] : (p.what ?? [])
+  return notice({
+    tone: p.tone ?? 'error',
+    verb,
+    headline: opts.headline ?? p.headline,
+    ...(what.length > 0 ? { what } : {}),
+    ...(p.why !== undefined ? { why: p.why } : {}),
+    ...(p.fix !== undefined ? { fix: p.fix } : {}),
+  })
+}
+
+/** A message of `tone` from `verb`, a fact a line. */
+function messageNotice(tone: Tone, verb: string, message: string): Block {
+  const p = messageParts(message)
+  return notice({
+    tone,
+    verb,
+    headline: p.headline,
+    ...(p.what !== undefined ? { what: p.what } : {}),
+    ...(p.why !== undefined ? { why: p.why } : {}),
+    ...(p.fix !== undefined ? { fix: p.fix } : {}),
+  })
+}
+
+/** A line that may open with its verb (`vx why: …`), as `messageNotice` draws it. */
+export function lineNotice(tone: Tone, line: string, verb = 'vx'): Block {
+  const named = /^(vx(?: [a-z][\w-]*)?): /.exec(line)
+  return messageNotice(
+    tone,
+    named?.[1] ?? verb,
+    named === null ? line : line.slice(named[0].length),
+  )
+}
+
+/** `messageNotice` on stderr. */
+export function sayNotice(tone: Tone, verb: string, message: string): void {
+  print('err', messageNotice(tone, verb, message))
+}
+
+/** `lineNotice` on stderr. */
+export function sayLine(tone: Tone, line: string, verb = 'vx'): void {
+  print('err', lineNotice(tone, line, verb))
+}

package/src/util/report.ts

@@ -0,0 +1,39 @@
+import { paint, type ColorSupport } from './colors.js'
+
+// Brand gradient for the rule: identity violet → pink (the project /
+// task hues), faded across the dash run. Plain dashes when colors
+// are off.
+const GRADIENT_FROM = [0xa7, 0x8b, 0xfa] as const
+const GRADIENT_TO = [0xf4, 0x72, 0xb6] as const
+// The bars' label column: 2 indent + 8 label + 2 gap.
+const LABEL = 12
+
+/** A meter's cells: 50, or fewer so the bar fits a narrower terminal. */
+export function barWidth(colors: ColorSupport): number {
+  const columns = colors.columns
+  return columns === undefined ? 50 : Math.max(10, Math.min(50, columns - LABEL))
+}
+
+/** `─ <mark> ` + dashes, flush with the bars. Shared by the run summary and every report. */
+export function gradientRule(colors: ColorSupport, mark = 'vx'): string {
+  const head = `─ `
+  const width = LABEL + barWidth(colors)
+  const dashes = '─'.repeat(Math.max(8, width - 3 - mark.length))
+  if (!colors.enabled) return `${head}${mark} ${dashes}`
+  const chunks = 8
+  // The gradient spans the rule as if its mark were `vx`.
+  const per = Math.ceil((width - 5) / chunks)
+  let out = ''
+  for (let i = 0; i < chunks; i++) {
+    const seg = dashes.slice(i * per, (i + 1) * per)
+    if (seg.length === 0) break
+    const f = i / (chunks - 1)
+    const hex = `#${GRADIENT_FROM.map((c, j) =>
+      Math.round(c + (GRADIENT_TO[j]! - c) * f)
+        .toString(16)
+        .padStart(2, '0'),
+    ).join('')}`
+    out += paint(hex, seg, colors)
+  }
+  return `${paint(`#${GRADIENT_FROM.map((c) => c.toString(16).padStart(2, '0')).join('')}`, head, colors)}${paint('', mark, colors, { bold: true })} ${out}`
+}

package/src/util/settle.ts

@@ -7,54 +7,29 @@ import { parseDuration } from './size.js'
 /** Default upper bound on one end-of-run flush/teardown await. */
 const DEFAULT_TIMEOUT_MS = 3000
 
-/** A bound the run resolved from its flag or `.vx/workspace`. */
-export interface SettleBound {
-  readonly ms: number
-  readonly from: 'flag' | 'workspace'
-}
-
-let teardownSet: SettleBound | undefined
-let killGraceSet: SettleBound | undefined
-
-/**
- * The run's `run.teardownTimeout` and `run.killGrace` from its flag or
- * workspace (the orchestrator resolves them; util sits below settings).
- * The variable, read per call, sits between the two, so a test drives the
- * deadline instead of waiting it out.
- */
-export function setSettleBounds(b: { teardown?: SettleBound; killGrace?: SettleBound }): void {
-  teardownSet = b.teardown
-  killGraceSet = b.killGrace
-}
-
 /**
- * A flag's bound, else the variable's (a positive duration inside the
- * timer's range: the CLI refuses any other before a run, and an embedder's
- * falls back), else the workspace's.
+ * A timer a test shortens: `VX_TEST_<name>`, a duration. Undocumented and
+ * in no settings table: the suites that prove a deadline drive it instead
+ * of waiting the real one out. Zero only where `zero` allows it.
  */
-function bound(name: string, set: SettleBound | undefined, zero = false): number | undefined {
-  if (set?.from === 'flag') return set.ms
-  const raw = process.env[name]
-  if (raw !== undefined && raw !== '') {
-    const n = parseDuration(raw)
-    if (n !== null && (n > 0 || zero) && n <= MAX_TIMEOUT_MS) return n
-  }
-  return set?.ms
+export function testTimerMs(name: string, defaultMs: number, zero = false): number {
+  const raw = process.env[`VX_TEST_${name}`]
+  if (raw === undefined || raw === '') return defaultMs
+  const n = parseDuration(raw)
+  return n !== null && (n > 0 || (zero && n === 0)) && n <= MAX_TIMEOUT_MS ? n : defaultMs
 }
 
 /**
- * The bound on one end-of-run flush or teardown (`run.teardownTimeout`).
- * There is no "no limit": the deadline exists so a plugin's flush cannot
- * hold the run's exit hostage, so a timer past the platform's range (which
- * would fire at once and drop every buffered record) is no value.
+ * The bound on one end-of-run flush or teardown: a plugin's flush cannot
+ * hold the run's exit hostage.
  */
 export function teardownTimeoutMs(): number {
-  return bound('VX_RUN_TEARDOWN_TIMEOUT', teardownSet, true) ?? DEFAULT_TIMEOUT_MS
+  return testTimerMs('TEARDOWN_TIMEOUT', DEFAULT_TIMEOUT_MS, true)
 }
 
 /**
- * The SIGTERM→SIGKILL grace a run grants a child that ignores SIGTERM
- * (`run.killGrace`): the one-shot timeout escalation (`exec/runner.ts`),
+ * The SIGTERM→SIGKILL grace a run grants a child that ignores SIGTERM:
+ * the one-shot timeout escalation (`exec/runner.ts`),
  * the signal teardown (`orchestrator/signals.ts`) and the end-of-run
  * persistent shutdown (`orchestrator/persistent.ts`) share it. Two seconds
  * is generous for a real server's cleanup and is what every run waits when
@@ -63,7 +38,7 @@ export function teardownTimeoutMs(): number {
  * 200 ms grace proves too.
  */
 export function killGraceMs(defaultMs: number): number {
-  return bound('VX_RUN_KILL_GRACE', killGraceSet) ?? defaultMs
+  return testTimerMs('KILL_GRACE', defaultMs)
 }
 
 /**

package/src/util/tail.ts

@@ -6,7 +6,7 @@
 // needs a cap, and the cap has to be honest — a truncated log that reads as
 // complete is worse than one that says what it lost.
 //
-// `orchestrator/logger.ts` is the sole holder: it registers a tail per
+// `report/logger.ts` is the sole holder: it registers a tail per
 // persistent task at taskStart and keeps one for the rest of the run, so a
 // single mechanism covers both the pre-ready window and everything after.
 // `exec/runner.ts` used to keep a SECOND pre-ready copy fed from the same