jackherd 1.12.7 → 1.13.0

package/schemas/jackherd.schema.json

@@ -87,32 +87,26 @@
       "type": "object",
       "properties": {
         "test": {
-          "default": "bun test",
           "type": "string",
           "minLength": 1
         },
         "typecheck": {
-          "default": "bunx -p typescript tsc --noEmit",
           "type": "string",
           "minLength": 1
         },
         "lint": {
-          "default": "bunx @biomejs/biome check .",
           "type": "string",
           "minLength": 1
         },
         "format": {
-          "default": "bunx @biomejs/biome format --write .",
           "type": "string",
           "minLength": 1
         },
         "install": {
-          "default": "bun install",
           "type": "string",
           "minLength": 1
         },
         "dev": {
-          "default": "bun run dev",
           "type": "string",
           "minLength": 1
         }
@@ -132,7 +126,6 @@
           }
         },
         "lockFile": {
-          "default": "bun.lock",
           "type": "string",
           "pattern": "^(?![/-])(?!(?:.*\\/)?\\.\\.(?:\\/|$))[A-Za-z0-9._/-]+$"
         }
@@ -140,6 +133,13 @@
       "additionalProperties": false
     },
     "models": {
+      "default": {
+        "plan": "claude-opus-5-5",
+        "implement": "claude-sonnet-5-5",
+        "review": "claude-sonnet-5-5",
+        "explore": "claude-sonnet-5-5",
+        "orchestrate": "claude-opus-5-5"
+      },
       "type": "object",
       "propertyNames": {
         "type": "string",
@@ -749,7 +749,6 @@
       "type": "object",
       "properties": {
         "lintFilesCommand": {
-          "default": "bunx @biomejs/biome check --no-errors-on-unmatched",
           "type": "string",
           "minLength": 1
         },
@@ -774,6 +773,13 @@
                   "type": "string",
                   "minLength": 1
                 }
+              },
+              "kind": {
+                "type": "string",
+                "enum": [
+                  "tests",
+                  "types"
+                ]
               }
             },
             "required": [
@@ -900,8 +906,5 @@
       "additionalProperties": false
     }
   },
-  "required": [
-    "models"
-  ],
   "additionalProperties": false
 }

package/src/check/command.ts

@@ -2,25 +2,34 @@ import { spawnSync } from 'node:child_process'
 import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join, resolve } from 'node:path'
-import { findProjectRoot, globalConfigPath, locateConfigFile } from '../config/location'
+import { planRootsIn } from '../../kit/hooks/hooks/shared/boards'
+import { findProjectRoot, globalConfigPath, locateConfigFile, MANIFEST_FILE, TOOL_DIRECTORY } from '../config/location'
 import { readRepositoryFacts } from '../config/repository-facts'
+import { mainCheckout } from '../plans/git'
 import { baseRefOf } from '../plans/settings'
 import { type ChangedFile, parsePorcelain, STATUS_COMMAND } from './changes'
 import { deferralArrowCheck } from './deferral-arrows'
 import { runCheck, runProcess } from './execute'
 import { parallelArgument, parallelReportLines } from './parallel-report'
-import { type CheckPlan, type Filesystem, isSlow, planChecks } from './plan'
+import { type CheckPlan, type CheckStack, checkStackOf, type Filesystem, isSlow, planChecks } from './plan'
 import { planStructureChecks } from './plan-structure-check'
 import { publicContentCheck } from './public-content-check'
-import { artifactResult, formatPlanHeader, formatResults, skippedSlowResult, summarize } from './report'
-import { type CheckResult, SKIP_SLOW_FLAG } from './result'
-import { type CheckSettings, CONFIG_PATH, parseCheckSettings } from './settings'
+import {
+  artifactResult,
+  formatPlanHeader,
+  formatResults,
+  skippedSlowResult,
+  summarize,
+  testCommandResult,
+  untestedResult,
+} from './report'
+import { type CheckResult, RUN_MODE, type RunMode, runModeOf } from './result'
+import { isWorkspaceManifest, kitCopyPaths, WORKSPACE_LIST_FILE, WORKSPACE_MANIFEST } from './roots'
+import { type CheckSettings, CONFIG_PATH, parseCheckSettings, stackOf } from './settings'
 import { skillBudgetCheck } from './skill-budgets'
 
 type CheckTarget = { root: string; configPath: string }
 
-const TEST_FILE = /\.(test|spec)\.[cm]?[jt]sx?$/
-
 /**
  * Where the checks run and which config they read: the nearest project with `.jackherd/config.json`, else the
  * repository's top level with `~/.jackherd/config.json` (a global install in a repository without the kit).
@@ -53,11 +62,44 @@ const contentAt =
     return result.status === 0 ? result.stdout : null
   }
 
-const filesystemAt = (root: string): Filesystem => ({
-  hasPackageJson: (dir) => existsSync(join(root, dir, 'package.json')),
-  hasTsconfig: (dir) => existsSync(join(root, dir, 'tsconfig.json')),
-  hasTests: (dir) => existsSync(join(root, dir)) && readdirSync(join(root, dir)).some((entry) => TEST_FILE.test(entry)),
-})
+/** A file that is there but cannot be read or parsed; its message names the path. */
+export class UnreadableFileError extends Error {}
+
+const isMissingFile = (error: unknown): boolean => error instanceof Error && 'code' in error && error.code === 'ENOENT'
+
+const messageOf = (error: unknown): string => (error instanceof Error ? error.message : String(error))
+
+/**
+ * A JSON file's parsed content; null only when the file is absent. A file that is there but cannot be read
+ * or parsed throws `UnreadableFileError`, so a broken manifest is reported instead of reading as no manifest.
+ */
+export const readJsonIfPresent = (path: string): unknown => {
+  let text: string
+  try {
+    text = readFileSync(path, 'utf8')
+  } catch (error) {
+    if (isMissingFile(error)) return null
+    throw new UnreadableFileError(`${path} cannot be read: ${messageOf(error)}`)
+  }
+  try {
+    return JSON.parse(text)
+  } catch (error) {
+    throw new UnreadableFileError(`${path} is not valid JSON: ${messageOf(error)}`)
+  }
+}
+
+const filesystemAt = (root: string, stack: CheckStack): Filesystem => {
+  const holdsAny = (dir: string, names: readonly string[]) => names.some((name) => existsSync(join(root, dir, name)))
+  return {
+    isProjectRoot: (dir) => holdsAny(dir, stack.rootMarkers),
+    isWorkspaceRoot: (dir) =>
+      existsSync(join(root, dir, WORKSPACE_LIST_FILE)) ||
+      isWorkspaceManifest(readJsonIfPresent(join(root, dir, WORKSPACE_MANIFEST))),
+    hasTypeConfig: (dir) => holdsAny(dir, stack.typeMarkers),
+    hasTests: (dir) =>
+      existsSync(join(root, dir)) && readdirSync(join(root, dir)).some((entry) => stack.testFile.test(entry)),
+  }
+}
 
 const print = (lines: readonly string[]): void => {
   for (const line of lines) console.log(line)
@@ -67,7 +109,7 @@ const loadSettings = (configPath: string, root: string): CheckSettings | string
   try {
     return parseCheckSettings(JSON.parse(readFileSync(configPath, 'utf8')), readRepositoryFacts(root))
   } catch (error) {
-    return `${configPath} is not valid: ${error instanceof Error ? error.message : String(error)}`
+    return `${configPath} is not valid: ${messageOf(error)}`
   }
 }
 
@@ -99,18 +141,76 @@ const changedFiles = async (root: string): Promise<ChangedFile[] | string> => {
 const executePlan = async (
   plan: CheckPlan,
   root: string,
-  skipSlow: boolean,
+  mode: RunMode,
   ownChecks: readonly (CheckResult | null)[],
 ): Promise<CheckResult[]> => {
   const [slow, quick] = [plan.checks.filter(isSlow), plan.checks.filter((check) => !isSlow(check))]
   return [
     artifactResult(plan.artifacts),
-    ...ownChecks.filter((result) => result !== null),
+    ...[...ownChecks, untestedResult(plan.untestedSources, mode)].filter((result) => result !== null),
     ...(await Promise.all(quick.map((check) => runCheck(check, root)))),
-    ...(skipSlow ? [skippedSlowResult()] : await Promise.all(slow.map((check) => runCheck(check, root)))),
+    ...(mode === RUN_MODE.quick
+      ? [skippedSlowResult()]
+      : await Promise.all(slow.map((check) => runCheck(check, root)))),
   ]
 }
 
+/** Where a board's plans are read: this checkout, the main checkout and every lane worktree below it (`root` alone outside git). */
+const planRootsOf = (root: string, worktreeDirectory: string): string[] => {
+  try {
+    return [...new Set([resolve(root), ...planRootsIn(mainCheckout(root), worktreeDirectory)])]
+  } catch {
+    return [resolve(root)]
+  }
+}
+
+/** The checks jackherd runs itself beside the configured ones: public content, deferral arrows, skill budgets, plan structure. */
+const ownChecksOf = (root: string, paths: readonly string[], settings: CheckSettings, home: string) => [
+  publicContentCheck(root, paths, settings.check.publicContent, home),
+  deferralArrowCheck(root, paths, settings.planDirectory),
+  skillBudgetCheck(root, settings.check.skillBudgets),
+  ...planStructureChecks({
+    root,
+    paths,
+    planDirectory: settings.planDirectory,
+    language: settings.planLanguage,
+    previousOf: contentAt(root, 'HEAD'),
+    baseOf: contentAt(root, baseRefOf(settings)),
+    planRoots: planRootsOf(root, settings.worktreeDirectory),
+  }),
+]
+
+/**
+ * Plans the checks for the changed files, prints the plan's header and runs every check. A manifest that is
+ * there but cannot be read comes back as a message instead of a result list.
+ */
+const checkChanges = async (
+  files: readonly ChangedFile[],
+  root: string,
+  settings: CheckSettings,
+  mode: RunMode,
+  home: string,
+): Promise<CheckResult[] | string> => {
+  const stack = checkStackOf(stackOf(settings.stack))
+  let plan: CheckPlan
+  try {
+    const kitCopies = kitCopyPaths(readJsonIfPresent(join(root, TOOL_DIRECTORY, MANIFEST_FILE)))
+    plan = planChecks(
+      files,
+      { commands: settings.commands, check: settings.check, stack, kitCopies },
+      filesystemAt(root, stack),
+    )
+  } catch (error) {
+    if (error instanceof UnreadableFileError) return error.message
+    throw error
+  }
+  print(formatPlanHeader(files, plan, settings.stack))
+  return executePlan(plan, root, mode, [
+    testCommandResult(settings.commands.test, settings.stack),
+    ...ownChecksOf(root, plan.paths, settings, home),
+  ])
+}
+
 /**
  * Runs the configured checks over the files `git status` reports. Exit code 1 when any check fails
  * or the configuration cannot be read. With `--parallel <plan>` it runs no check and prints the plan's waves and critical path.
@@ -139,25 +239,11 @@ export const run = async (args: string[], home: string = homedir()): Promise<num
     console.log('Nothing changed.')
     return 0
   }
-
-  const plan = planChecks(files, settings.commands, settings.check, filesystemAt(root))
-  print(formatPlanHeader(files, plan))
-  const publicContent = publicContentCheck(root, plan.paths, settings.check.publicContent, home)
-  const deferralArrows = deferralArrowCheck(root, plan.paths, settings.planDirectory)
-  const planStructure = planStructureChecks({
-    root,
-    paths: plan.paths,
-    planDirectory: settings.planDirectory,
-    language: settings.planLanguage,
-    previousOf: contentAt(root, 'HEAD'),
-    baseOf: contentAt(root, baseRefOf(settings)),
-  })
-  const results = await executePlan(plan, root, args.includes(SKIP_SLOW_FLAG), [
-    publicContent,
-    deferralArrows,
-    skillBudgetCheck(root, settings.check.skillBudgets),
-    ...planStructure,
-  ])
+  const results = await checkChanges(files, root, settings, runModeOf(args), home)
+  if (typeof results === 'string') {
+    console.error(results)
+    return 1
+  }
   print(formatResults(results))
   const summary = summarize(results)
   console.log(`\n${summary.line}`)

package/src/check/plan-structure-check.ts

@@ -1,5 +1,8 @@
 import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { dirname, join, posix } from 'node:path'
+import { boardPlansOf, isInsideRepository } from '../../kit/hooks/hooks/shared/board-lanes'
+import { planCopiesIn } from '../../kit/hooks/hooks/shared/boards'
+import { codesOfPlans } from '../../kit/hooks/hooks/shared/plan-codes'
 import {
   boardRowsWithoutPhase,
   boardRowsWithProse,
@@ -25,6 +28,7 @@ import {
   type ShortNameFinding,
   shortNameFindings,
 } from '../plan-format'
+import { boardRowsWithBareCodes, type RowWithBareCode } from '../plan-format/bare-codes'
 import { changedPlansOf } from './deferral-arrows'
 import { CHECK_STATUS, type CheckResult } from './result'
 
@@ -42,6 +46,8 @@ export type PlanCheckInput = {
   language: PlanLanguage
   previousOf: ContentAt
   baseOf: ContentAt
+  /** Where a board's plans are read, `root` when absent: the checkout, the main checkout and the lane worktrees. */
+  planRoots?: readonly string[]
 }
 
 type Changed = {
@@ -116,6 +122,16 @@ const proseReport: Report<RowWithProse> = {
   clean: 'every changed lane row names the phase only',
 }
 
+const bareCodeReport: Report<RowWithBareCode> = {
+  name: 'Board rows with a bare plan code',
+  noun: 'board',
+  rule: 'changed waiting rows say what a plan code is',
+  unmet: CHECK_STATUS.warn,
+  text: ({ path, line, code }) =>
+    `${path}:${line} plan code ${code} without its words: say what it is, the code at most in brackets after it`,
+  clean: 'no changed waiting row names a plan code bare',
+}
+
 const mergedReport: Report<MergedPhaseWithOpenBoxes> = {
   name: 'Merged phases with open boxes',
   noun: 'plan',
@@ -175,6 +191,20 @@ const rowsOf = ({ path, current, previousLines }: Changed, language: PlanLanguag
 const proseOf = ({ path, current, previousLines }: Changed, language: PlanLanguage): Found<RowWithProse>[] =>
   boardRowsWithProse(current, language, previousLines).map(withPath(path))
 
+/** Every readable copy of the plans the board links, in each plan root; a path that leaves the repository is skipped. */
+const planTextsOf = (roots: readonly string[], { path, current }: Changed, language: PlanLanguage): string[] =>
+  boardPlansOf(current, posix.normalize(dirname(path)), language)
+    .filter(isInsideRepository)
+    .flatMap((plan) => planCopiesIn(roots, plan))
+
+const bareCodesOfBoard = (roots: readonly string[], file: Changed, language: PlanLanguage): Found<RowWithBareCode>[] =>
+  boardRowsWithBareCodes(
+    file.current,
+    language,
+    file.previousLines,
+    codesOfPlans(planTextsOf(roots, file, language), language),
+  ).map(withPath(file.path))
+
 const mergedOf = ({ path, current, base }: Changed, language: PlanLanguage): Found<MergedPhaseWithOpenBoxes>[] =>
   base ? mergedPhasesWithOpenBoxes(current, base, language).map(withPath(path)) : []
 
@@ -202,6 +232,7 @@ const changedContents = ({ root, previousOf, baseOf, language }: PlanCheckInput,
  * - a phase the change added (against `HEAD`) with tasks and without a review gate fails;
  * - a lane row the change added or edited that names no phase warns, and so does one whose phases cell is longer
  *   than `PHASE_CELL_LIMIT` or records a side order of the user;
+ * - a waiting row the change added or edited whose item cell names a plan code of the board's plans bare warns;
  * - a phase whose tasks are all ticked on the base branch and that still has open boxes without `→ P<n>` warns;
  * - a phase of a plan with a dependency table that has no row in it warns;
  * - an open task the change added or edited without a short name, or with one over `SHORT_NAME_LIMIT`, warns, and so
@@ -222,6 +253,7 @@ export const planStructureChecks = (input: PlanCheckInput): CheckResult[] => {
   const gates = changed.flatMap((file) => gatesOf(file, language))
   const rows = boards.flatMap((file) => rowsOf(file, language))
   const prose = boards.flatMap((file) => proseOf(file, language))
+  const bareCodes = boards.flatMap((file) => bareCodesOfBoard(input.planRoots ?? [input.root], file, language))
   const merged = plans.flatMap((file) => mergedOf(file, language))
   const unlisted = unlistedPerPlan.flat()
   const shortNames = plans.flatMap((file) => shortNamesOf(file, language))
@@ -233,6 +265,7 @@ export const planStructureChecks = (input: PlanCheckInput): CheckResult[] => {
       ? [
           findingsResult(rowReport, rows, boards.length, durationMs),
           findingsResult(proseReport, prose, boards.length, durationMs),
+          findingsResult(bareCodeReport, bareCodes, boards.length, durationMs),
         ]
       : []),
     ...(plans.length > 0 ? [findingsResult(mergedReport, merged, plans.length, durationMs)] : []),

package/src/check/plan.ts

@@ -1,33 +1,58 @@
 import type { JackherdConfig } from '../config'
+import { STACKS, type Stack, type StackProfile } from '../config/detect'
 import { agentTextReviewers } from './agent-text-reviewers'
 import { type ChangedFile, generatorOwnedFiles, stagedBuildArtifacts } from './changes'
 import { tokenize } from './command-line'
-import { looseDirectories, packageRootsFor } from './roots'
+import { matchesAnyGlob } from './glob'
+import { CHECK_KIND, type CheckKind } from './result'
+import { isUnder, looseDirectories, packageRootsFor } from './roots'
 import { projectChecksFor, publicContentReviewers, reviewersFor } from './routing'
-import type { CheckConfig } from './schema'
+import type { CheckConfig, ProjectCheck } from './schema'
 
-export const CHECK_KIND = { lint: 'lint', project: 'project', types: 'types', tests: 'tests' } as const
-
-export type CheckKind = (typeof CHECK_KIND)[keyof typeof CHECK_KIND]
+export { CHECK_KIND, type CheckKind } from './result'
 
 export type PlannedCheck = {
   name: string
   /** What the report shows; `argv` is what runs. */
   command: string
   argv: string[]
-  /** Relative to the workspace root. */
+  /** Relative to the repository root `.`. */
   cwd: string
   kind: CheckKind
 }
 
 export type PackageCommands = Pick<JackherdConfig['commands'], 'test' | 'typecheck'>
 
+/** What the plan asks of the disk, by the markers of the stack (`checkStackOf`). */
 export type Filesystem = {
-  hasPackageJson: (dir: string) => boolean
-  hasTsconfig: (dir: string) => boolean
+  /** Whether the directory holds the stack's root marker (`package.json`, `composer.json`). */
+  isProjectRoot: (dir: string) => boolean
+  /** Whether the directory only gathers workspaces, so a test from there would run the whole monorepo. */
+  isWorkspaceRoot: (dir: string) => boolean
+  /** Whether the directory holds a type marker of the stack (`tsconfig.json`, `phpstan.neon`). */
+  hasTypeConfig: (dir: string) => boolean
   hasTests: (dir: string) => boolean
 }
 
+/** The stack as the check reads it; without a detected stack, every stack's markers and patterns together. */
+export type CheckStack = {
+  rootMarkers: string[]
+  typeMarkers: string[]
+  testFile: RegExp
+  sourceFile: RegExp
+  /** Globs the lint covers; none means every changed file. */
+  lintGlobs: string[]
+}
+
+/** What the plan reads from the settings: the test and type commands, the `check` block and the stack's patterns. */
+export type PlanInputs = {
+  commands: PackageCommands
+  check: CheckConfig
+  stack: Pick<CheckStack, 'lintGlobs' | 'sourceFile'>
+  /** Repository paths of the kit's copies (`.jackherd/lock.json`); their tests run where the kit keeps the source. */
+  kitCopies: readonly string[]
+}
+
 export type CheckPlan = {
   paths: string[]
   roots: string[]
@@ -36,26 +61,58 @@ export type CheckPlan = {
   artifacts: string[]
   /** Fast checks first, then the ones that scale with the package; the runner starts each group together. */
   checks: PlannedCheck[]
+  /** The changed source files of the stack no planned test reaches, kit copies aside; a check without a test is no green. */
+  untestedSources: string[]
 }
 
 export const isSlow = (check: PlannedCheck): boolean =>
   check.kind === CHECK_KIND.types || check.kind === CHECK_KIND.tests
 
-const lintCheck = (config: CheckConfig, paths: readonly string[]): PlannedCheck => ({
-  name: 'Lint & unused imports',
-  command: `${config.lintFilesCommand} (${paths.length} files)`,
-  argv: [...tokenize(config.lintFilesCommand), ...paths],
-  cwd: '.',
-  kind: CHECK_KIND.lint,
-})
+const unique = (values: readonly string[]): string[] => [...new Set(values)]
+
+const anyOf = (patterns: readonly RegExp[]): RegExp =>
+  new RegExp(unique(patterns.map((pattern) => `(?:${pattern.source})`)).join('|'))
+
+const lintGlobsOf = (profiles: readonly StackProfile[]): string[] =>
+  profiles.some((profile) => profile.lintGlobs.length === 0)
+    ? []
+    : unique(profiles.flatMap((profile) => profile.lintGlobs))
+
+export const checkStackOf = (stack: Stack | null): CheckStack => {
+  const profiles = stack === null ? Object.values(STACKS) : [STACKS[stack]]
+  return {
+    rootMarkers: unique(profiles.map((profile) => profile.rootMarker)),
+    typeMarkers: unique(profiles.flatMap((profile) => profile.typeMarkers)),
+    testFile: anyOf(profiles.map((profile) => profile.testFilePattern)),
+    sourceFile: anyOf(profiles.map((profile) => profile.sourceFilePattern)),
+    lintGlobs: lintGlobsOf(profiles),
+  }
+}
+
+const lintedPaths = (paths: readonly string[], lintGlobs: readonly string[]): string[] =>
+  lintGlobs.length === 0 ? [...paths] : paths.filter((path) => matchesAnyGlob(path, lintGlobs))
+
+/** No lint without a `lintFilesCommand`, none is guessed; none either when no changed file is the stack's to lint. */
+const lintChecks = (command: string | undefined, paths: readonly string[]): PlannedCheck[] =>
+  command === undefined || paths.length === 0
+    ? []
+    : [
+        {
+          name: 'Lint & unused imports',
+          command: `${command} (${paths.length} files)`,
+          argv: [...tokenize(command), ...paths],
+          cwd: '.',
+          kind: CHECK_KIND.lint,
+        },
+      ]
 
-const projectChecks = (config: CheckConfig, paths: readonly string[]): PlannedCheck[] =>
-  projectChecksFor(paths, config.checks).map(({ name, command }) => ({
+const projectChecks = (fired: readonly ProjectCheck[]): PlannedCheck[] =>
+  fired.map(({ name, command, kind }) => ({
     name,
     command,
     argv: tokenize(command),
     cwd: '.',
-    kind: CHECK_KIND.project,
+    kind: kind ?? CHECK_KIND.project,
   }))
 
 const inDirectory = (kind: CheckKind, label: string, command: string, dir: string): PlannedCheck => ({
@@ -66,48 +123,74 @@ const inDirectory = (kind: CheckKind, label: string, command: string, dir: strin
   kind,
 })
 
+/** No type check without `commands.typecheck`, no test without `commands.test`: none is guessed. */
 const typeChecks = (
   roots: readonly string[],
-  command: string,
-  hasTsconfig: Filesystem['hasTsconfig'],
-): PlannedCheck[] => roots.filter(hasTsconfig).map((root) => inDirectory(CHECK_KIND.types, 'Types', command, root))
+  command: string | undefined,
+  hasTypeConfig: Filesystem['hasTypeConfig'],
+): PlannedCheck[] =>
+  command === undefined
+    ? []
+    : roots.filter(hasTypeConfig).map((root) => inDirectory(CHECK_KIND.types, 'Types', command, root))
+
+const testChecks = (dirs: readonly string[], command: string | undefined): PlannedCheck[] =>
+  command === undefined ? [] : dirs.map((dir) => inDirectory(CHECK_KIND.tests, 'Tests', command, dir))
+
+/** What reaches a changed file: a test run from a directory above it, or a fired project check of kind tests whose globs (or no globs) match it. */
+type TestReach = { dirs: readonly string[]; checks: readonly ProjectCheck[] }
+
+const isReached = (path: string, { dirs, checks }: TestReach): boolean =>
+  dirs.some((dir) => isUnder(path, dir)) ||
+  checks.some(({ globs }) => globs === undefined || matchesAnyGlob(path, globs))
+
+/** Each changed source file on its own: one test elsewhere in the change does not cover it. */
+const untestedSourcesOf = (
+  paths: readonly string[],
+  reach: TestReach,
+  { sourceFile, kitCopies }: Pick<PlanInputs['stack'], 'sourceFile'> & Pick<PlanInputs, 'kitCopies'>,
+): string[] => paths.filter((path) => sourceFile.test(path) && !kitCopies.includes(path) && !isReached(path, reach))
 
-const testChecks = (dirs: readonly string[], command: string): PlannedCheck[] =>
-  dirs.map((dir) => inDirectory(CHECK_KIND.tests, 'Tests', command, dir))
+/** The reviewers a set of changed paths calls for, each named once: routed, public content and agent texts. */
+export const reviewersOf = (paths: readonly string[], config: CheckConfig): string[] => [
+  ...new Set([
+    ...reviewersFor(paths, config.reviewerRoutes),
+    ...publicContentReviewers(paths, config.publicContent),
+    ...agentTextReviewers(paths),
+  ]),
+]
 
 /**
  * Decides, without touching the disk or running anything, what a set of changed files calls for:
- * which package roots to type-check and test, which project checks fire, which reviewers to start.
+ * which package roots to type-check and test, which project checks fire, which reviewers to start,
+ * and which changed source files no test covers. A root that gathers workspaces is never tested.
  */
 export const planChecks = (
   files: readonly ChangedFile[],
-  commands: PackageCommands,
-  config: CheckConfig,
+  { commands, check: config, stack, kitCopies }: PlanInputs,
   filesystem: Filesystem,
 ): CheckPlan => {
   const paths = files.map((file) => file.path)
-  const roots = packageRootsFor(paths, filesystem.hasPackageJson).filter((root) => root !== '.')
-  const looseDirs = config.looseTests ? looseDirectories(paths, roots, filesystem.hasTests) : []
+  const roots = packageRootsFor(paths, filesystem.isProjectRoot).filter((root) => !filesystem.isWorkspaceRoot(root))
+  const loose = config.looseTests ? looseDirectories(paths, roots, filesystem.hasTests) : []
+  const fired = projectChecksFor(paths, config.checks)
+  const testDirs = commands.test === undefined ? [] : [...roots, ...loose]
+  const checks =
+    paths.length === 0
+      ? []
+      : [
+          ...lintChecks(config.lintFilesCommand, lintedPaths(paths, stack.lintGlobs)),
+          ...projectChecks(fired),
+          ...typeChecks(roots, commands.typecheck, filesystem.hasTypeConfig),
+          ...testChecks(testDirs, commands.test),
+        ]
+  const reach: TestReach = { dirs: testDirs, checks: fired.filter((check) => check.kind === CHECK_KIND.tests) }
   return {
     paths,
     roots,
-    reviewers: [
-      ...new Set([
-        ...reviewersFor(paths, config.reviewerRoutes),
-        ...publicContentReviewers(paths, config.publicContent),
-        ...agentTextReviewers(paths),
-      ]),
-    ],
+    reviewers: reviewersOf(paths, config),
     generated: generatorOwnedFiles(paths, config.generatorOwned),
     artifacts: stagedBuildArtifacts(files, config.buildArtifacts),
-    checks:
-      paths.length === 0
-        ? []
-        : [
-            lintCheck(config, paths),
-            ...projectChecks(config, paths),
-            ...typeChecks(roots, commands.typecheck, filesystem.hasTsconfig),
-            ...testChecks([...roots, ...looseDirs], commands.test),
-          ],
+    checks,
+    untestedSources: untestedSourcesOf(paths, reach, { sourceFile: stack.sourceFile, kitCopies }),
   }
 }