infra-kit 0.1.101 → 0.1.105

package/src/lib/infra-kit-config/infra-kit-config.ts

@@ -1,15 +1,14 @@
 import fs from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
-import yaml from 'yaml'
-import { z } from 'zod/v4'
+import { z } from 'zod'
 
 import { getProjectRoot, getRepoName } from 'src/lib/git-utils'
 
-const INFRA_KIT_CONFIG_FILE = 'infra-kit.yml'
+const INFRA_KIT_CONFIG_FILE = 'infra-kit.json'
 
 const USER_CONFIG_DIR_NAME = '.infra-kit'
-const USER_GLOBAL_CONFIG_FILE = 'config.yml'
+const USER_GLOBAL_CONFIG_FILE = 'config.json'
 const USER_PROJECTS_DIR = 'projects'
 
 // envManagement
@@ -62,7 +61,7 @@ const worktreesConfigSchema = z.object({
   openInCmux: z.boolean().optional(),
 })
 
-const infraKitConfigSchema = z.object({
+export const infraKitConfigSchema = z.object({
   environments: z.array(z.string().min(1)).min(1),
   envManagement: envManagementSchema,
   ide: ideSchema.optional(),
@@ -70,7 +69,7 @@ const infraKitConfigSchema = z.object({
   worktrees: worktreesConfigSchema.optional(),
 })
 
-const infraKitOverrideConfigSchema = infraKitConfigSchema.partial()
+export const infraKitOverrideConfigSchema = infraKitConfigSchema.partial()
 
 export type InfraKitConfig = z.infer<typeof infraKitConfigSchema>
 
@@ -79,7 +78,7 @@ export interface InfraKitConfigPaths {
   main: string
   /** User-scope global overrides applied to every project. */
   userGlobal: string
-  /** User-scope per-project overrides — `<userProjectsDir>/<projectName>/infra-kit.yml`. */
+  /** User-scope per-project overrides — `<userProjectsDir>/<projectName>/infra-kit.json`. */
   userProject: string
   /** Repo basename (`path.basename(projectRoot)`) used to namespace the user-project file. */
   projectName: string
@@ -100,9 +99,9 @@ let cached: CacheEntry | null = null
  * @example
  * const paths = await getInfraKitConfigPaths()
  * // {
- * //   main:        '/Users/arthur/projects/api/infra-kit.yml',
- * //   userGlobal:  '/Users/arthur/.infra-kit/config.yml',
- * //   userProject: '/Users/arthur/.infra-kit/projects/api/infra-kit.yml',
+ * //   main:        '/Users/arthur/projects/api/infra-kit.json',
+ * //   userGlobal:  '/Users/arthur/.infra-kit/config.json',
+ * //   userProject: '/Users/arthur/.infra-kit/projects/api/infra-kit.json',
  * //   projectName: 'api',
  * // }
  */
@@ -120,19 +119,19 @@ export const getInfraKitConfigPaths = async (): Promise<InfraKitConfigPaths> =>
 }
 
 /**
- * Read and validate `infra-kit.yml`, with optional override layers shallow-merged
+ * Read and validate `infra-kit.json`, with optional override layers shallow-merged
  * on top in this order (later wins):
- *   1. project `infra-kit.yml`                            — committed source of truth
- *   2. `~/.infra-kit/config.yml`                          — user-global defaults
- *   3. `~/.infra-kit/projects/<repo-name>/infra-kit.yml`  — user-scope per-project overrides
+ *   1. project `infra-kit.json`                            — committed source of truth
+ *   2. `~/.infra-kit/config.json`                          — user-global defaults
+ *   3. `~/.infra-kit/projects/<repo-name>/infra-kit.json`  — user-scope per-project overrides
  *
  * Top-level keys (entire capability sections like `ide`, `envManagement`)
  * replace wholesale. Results are cached per file mtimes so the long-running
  * MCP server picks up edits without a restart.
  *
  * @example
- * // infra-kit.yml:           { environments: ['dev'], envManagement: { provider: 'doppler', config: { name: 'p' } } }
- * // ~/.infra-kit/config.yml: { ide: { provider: 'cursor', config: { mode: 'windows' } } }
+ * // infra-kit.json:           { "environments": ["dev"], "envManagement": { "provider": "doppler", "config": { "name": "p" } } }
+ * // ~/.infra-kit/config.json: { "ide": { "provider": "cursor", "config": { "mode": "windows" } } }
  * const cfg = await getInfraKitConfig()
  * // => { environments: ['dev'], envManagement: {...}, ide: { provider: 'cursor', config: { mode: 'windows' } } }
  */
@@ -145,7 +144,18 @@ export const getInfraKitConfig = async (): Promise<InfraKitConfig> => {
     mainStat = await fs.stat(paths.main)
   } catch {
     cached = null
-    throw new Error(`infra-kit.yml not found at ${paths.main}`)
+
+    // Bridge the YAML→JSON cutover: if a legacy infra-kit.yml is sitting where
+    // the JSON config should be, point the user at the one-shot migration.
+    const legacyYmlPath = paths.main.replace(/\.json$/, '.yml')
+
+    if (await statIfExists(legacyYmlPath)) {
+      throw new Error(
+        `infra-kit.json not found at ${paths.main}. A legacy infra-kit.yml exists — run \`infra-kit init\` to convert it.`,
+      )
+    }
+
+    throw new Error(`infra-kit.json not found at ${paths.main}`)
   }
 
   const [userGlobalStat, userProjectStat] = await Promise.all([
@@ -164,10 +174,10 @@ export const getInfraKitConfig = async (): Promise<InfraKitConfig> => {
   }
 
   const layers: ConfigLayer[] = [
-    { label: 'infra-kit.yml', path: paths.main, required: true },
-    { label: '~/.infra-kit/config.yml', path: paths.userGlobal, required: false },
+    { label: 'infra-kit.json', path: paths.main, required: true },
+    { label: '~/.infra-kit/config.json', path: paths.userGlobal, required: false },
     {
-      label: `~/.infra-kit/projects/${paths.projectName}/infra-kit.yml`,
+      label: `~/.infra-kit/projects/${paths.projectName}/infra-kit.json`,
       path: paths.userProject,
       required: false,
     },
@@ -224,8 +234,8 @@ const statIfExists = async (filePath: string): Promise<Awaited<ReturnType<typeof
  * `fs.readFile` that returns `null` instead of throwing on ENOENT.
  *
  * @example
- * const raw = await readIfExists('/missing.yml') // => null
- * const raw = await readIfExists('/exists.yml')  // => 'environments: [dev]\n'
+ * const raw = await readIfExists('/missing.json') // => null
+ * const raw = await readIfExists('/exists.json')  // => '{ "environments": ["dev"] }\n'
  */
 const readIfExists = async (filePath: string): Promise<string | null> => {
   try {
@@ -261,17 +271,18 @@ interface ConfigLayer {
 }
 
 /**
- * Read a single layer of the merge chain: parse the YAML if the file exists
+ * Read a single layer of the merge chain: parse the JSON if the file exists
  * and validate it against the override schema. Returns `null` if an optional
- * layer is missing; throws if the layer is required or invalid.
+ * layer is missing; throws if the layer is required, malformed, or invalid.
+ * An empty/whitespace-only file is treated as `{}` (JSON.parse would throw).
  *
  * @example
- * await loadLayer({ label: '~/.infra-kit/config.yml', path: '/missing.yml', required: false })
+ * await loadLayer({ label: '~/.infra-kit/config.json', path: '/missing.json', required: false })
  * // => null
  *
  * @example
- * // /home/me/.infra-kit/config.yml: 'ide:\n  provider: cursor\n  config: { mode: windows }'
- * await loadLayer({ label: '~/.infra-kit/config.yml', path: '/home/me/.infra-kit/config.yml', required: false })
+ * // /home/me/.infra-kit/config.json: '{ "ide": { "provider": "cursor", "config": { "mode": "windows" } } }'
+ * await loadLayer({ label: '~/.infra-kit/config.json', path: '/home/me/.infra-kit/config.json', required: false })
  * // => { ide: { provider: 'cursor', config: { mode: 'windows' } } }
  */
 const loadLayer = async (layer: ConfigLayer): Promise<Record<string, unknown> | null> => {
@@ -285,7 +296,14 @@ const loadLayer = async (layer: ConfigLayer): Promise<Record<string, unknown> |
     return null
   }
 
-  const parsedRaw = yaml.parse(raw) ?? {}
+  let parsedRaw: unknown
+
+  try {
+    parsedRaw = raw.trim() === '' ? {} : JSON.parse(raw)
+  } catch (err) {
+    throw new Error(`Invalid JSON in ${layer.label} at ${layer.path}: ${(err as Error).message}`)
+  }
+
   const result = infraKitOverrideConfigSchema.safeParse(parsedRaw)
 
   if (!result.success) {

package/src/lib/package-config/__tests__/package-config.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest'
+
+import { DEFAULT_RULES, ROOT_DEFAULT_RULES, defineConfig, resolvePackageConfig } from '../package-config'
+import { packageConfigSchema } from '../package-config-schema'
+
+describe('defineConfig', () => {
+  it('returns an object input unchanged (identity)', () => {
+    const input = { requiredScripts: ['build'] }
+
+    expect(defineConfig(input)).toBe(input)
+  })
+
+  it('returns a factory input unchanged so the loader can resolve it', () => {
+    const factory = () => {
+      return { requiredFiles: ['a.txt'] }
+    }
+
+    expect(defineConfig(factory)).toBe(factory)
+  })
+})
+
+describe('resolvePackageConfig', () => {
+  it('falls back to defaults for every unset key', () => {
+    const rules = resolvePackageConfig({})
+
+    expect(rules.requiredScripts).toEqual(DEFAULT_RULES.requiredScripts)
+    expect(rules.requiredFiles).toEqual(DEFAULT_RULES.requiredFiles)
+  })
+
+  it('replaces a key wholesale when provided, including an empty array opt-out', () => {
+    const rules = resolvePackageConfig({ requiredScripts: [], requiredFiles: ['serverless.common.yml'] })
+
+    expect(rules.requiredScripts).toEqual([])
+    expect(rules.requiredFiles).toEqual(['serverless.common.yml'])
+  })
+
+  it('does not share the default array reference with the resolved result', () => {
+    const rules = resolvePackageConfig({})
+
+    rules.requiredScripts.push('mutated')
+
+    expect(DEFAULT_RULES.requiredScripts).not.toContain('mutated')
+  })
+
+  it('falls back to the supplied baseline (root) for unset keys, including turbo tasks', () => {
+    const rules = resolvePackageConfig({}, ROOT_DEFAULT_RULES)
+
+    expect(rules.requiredScripts).toEqual(ROOT_DEFAULT_RULES.requiredScripts)
+    expect(rules.turboTasks).toEqual(ROOT_DEFAULT_RULES.turboTasks)
+  })
+
+  it('lets a config override turbo.requiredTasks', () => {
+    const rules = resolvePackageConfig({ turbo: { requiredTasks: ['build'] } }, ROOT_DEFAULT_RULES)
+
+    expect(rules.turboTasks).toEqual(['build'])
+  })
+
+  it('defaults turboTasks to an empty array for packages', () => {
+    const rules = resolvePackageConfig({})
+
+    expect(rules.turboTasks).toEqual([])
+  })
+})
+
+describe('packageConfigSchema', () => {
+  it('rejects unknown keys so config typos surface as errors', () => {
+    const result = packageConfigSchema.safeParse({ requiredScript: ['build'] })
+
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a non-array requiredScripts', () => {
+    const result = packageConfigSchema.safeParse({ requiredScripts: 'build' })
+
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts a well-formed config', () => {
+    const result = packageConfigSchema.safeParse({ requiredScripts: ['build'], requiredFiles: ['tsconfig.json'] })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts a turbo.requiredTasks block', () => {
+    const result = packageConfigSchema.safeParse({ turbo: { requiredTasks: ['build', 'validate'] } })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects an unknown key inside turbo', () => {
+    const result = packageConfigSchema.safeParse({ turbo: { tasks: ['build'] } })
+
+    expect(result.success).toBe(false)
+  })
+})

package/src/lib/package-config/index.ts

@@ -0,0 +1,3 @@
+export { DEFAULT_RULES, defineConfig, resolvePackageConfig, ROOT_DEFAULT_RULES } from './package-config'
+export type { InfraKitPackageConfig, InfraKitPackageConfigInput, ResolvedPackageRules } from './package-config'
+export { packageConfigSchema } from './package-config-schema'

package/src/lib/package-config/package-config-schema.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod'
+
+/**
+ * Schema for the resolved (post-factory) package config object. `strictObject`
+ * rejects unknown keys so typos in `infra-kit.config.ts` surface as validation
+ * errors instead of being silently ignored.
+ *
+ * Kept in its own module — separate from the public `defineConfig`/types entry —
+ * so the published `infra-kit` type surface stays free of a `zod` import.
+ */
+export const packageConfigSchema = z.strictObject({
+  requiredScripts: z.array(z.string().min(1)).optional(),
+  requiredFiles: z.array(z.string().min(1)).optional(),
+  turbo: z
+    .strictObject({
+      requiredTasks: z.array(z.string().min(1)).optional(),
+    })
+    .optional(),
+})

package/src/lib/package-config/package-config.ts

@@ -0,0 +1,99 @@
+/**
+ * Validation rules for a single workspace package, declared in its
+ * `infra-kit.config.js`. Every field is optional: a key left unset falls back to
+ * the active baseline ({@link DEFAULT_RULES} for packages, {@link ROOT_DEFAULT_RULES}
+ * for the monorepo root), and a key set replaces that default wholesale (per-key,
+ * no array concatenation) so a package can opt out with an explicit empty array.
+ *
+ * Most packages need none of these — the standard rules live in the baseline, so
+ * a typical config is just `defineConfig(() => ({}))`.
+ *
+ * @example
+ * // infra-kit.config.js
+ * import { defineConfig } from 'infra-kit'
+ *
+ * export default defineConfig(() => ({}))
+ */
+export interface InfraKitPackageConfig {
+  /** Scripts that must be present in the package's package.json `scripts` map. */
+  requiredScripts?: string[]
+  /** Files (relative to the package root) that must exist on disk. */
+  requiredFiles?: string[]
+  /** Turborepo expectations — only meaningful where a turbo.json lives (the root). */
+  turbo?: {
+    /** Tasks that must be defined in turbo.json `tasks`. */
+    requiredTasks?: string[]
+  }
+}
+
+/**
+ * Accepted shapes for a package config's default export — mirrors Vite's
+ * `defineConfig` input: a plain object, a sync factory, or an async factory.
+ */
+export type InfraKitPackageConfigInput =
+  | InfraKitPackageConfig
+  | (() => InfraKitPackageConfig)
+  | (() => Promise<InfraKitPackageConfig>)
+
+/**
+ * Identity helper that gives `infra-kit.config.js` authors full type inference
+ * and editor autocomplete without changing the value — exactly like Vite's
+ * `defineConfig`. Resolution of the factory form happens in the loader, not here.
+ *
+ * @example
+ * export default defineConfig(() => ({}))
+ *
+ * @example
+ * export default defineConfig(() => ({ requiredScripts: [] }))
+ */
+export const defineConfig = (config: InfraKitPackageConfigInput): InfraKitPackageConfigInput => {
+  return config
+}
+
+/** Fully-resolved rules with every defaultable field present. */
+export interface ResolvedPackageRules {
+  requiredScripts: string[]
+  requiredFiles: string[]
+  turboTasks: string[]
+}
+
+/**
+ * Baseline rules for a standard TypeScript workspace package, applied to any key
+ * a package leaves unset. These are the "under the hood" defaults so a conforming
+ * package's config can stay empty; non-standard packages override the relevant key.
+ */
+export const DEFAULT_RULES: Readonly<ResolvedPackageRules> = {
+  requiredScripts: ['build', 'ts-check', 'eslint-check', 'prettier-check', 'test'],
+  requiredFiles: ['tsconfig.json', 'eslint.config.js', 'readme.md'],
+  turboTasks: [],
+}
+
+/**
+ * Baseline rules for the monorepo root (`infra-kit audit --root`). Checks the
+ * root commands, the workspace/turbo files, and that the turbo pipeline defines
+ * the expected tasks — so the root's own config can also stay empty.
+ */
+export const ROOT_DEFAULT_RULES: Readonly<ResolvedPackageRules> = {
+  requiredScripts: ['build', 'dev', 'test', 'qa', 'check', 'fix'],
+  requiredFiles: ['turbo.json', 'pnpm-workspace.yaml'],
+  turboTasks: ['build', 'test', 'ts-check', 'eslint-check', 'prettier-check', 'check'],
+}
+
+/**
+ * Merge a parsed package config over a baseline. Each key is replaced wholesale
+ * when the package provides it, otherwise the baseline value is used.
+ *
+ * @example
+ * resolvePackageConfig({ requiredScripts: [] })
+ * // => { requiredScripts: [], requiredFiles: [...DEFAULT_RULES.requiredFiles], turboTasks: [] }
+ */
+export const resolvePackageConfig = (
+  config: InfraKitPackageConfig,
+  baseline: Readonly<ResolvedPackageRules> = DEFAULT_RULES,
+): ResolvedPackageRules => {
+  return {
+    requiredScripts: config.requiredScripts ?? [...baseline.requiredScripts],
+    requiredFiles: config.requiredFiles ?? [...baseline.requiredFiles],
+    turboTasks: config.turbo?.requiredTasks ?? [...baseline.turboTasks],
+  }
+}

package/src/lib/package-validator/__tests__/package-validator.test.ts

@@ -0,0 +1,263 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { DEFAULT_RULES, ROOT_DEFAULT_RULES } from 'src/lib/package-config'
+
+import { discoverPackages, loadPackageConfig, validatePackage } from '../package-validator'
+
+const tmpDirs: string[] = []
+
+const makeTmpDir = (): string => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pkg-validator-'))
+
+  tmpDirs.push(dir)
+
+  return dir
+}
+
+interface PackageFixture {
+  packageJson?: Record<string, unknown>
+  config?: string
+  files?: Record<string, string>
+}
+
+const writePackage = (dir: string, fixture: PackageFixture): void => {
+  const packageJson = fixture.packageJson ?? { name: '@x/pkg', type: 'module' }
+
+  fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify(packageJson, null, 2))
+
+  if (fixture.config !== undefined) {
+    fs.writeFileSync(path.join(dir, 'infra-kit.config.ts'), fixture.config)
+  }
+
+  for (const [name, content] of Object.entries(fixture.files ?? {})) {
+    fs.writeFileSync(path.join(dir, name), content)
+  }
+}
+
+afterEach(() => {
+  while (tmpDirs.length > 0) {
+    const dir = tmpDirs.pop()
+
+    if (dir) {
+      fs.rmSync(dir, { recursive: true, force: true })
+    }
+  }
+})
+
+describe('loadPackageConfig', () => {
+  it('throws when infra-kit.config.js is missing', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {})
+
+    await expect(loadPackageConfig(dir)).rejects.toThrow(/not found/)
+  })
+
+  it('loads an object default export and merges defaults', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, { config: 'export default { requiredScripts: [] }' })
+
+    const rules = await loadPackageConfig(dir)
+
+    expect(rules.requiredScripts).toEqual([])
+    expect(rules.requiredFiles).toEqual(DEFAULT_RULES.requiredFiles)
+  })
+
+  it('resolves a factory (function) default export', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, { config: "export default () => ({ requiredFiles: ['a.txt'] })" })
+
+    const rules = await loadPackageConfig(dir)
+
+    expect(rules.requiredFiles).toEqual(['a.txt'])
+  })
+
+  it('rejects an invalid config shape with a descriptive error', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, { config: "export default { requiredScripts: 'build' }" })
+
+    await expect(loadPackageConfig(dir)).rejects.toThrow(/Invalid/)
+  })
+
+  it('rejects an unknown key (typo protection)', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, { config: 'export default { requiredScript: [] }' })
+
+    await expect(loadPackageConfig(dir)).rejects.toThrow(/Invalid/)
+  })
+})
+
+describe('validatePackage', () => {
+  it('passes when config, required scripts, and required files are all satisfied', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: { name: '@x/ok', type: 'module', scripts: { build: 'x' } },
+      config: "export default { requiredScripts: ['build'], requiredFiles: ['tsconfig.json'] }",
+      files: { 'tsconfig.json': '{}' },
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(true)
+    expect(result.packageName).toBe('@x/ok')
+  })
+
+  it('applies the under-the-hood defaults when the config is empty', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: {
+        name: '@x/std',
+        type: 'module',
+        scripts: { build: 'x', 'ts-check': 'x', 'eslint-check': 'x', 'prettier-check': 'x', test: 'x' },
+      },
+      config: 'export default {}',
+      files: { 'tsconfig.json': '{}', 'eslint.config.js': '', 'readme.md': '' },
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(true)
+  })
+
+  it('fails when a required script is missing', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: { name: '@x/no-script', type: 'module', scripts: { build: 'x' } },
+      config: "export default { requiredScripts: ['build', 'ts-check'], requiredFiles: [] }",
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(false)
+    expect(result.checks).toContainEqual(expect.objectContaining({ name: 'script:ts-check', status: 'fail' }))
+  })
+
+  it('fails when a required file is missing', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: { name: '@x/no-file', type: 'module', scripts: {} },
+      config: "export default { requiredScripts: [], requiredFiles: ['tsconfig.json'] }",
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(false)
+    expect(result.checks).toContainEqual(expect.objectContaining({ name: 'file:tsconfig.json', status: 'fail' }))
+  })
+
+  it('fails with only the config check when infra-kit.config.ts is missing', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, { packageJson: { name: '@x/no-config', type: 'module' } })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(false)
+    expect(result.checks).toHaveLength(1)
+    expect(result.checks[0]).toMatchObject({ name: 'infra-kit.config.ts', status: 'fail' })
+  })
+})
+
+describe('validatePackage — root / turbo', () => {
+  it('passes the root baseline when scripts, files, and turbo tasks are present', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: {
+        name: 'monorepo',
+        type: 'module',
+        scripts: { build: 'x', dev: 'x', test: 'x', qa: 'x', check: 'x', fix: 'x' },
+      },
+      config: 'export default {}',
+      files: {
+        'pnpm-workspace.yaml': 'packages: []\n',
+        'turbo.json': JSON.stringify({
+          tasks: { build: {}, test: {}, 'ts-check': {}, 'eslint-check': {}, 'prettier-check': {}, check: {} },
+        }),
+      },
+    })
+
+    const result = await validatePackage(dir, ROOT_DEFAULT_RULES)
+
+    expect(result.passed).toBe(true)
+  })
+
+  it('fails when a required turbo task is missing from turbo.json', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: { name: 'monorepo', type: 'module' },
+      config: "export default { requiredScripts: [], requiredFiles: [], turbo: { requiredTasks: ['build', 'lint'] } }",
+      files: { 'turbo.json': JSON.stringify({ tasks: { build: {} } }) },
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(false)
+    expect(result.checks).toContainEqual(expect.objectContaining({ name: 'turbo:lint', status: 'fail' }))
+    expect(result.checks).toContainEqual(expect.objectContaining({ name: 'turbo:build', status: 'pass' }))
+  })
+
+  it('accepts a root task keyed as //#name in turbo.json', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: { name: 'monorepo', type: 'module' },
+      config: "export default { requiredScripts: [], requiredFiles: [], turbo: { requiredTasks: ['check-root'] } }",
+      files: { 'turbo.json': JSON.stringify({ tasks: { '//#check-root': {} } }) },
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.checks).toContainEqual(expect.objectContaining({ name: 'turbo:check-root', status: 'pass' }))
+  })
+})
+
+describe('discoverPackages', () => {
+  it('expands non-vendor globs and excludes vendor and negations', async () => {
+    const root = makeTmpDir()
+
+    fs.writeFileSync(
+      path.join(root, 'pnpm-workspace.yaml'),
+      'packages:\n  - apps/*/*\n  - packages/*\n  - vendor/packages/*\n  - "!**/test/**"\n',
+    )
+
+    const dirs = ['apps/infra-kit/cli', 'packages/p1', 'vendor/packages/v1']
+
+    for (const dir of dirs) {
+      const full = path.join(root, dir)
+
+      fs.mkdirSync(full, { recursive: true })
+      fs.writeFileSync(path.join(full, 'package.json'), '{}')
+    }
+
+    const found = await discoverPackages(root)
+
+    expect(found).toContain(path.join(root, 'apps/infra-kit/cli'))
+    expect(found).toContain(path.join(root, 'packages/p1'))
+    expect(found).not.toContain(path.join(root, 'vendor/packages/v1'))
+  })
+
+  it('omits directories that lack a package.json', async () => {
+    const root = makeTmpDir()
+
+    fs.writeFileSync(path.join(root, 'pnpm-workspace.yaml'), 'packages:\n  - packages/*\n')
+
+    fs.mkdirSync(path.join(root, 'packages/empty'), { recursive: true })
+
+    const found = await discoverPackages(root)
+
+    expect(found).not.toContain(path.join(root, 'packages/empty'))
+  })
+})