jackherd 1.9.0 → 1.10.0

package/src/watch/skill-change.ts

@@ -1,13 +1,40 @@
-import { mkdirSync, readFileSync } from 'node:fs'
+import { readdirSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
+import { ensurePrivateDirectory, writePrivateFile } from '../../kit/hooks/hooks/shared/private-directory'
 import { errorText } from '../plans/error-text'
-import { changedSections, SKILL_CHANGE, type SkillChange, skillChangeLine } from '../version/skill-diff'
+import {
+  changedSections,
+  orchestrateChangeLines,
+  REFERENCE_CHANGE,
+  type ReferenceChange,
+  type ReferenceDelta,
+  referenceChanges,
+  SKILL_CHANGE,
+  type SkillChange,
+} from '../version/skill-diff'
 import type { StartedKit } from '../version/started-kit'
-import { writePrivate } from './watcher-lock'
+import { ORCHESTRATE_SKILL_NAME } from './reference-paths'
+
+/** The orchestrate skill as the kit ships it: its text and its reference files by name. */
+export type OrchestrateSnapshot = { skill: string; references: Record<string, string> }
+
+/** The change since a snapshot: the skill itself, and each reference that changed, is new or is gone. */
+export type OrchestrateChange = { skill: SkillChange; references: ReferenceChange[] }
+
+type WrittenDiff = { text: string; path: string }
+
+/** A reference name that stays a plain Markdown file name, since it goes into the name of a diff file. */
+const REFERENCE_FILE = /^[A-Za-z0-9][A-Za-z0-9._-]*\.md$/
+
+const skillDirectory = (packageRoot: string): string =>
+  join(packageRoot, 'kit', 'workflow', 'skills', ORCHESTRATE_SKILL_NAME)
 
 /** The kit's own text of the orchestrate skill, with its placeholders, inside the package. */
-export const orchestrateSkillPath = (packageRoot: string): string =>
-  join(packageRoot, 'kit', 'workflow', 'skills', 'orchestrate', 'SKILL.md')
+export const orchestrateSkillPath = (packageRoot: string): string => join(skillDirectory(packageRoot), 'SKILL.md')
+
+/** The directory of the skill's reference files in the kit at `packageRoot`. */
+export const orchestrateReferencesPath = (packageRoot: string): string =>
+  join(skillDirectory(packageRoot), 'references')
 
 /** The orchestrate skill's text in the kit at `packageRoot`; null when it cannot be read. */
 export const readOrchestrateSkill = (packageRoot: string): string | null => {
@@ -18,10 +45,45 @@ export const readOrchestrateSkill = (packageRoot: string): string | null => {
   }
 }
 
+/** The skill's reference files by name (every `*.md` file below `references/`); none when the directory is missing. */
+export const readOrchestrateReferences = (packageRoot: string): Record<string, string> => {
+  const directory = orchestrateReferencesPath(packageRoot)
+  try {
+    const names = readdirSync(directory, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && REFERENCE_FILE.test(entry.name))
+      .map((entry) => entry.name)
+    return Object.fromEntries(names.map((name) => [name, readFileSync(join(directory, name), 'utf8')]))
+  } catch {
+    return {}
+  }
+}
+
+/** The skill and its references in the kit at `packageRoot`; null when the skill cannot be read. */
+export const readOrchestrateSnapshot = (packageRoot: string): OrchestrateSnapshot | null => {
+  const skill = readOrchestrateSkill(packageRoot)
+  return skill === null ? null : { skill, references: readOrchestrateReferences(packageRoot) }
+}
+
+/**
+ * The unified diff (`git diff --no-index`) between `before` and the file at `currentPath`, written to `directory` as
+ * `<name>.diff`; null when git has none to give.
+ */
+const writeDiff = (before: string, currentPath: string, directory: string, name: string): WrittenDiff | null => {
+  ensurePrivateDirectory(directory)
+  const beforePath = join(directory, `${name}.before.md`)
+  writePrivateFile(beforePath, before)
+  const diff = Bun.spawnSync(['git', 'diff', '--no-index', '--unified=3', '--', beforePath, currentPath])
+  const text = diff.stdout.toString()
+  if (diff.exitCode !== 1 || text === '') return null
+  const path = join(directory, `${name}.diff`)
+  writePrivateFile(path, text)
+  return { text, path }
+}
+
 /**
  * The change of the orchestrate skill between `snapshot` and the kit at `packageRoot` now: the unified diff
- * (`git diff --no-index`) written to `directory` and the sections it touches, so the coordinator reads the change
- * instead of the whole skill. Unavailable without a snapshot, a readable skill or a diff.
+ * written to `directory` and the sections it touches, so the coordinator reads the change instead of the whole
+ * skill. Unavailable without a snapshot, a readable skill or a diff.
  */
 export const skillChangeSince = (snapshot: string | null, packageRoot: string, directory: string): SkillChange => {
   if (snapshot === null) return { kind: SKILL_CHANGE.unavailable, reason: 'no snapshot at start' }
@@ -29,33 +91,63 @@ export const skillChangeSince = (snapshot: string | null, packageRoot: string, d
   if (current === null) return { kind: SKILL_CHANGE.unavailable, reason: 'skill not readable' }
   if (current === snapshot) return { kind: SKILL_CHANGE.unchanged }
   try {
-    mkdirSync(directory, { recursive: true, mode: 0o700 })
-    const before = join(directory, 'orchestrate-skill.before.md')
-    writePrivate(before, snapshot)
-    const diff = Bun.spawnSync([
-      'git',
-      'diff',
-      '--no-index',
-      '--unified=3',
-      '--',
-      before,
-      orchestrateSkillPath(packageRoot),
-    ])
-    const text = diff.stdout.toString()
-    if (diff.exitCode !== 1 || text === '')
-      return { kind: SKILL_CHANGE.unavailable, reason: `git diff exit ${diff.exitCode}` }
-    const diffPath = join(directory, 'orchestrate-skill.diff')
-    writePrivate(diffPath, text)
-    return { kind: SKILL_CHANGE.changed, sections: changedSections(current, text), diffPath }
+    const diff = writeDiff(snapshot, orchestrateSkillPath(packageRoot), directory, `${ORCHESTRATE_SKILL_NAME}-skill`)
+    if (diff === null) return { kind: SKILL_CHANGE.unavailable, reason: 'git diff gave none' }
+    return { kind: SKILL_CHANGE.changed, sections: changedSections(current, diff.text), diffPath: diff.path }
   } catch (error) {
     return { kind: SKILL_CHANGE.unavailable, reason: errorText(error) }
   }
 }
 
-/** The line about the orchestrate skill after a kit update, for the kit the watcher started with. */
-export const skillLineFor = (kit: StartedKit | null, snapshot: string | null, directory: string): string =>
-  skillChangeLine(
-    kit
-      ? skillChangeSince(snapshot, kit.packageRoot, directory)
-      : { kind: SKILL_CHANGE.unavailable, reason: 'kit not located' },
-  )
+const referenceChangeOf = (
+  delta: ReferenceDelta,
+  snapshot: OrchestrateSnapshot,
+  packageRoot: string,
+  directory: string,
+): ReferenceChange => {
+  const path = join(orchestrateReferencesPath(packageRoot), delta.name)
+  if (delta.kind === REFERENCE_CHANGE.deleted) return { name: delta.name, kind: REFERENCE_CHANGE.deleted }
+  if (delta.kind === REFERENCE_CHANGE.added) return { name: delta.name, kind: REFERENCE_CHANGE.added, path }
+  try {
+    const diff = writeDiff(
+      snapshot.references[delta.name] ?? '',
+      path,
+      directory,
+      `${ORCHESTRATE_SKILL_NAME}-reference-${delta.name}`,
+    )
+    return { name: delta.name, kind: REFERENCE_CHANGE.changed, diffPath: diff?.path ?? null }
+  } catch {
+    return { name: delta.name, kind: REFERENCE_CHANGE.changed, diffPath: null }
+  }
+}
+
+/**
+ * The change of the skill and of its references since `snapshot`. The references are judged only while the skill
+ * can be read, so a package being replaced does not make every reference look deleted.
+ */
+export const orchestrateChangeSince = (
+  snapshot: OrchestrateSnapshot | null,
+  packageRoot: string,
+  directory: string,
+): OrchestrateChange => {
+  const skill = skillChangeSince(snapshot?.skill ?? null, packageRoot, directory)
+  if (snapshot === null || skill.kind === SKILL_CHANGE.unavailable) return { skill, references: [] }
+  const deltas = referenceChanges(snapshot.references, readOrchestrateReferences(packageRoot))
+  return { skill, references: deltas.map((delta) => referenceChangeOf(delta, snapshot, packageRoot, directory)) }
+}
+
+/**
+ * The lines about the orchestrate skill after a kit update, for the kit the watcher started with: the skill's, then one
+ * per changed, new or deleted reference, joined by line breaks.
+ */
+export const skillLineFor = (
+  kit: StartedKit | null,
+  snapshot: OrchestrateSnapshot | null,
+  directory: string,
+): string => {
+  if (kit === null) {
+    return orchestrateChangeLines({ kind: SKILL_CHANGE.unavailable, reason: 'kit not located' }, []).join('\n')
+  }
+  const { skill, references } = orchestrateChangeSince(snapshot, kit.packageRoot, directory)
+  return orchestrateChangeLines(skill, references).join('\n')
+}

package/src/watch/source-change.ts

@@ -0,0 +1,48 @@
+import { existsSync, type FSWatcher, watch } from 'node:fs'
+import { join } from 'node:path'
+import { isRestartTrigger, RESTART_DEBOUNCE_MS } from '../plans/restart-decision'
+
+/** The changes to a package's `src/` seen so far: when the last one came (null before any), and the watch to close. */
+export type SourceChanges = { lastChangeAt: () => number | null; close: () => void }
+
+/**
+ * Whether the package at `packageRoot` is a checkout's own source rather than an installed copy, which lies under a
+ * `node_modules` directory. Only the source changes under a running process (a pull or a fast-forward of the
+ * checkout); an installed copy changes by a reinstall, which its version shows.
+ */
+export const runsFromSource = (packageRoot: string): boolean => !packageRoot.split(/[\\/]/).includes('node_modules')
+
+/** Whether a change seen at `lastChangeAt` is over: no further change for the window in which the herd collapses a burst into one restart. */
+export const sourceChangeSettled = (lastChangeAt: number | null, now: number): boolean =>
+  lastChangeAt !== null && now - lastChangeAt >= RESTART_DEBOUNCE_MS
+
+const NO_CHANGES: SourceChanges = { lastChangeAt: () => null, close: () => {} }
+
+/** The watch of `directory`, closed on a later error (`EMFILE` while dev servers run), which would else end the process. */
+const watcherOf = (directory: string, onChange: () => void): FSWatcher | null => {
+  try {
+    const watcher = watch(directory, { recursive: true }, (_event, name) => {
+      if (name && isRestartTrigger(name.toString())) onChange()
+    })
+    watcher.on('error', () => watcher.close())
+    return watcher
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Follows the source files below `<packageRoot>/src` with the trigger the herd restarts on (`isRestartTrigger`: a
+ * `.ts` file, tests and declarations left out), stamping each change with `clock`. A package without `src/`, or one
+ * the platform cannot watch, is followed for nothing.
+ */
+export const watchSourceChanges = (packageRoot: string, clock: () => number = Date.now): SourceChanges => {
+  const directory = join(packageRoot, 'src')
+  if (!existsSync(directory)) return NO_CHANGES
+  let lastChangeAt: number | null = null
+  const watcher = watcherOf(directory, () => {
+    lastChangeAt = clock()
+  })
+  if (!watcher) return NO_CHANGES
+  return { lastChangeAt: () => lastChangeAt, close: () => watcher.close() }
+}

package/src/watch/sources.ts

@@ -94,6 +94,8 @@ export type TicketRecord = { url: string | null; status: string | null; changedA
 export type SourceRecord = {
   seen: SeenEntry[] | null
   failingSince: number | null
+  /** When its last run started, failed or not (`isSourceDue`); absent in a state written before it was kept: never. */
+  ranAt?: number
   /** Of a ticket source only: the entries of its last successful run by id. */
   tickets?: Record<string, TicketRecord>
 }
@@ -248,7 +250,7 @@ export const parseSourceOutput = (
   return { ok: true, items: uniqueById(items as SourceItem[]) }
 }
 
-/** Whether a source last started at `lastRunAt` (undefined: never in this process) is due again at `now`. */
+/** Whether a source last started at `lastRunAt` (`SourceRecord.ranAt`; undefined: never) is due again at `now`. */
 export const isSourceDue = (lastRunAt: number | undefined, everyMinutes: number, now: number): boolean =>
   lastRunAt === undefined || now - lastRunAt >= everyMinutes * MINUTE_MS
 
@@ -342,8 +344,8 @@ const seenAfter = (seen: readonly SeenEntry[], items: readonly SourceItem[]): Se
 
 const recordOf = (record: SourceRecord | undefined, result: SourceResult, now: number): SourceRecord =>
   result.ok
-    ? { seen: seenAfter(record?.seen ?? [], result.items), failingSince: null }
-    : { seen: record?.seen ?? null, failingSince: record?.failingSince ?? now }
+    ? { seen: seenAfter(record?.seen ?? [], result.items), failingSince: null, ranAt: now }
+    : { seen: record?.seen ?? null, failingSince: record?.failingSince ?? now, ranAt: now }
 
 /**
  * The state after `runs` for the sources configured as `names`: a run records its outcome, a source without a run keeps
@@ -385,6 +387,7 @@ const isSourceRecord = (value: unknown): boolean =>
   isRecord(value) &&
   (value.seen === null || (Array.isArray(value.seen) && value.seen.every(isSeenEntry))) &&
   (value.failingSince === null || typeof value.failingSince === 'number') &&
+  (value.ranAt === undefined || typeof value.ranAt === 'number') &&
   (value.tickets === undefined || (isRecord(value.tickets) && Object.values(value.tickets).every(isTicketRecord)))
 
 export const isSourceState = (value: unknown): value is SourceState =>

package/src/watch/stream-output.ts

@@ -17,7 +17,8 @@ const laneState = (lane: string, current: LaneSnapshot, notes: LaneNotes, rests:
 
 /**
  * The heartbeat of a stream, as one line, since every line of a stream reaches the coordinator as a
- * message of its own: `=== heartbeat <time> · <lane> <status> · …`.
+ * message of its own: `=== heartbeat <time> · <lane> <status> · …`. `standing` are the lines that stay until
+ * their cause is gone (what waits on the user, the main checkout behind its base), each one entry at the end.
  */
 export const streamHeartbeatLine = (
   time: string,
@@ -25,12 +26,12 @@ export const streamHeartbeatLine = (
   current: LaneSnapshot,
   notes: LaneNotes,
   rests: LaneNotes = {},
-  waiting: string | null = null,
+  standing: readonly string[] = [],
 ): string => {
   const states = lanes.map((lane) => laneState(lane, current, notes, rests))
   return [
     `=== ${WATCH_EVENT.heartbeat} ${terminalSafe(time)}`,
     ...(states.length > 0 ? states : ['no lanes']),
-    ...(waiting === null ? [] : [terminalSafe(waiting).replaceAll(SEPARATOR, ' / ')]),
+    ...standing.map((line) => terminalSafe(line).replaceAll(SEPARATOR, ' / ')),
   ].join(SEPARATOR)
 }

package/src/watch/task-parallel-auto.ts

@@ -0,0 +1,208 @@
+import { ALWAYS_ASK_PATHS, ENV_PATHS, MIGRATION_PATHS } from '../../kit/hooks/hooks/merge-guard/always-ask'
+import { MAX_AUTO_WINDOW_DAYS, windowDays } from '../config/auto-window'
+import type { JackherdConfig } from '../config/schema'
+import { twoDigits } from '../plan-format/clock'
+import {
+  AUTO_VERDICT,
+  type AutoVerdict,
+  GLOB_CHARACTER,
+  pathsOfTask,
+  type TaskParallelInput,
+  type TaskParallelProposal,
+} from './task-parallel'
+
+/** The window of `watch.parallelTasks.auto`: two `YYYY-MM-DD` days, both included. */
+export type AutoWindow = NonNullable<JackherdConfig['watch']['parallelTasks']['auto']>
+
+/** The switch, unset when the project has none, and every path a task may not name to start without a question. */
+export type AutoSettings = {
+  auto?: AutoWindow
+  askPaths: readonly string[]
+  /** `watch.parallelTasks.maxTokens` of the same config as the switch. */
+  maxTokens: number
+  /** Whether the repository holds a path of `DATA_PATHS` at or below a directory, relative to its root. */
+  holdsDataPath: (directory: string) => boolean
+}
+
+export const MAX_AUTO_EXTRA_AGENTS = 2
+
+/**
+ * The paths that always ask whose work takes effect before the merge: a migration may be pushed and a secret written
+ * while the pull request is open, so the merge guard comes too late. A directory of a writes set that holds one asks.
+ */
+export const DATA_PATHS: readonly string[] = [...MIGRATION_PATHS, ...ENV_PATHS]
+
+/**
+ * The paths that always ask (`ALWAYS_ASK_PATHS`, plus every package.json and CHANGELOG.md, which the merge guard
+ * reads apart): work on them is tier C and never starts without a question. The project's `guard.alwaysAsk` come on top.
+ */
+export const AUTO_ASK_PATHS: readonly string[] = [...ALWAYS_ASK_PATHS, '**/package.json', '**/CHANGELOG.md']
+
+const PROBE = 'x'
+/** Shorter literal pieces of a pattern (`**`, `*`) say nothing about a task's text. */
+const MIN_FRAGMENT = 3
+/**
+ * A path that may leave the repository or hide where it lies: absolute, from home, a variable, a drive, a backslash, or
+ * a `.` or `..` segment.
+ */
+const OUTSIDE_REPOSITORY = /^[/~]|^[A-Za-z]:|[\\%$]|(?:^|\/)\.{1,2}(?:\/|$)/
+
+/** Whether a path may leave the repository or hide where it lies (`OUTSIDE_REPOSITORY`). */
+export const leavesRepository = (path: string): boolean => OUTSIDE_REPOSITORY.test(path)
+
+const hasFileName = (path: string): boolean => /\.[^/]*$/.test(path.slice(path.lastIndexOf('/') + 1))
+
+/** A path up to the directory its first wildcard lies in; a path without one is itself. */
+const literalPrefix = (path: string): string => {
+  const glob = path.search(GLOB_CHARACTER)
+  return glob === -1 ? path : path.slice(0, Math.max(path.lastIndexOf('/', glob), 0))
+}
+
+/** Whether one path lies inside the other or both are the same; `''` is the whole repository. */
+const nested = (left: string, right: string): boolean =>
+  left === '' || right === '' || left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`)
+
+const matchesAnyPattern = (path: string, patterns: readonly string[]): boolean => {
+  const lower = path.toLowerCase()
+  const globs = patterns.map((pattern) => new Bun.Glob(pattern.toLowerCase()))
+  return globs.some((glob) => glob.match(lower) || glob.match(`${lower}/${PROBE}`))
+}
+
+/**
+ * Whether a path a task names may touch a path that always asks. Only a named file inside a directory of the
+ * repository is matched (in lower case, as the merge guard does): a path that may leave the repository, a directory,
+ * a glob or a bare file name could reach such a path somewhere, so it counts as one. A dotted name is also matched as
+ * a directory, so `.claude` counts like `.claude/**`.
+ */
+export const touchesAskPath = (path: string, patterns: readonly string[]): boolean => {
+  if (OUTSIDE_REPOSITORY.test(path) || !path.includes('/') || GLOB_CHARACTER.test(path) || !hasFileName(path))
+    return true
+  return matchesAnyPattern(path, patterns)
+}
+
+/** Whether a path relative to the repository root is, or lies in, one of `DATA_PATHS`. */
+export const isDataPath = (path: string): boolean => matchesAnyPattern(path, DATA_PATHS)
+
+/**
+ * Whether an entry of a phase's writes set may touch a path that always asks: the whole repository, a path that may
+ * leave it, an entry a pattern matches as written (`packages/*\/package.json`), a directory or glob that overlaps a
+ * pattern anchored at the root (`.claude/**`), or one under whose literal part the repository holds a migration or an
+ * env file (`holdsDataPath`). Other patterns that hold anywhere (`**\/package.json`) are not looked for below a
+ * directory: their work waits for the merge guard.
+ */
+export const writesTouchAskPath = (
+  entry: string,
+  patterns: readonly string[],
+  holdsDataPath: (directory: string) => boolean,
+): boolean => {
+  if (entry === '' || OUTSIDE_REPOSITORY.test(entry)) return true
+  if (matchesAnyPattern(entry, patterns)) return true
+  if (!GLOB_CHARACTER.test(entry) && hasFileName(entry)) return false
+  const literal = literalPrefix(entry.toLowerCase())
+  const rootAnchored = patterns.filter((pattern) => !pattern.startsWith('**'))
+  return (
+    rootAnchored.some((pattern) => nested(literal, literalPrefix(pattern.toLowerCase()))) ||
+    holdsDataPath(literalPrefix(entry))
+  )
+}
+
+/** The literal pieces of the patterns (`.claude`, `package.json`, `migrations`), in lower case. */
+const fragmentsOf = (patterns: readonly string[]): string[] => [
+  ...new Set(
+    patterns.flatMap((pattern) =>
+      pattern
+        .toLowerCase()
+        .split(/[/*?[\]{}]+/)
+        .filter((piece) => piece.length >= MIN_FRAGMENT),
+    ),
+  ),
+]
+
+/** The local calendar day of `at`, as `YYYY-MM-DD`. */
+export const localDay = (at: number): string => {
+  const date = new Date(at)
+  return `${date.getFullYear()}-${twoDigits(date.getMonth() + 1)}-${twoDigits(date.getDate())}`
+}
+
+const windowRefusal = (auto: AutoWindow, today: string): string | null => {
+  if (!(windowDays(auto.since, auto.until) <= MAX_AUTO_WINDOW_DAYS))
+    return `window longer than ${MAX_AUTO_WINDOW_DAYS} days`
+  if (today < auto.since) return `off until ${auto.since}`
+  if (today > auto.until) return `ended ${auto.until}`
+  return null
+}
+
+const extraAgentsAtOnce = (input: TaskParallelInput, proposal: TaskParallelProposal): number =>
+  Math.max(input.active.length - 1, 0) + proposal.extraAgents
+
+const taskPathRefusal = (proposal: TaskParallelProposal, patterns: readonly string[]): string | null => {
+  const path = proposal.tasks.flatMap((task) => pathsOfTask(task.text)).find((entry) => touchesAskPath(entry, patterns))
+  return path === undefined ? null : `a task names ${path}, which always asks`
+}
+
+/** A task's text may name such a path without backticks or extension (`.husky/pre-commit`, `CODEOWNERS`). */
+const taskTextRefusal = (proposal: TaskParallelProposal, patterns: readonly string[]): string | null => {
+  const fragments = fragmentsOf(patterns)
+  const fragment = proposal.tasks
+    .map((task) => task.text.toLowerCase())
+    .flatMap((text) => fragments.filter((piece) => text.includes(piece)))[0]
+  return fragment === undefined ? null : `a task mentions ${fragment}, which always asks`
+}
+
+/**
+ * The task's text does not bind the subagent; its phase's writes set is what it may write, read from the plan at the
+ * base branch, so the lane's own copy widens nothing. A phase the base branch does not have asks.
+ */
+const phaseWritesRefusal = (input: TaskParallelInput, proposal: TaskParallelProposal, settings: AutoSettings) => {
+  for (const task of proposal.tasks) {
+    const writes = input.baseWrites[task.phase]
+    if (writes === undefined || writes.length === 0) return `phase ${task.phase} has no writes set on the base branch`
+    const entry = writes.find((path) => writesTouchAskPath(path, settings.askPaths, settings.holdsDataPath))
+    if (entry !== undefined)
+      return `phase ${task.phase} writes ${entry === '' ? 'the whole repository' : entry}, which always asks`
+  }
+  return null
+}
+
+const limitRefusal = (input: TaskParallelInput, proposal: TaskParallelProposal, settings: AutoSettings) => {
+  const { askPaths: patterns, maxTokens } = settings
+  if (input.active.length === 0) return 'no running work in the lane'
+  const atOnce = extraAgentsAtOnce(input, proposal)
+  if (atOnce > MAX_AUTO_EXTRA_AGENTS) return `${atOnce} extra agents at once, at most ${MAX_AUTO_EXTRA_AGENTS}`
+  if (proposal.estimateTokens >= Math.min(input.thresholdTokens, maxTokens)) return 'over the token limit'
+  return (
+    taskPathRefusal(proposal, patterns) ??
+    taskTextRefusal(proposal, patterns) ??
+    phaseWritesRefusal(input, proposal, settings)
+  )
+}
+
+/**
+ * Whether the coordinator may start `proposal` without asking: the switch holds on `today`, the lane has running work
+ * (the extra agents are its subagents, never a new lane), at most two extra agents run at once with the subagents
+ * already running, the cost stays under the limit, and neither a task's paths, its text nor its phase's writes set
+ * reaches a path that always asks. Every doubt asks.
+ */
+export const autoVerdict = (
+  input: TaskParallelInput,
+  proposal: TaskParallelProposal,
+  settings: AutoSettings,
+  today: string,
+): AutoVerdict => {
+  if (settings.auto === undefined) return { kind: AUTO_VERDICT.off }
+  const reason = windowRefusal(settings.auto, today) ?? limitRefusal(input, proposal, settings)
+  return reason === null ? { kind: AUTO_VERDICT.auto, until: settings.auto.until } : { kind: AUTO_VERDICT.asks, reason }
+}
+
+/**
+ * The line that the switch ended, once per last day: `ended` is the last day already reported (null before any), the
+ * answer the one to keep. Nothing while the switch holds or is unset.
+ */
+export const autoEndedReport = (
+  ended: string | null,
+  auto: AutoWindow | undefined,
+  today: string,
+): { ended: string | null; line: string | null } =>
+  auto === undefined || today <= auto.until || ended === auto.until
+    ? { ended, line: null }
+    : { ended: auto.until, line: `parallel tasks auto ended ${auto.until}: every proposal asks again` }

package/src/watch/task-parallel-data-paths.ts

@@ -0,0 +1,46 @@
+import { readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { isDataPath, leavesRepository } from './task-parallel-auto'
+
+type Child = { path: string; searched: boolean }
+
+/** Directories a search below a writes entry skips: installed packages and the repository's own store. */
+const SKIPPED = new Set(['node_modules', '.git'])
+/** How many entries one search reads before it gives up; a directory larger than this counts as holding one. */
+const MAX_ENTRIES = 20_000
+
+/** The children of a directory below the root, none when it cannot be read; `searched` marks a directory to descend. */
+const childrenOf = (root: string, directory: string): Child[] => {
+  try {
+    return readdirSync(join(root, directory), { withFileTypes: true }).map((entry) => ({
+      path: directory === '' ? entry.name : `${directory}/${entry.name}`,
+      searched: entry.isDirectory() && !SKIPPED.has(entry.name),
+    }))
+  } catch {
+    return []
+  }
+}
+
+/** Whether a path below `relative` is a data path; `true` once the search has read more than `limit` entries. */
+const searchBelow = (root: string, relative: string, limit: number): boolean => {
+  const pending = [relative]
+  let read = 0
+  while (pending.length > 0) {
+    for (const child of childrenOf(root, pending.pop() ?? '')) {
+      read += 1
+      if (read > limit || isDataPath(child.path)) return true
+      if (child.searched) pending.push(child.path)
+    }
+  }
+  return false
+}
+
+/**
+ * `holdsDataPath` for the repository at `root`: whether a migration or an env file lies at or below a directory,
+ * read from the file system at each call. A path that may leave the repository counts, a directory that does not exist
+ * holds nothing, and a search that reads more than `limit` entries counts as a hit, so a doubt asks.
+ */
+export const holdsDataPathIn =
+  (root: string, limit: number = MAX_ENTRIES) =>
+  (directory: string): boolean =>
+    leavesRepository(directory) || isDataPath(directory) || searchBelow(root, directory, limit)

package/src/watch/task-parallel-input.ts

@@ -1,5 +1,5 @@
 import { isPhaseFinished, isPhaseOpen, type PlanLanguage, type PlanPhase, parsePlanPhases } from '../plan-format'
-import { type PhaseDependency, parseDependencyTable } from '../plan-format/dependencies'
+import { type PhaseDependency, parseDependencyTable, writeSetOf } from '../plan-format/dependencies'
 import { matchSignals, type OpenPlanTask } from '../task-signals/matcher'
 import type { TaskSignal } from '../task-signals/types'
 import type { ActiveWork, OpenTask, TaskParallelInput } from './task-parallel'
@@ -12,24 +12,11 @@ export type PlanTaskView = {
   phaseWrites: Record<string, string[]>
 }
 
-const writeSetOf = (
-  row: PhaseDependency,
-  byId: ReadonlyMap<string, PhaseDependency>,
-  chain: readonly string[],
-): string[] | null => {
-  if (chain.includes(row.id)) return null
-  const like = row.writesLike.map((id) => {
-    const target = byId.get(id)
-    return target ? writeSetOf(target, byId, [...chain, row.id]) : null
-  })
-  return like.some((set) => set === null) ? null : [...row.writes, ...like.flatMap((set) => set ?? [])]
-}
-
 const phaseWritesOf = (rows: readonly PhaseDependency[]): Record<string, string[]> => {
   const byId = new Map(rows.map((row) => [row.id, row]))
   return Object.fromEntries(
     rows.flatMap((row) => {
-      const writes = writeSetOf(row, byId, [])
+      const writes = writeSetOf(row, byId)
       return writes === null ? [] : [[row.id, writes]]
     }),
   )
@@ -77,6 +64,8 @@ export type TaskParallelFacts = {
   touchedFiles: readonly string[]
   /** The lane's own agent is working, with or without a task report. */
   laneWorking: boolean
+  /** The writes sets of the plan at the base branch; empty when the base branch has no such plan. */
+  baseWrites: Record<string, string[]>
   baselineTokens: number
   thresholdTokens: number
 }
@@ -112,6 +101,7 @@ export const taskParallelInputOf = (facts: TaskParallelFacts): TaskParallelInput
   open: openTasksWithout(facts),
   active: activeWorkOf(facts),
   phaseWrites: facts.plan.phaseWrites,
+  baseWrites: facts.baseWrites,
   doneCount: facts.plan.doneCount,
   baselineTokens: facts.baselineTokens,
   thresholdTokens: facts.thresholdTokens,

package/src/watch/task-parallel-read.ts

@@ -11,7 +11,7 @@ import { recordSignals } from '../task-signals/record'
 import { readTaskRecords } from '../task-signals/record-store'
 import type { TaskSignal } from '../task-signals/types'
 import { AGENT_STATUS, type LaneAgent } from '../terminal/types'
-import { watchedLanePlanText } from './lane-progress'
+import { baseLanePlanText, watchedLanePlanText } from './lane-progress'
 import type { TaskParallelInput } from './task-parallel'
 import { planTaskViewOf, taskParallelInputOf } from './task-parallel-input'
 import { isWithinWorktree, touchedFilesOf } from './task-parallel-touched'
@@ -134,9 +134,11 @@ export const readTaskParallelInputs = (
       const signals = uniqueSignals([...reads.flatMap((read) => read.signals), ...records]).filter((signal) =>
         isWithinWorktree(signal.cwd, worktree),
       )
+      const baseText = baseLanePlanText(sources.root, sources.settings, sources.boardFile, lane)
       const input = taskParallelInputOf({
         lane: lane.name,
         plan: planTaskViewOf(text, sources.settings.planLanguage),
+        baseWrites: baseText === null ? {} : planTaskViewOf(baseText, sources.settings.planLanguage).phaseWrites,
         signals,
         touchedFiles: reads.flatMap((read) => read.tails.flatMap((tail) => touchedFilesOf(tail, worktree, since))),
         laneWorking: agents.some((agent) => agent.name === lane.name && agent.status === AGENT_STATUS.working),