@nitra/cursor 4.1.0 → 4.1.1

package/scripts/dispatcher/graph/lib/cmd-verify.mjs

@@ -0,0 +1,100 @@
+/**
+ * Handler `flow verify` — Stage 2 structural check (думка.MD § "flow verify").
+ *
+ * Перевіряє що `fact_NNN.md` існує і непорожній у директорії поточного вузла
+ * (CWD). Якщо так — виводить `## Done when` секцію з `task.md` та вміст
+ * `fact_NNN.md` на stdout для агентської self-evaluation.
+ *
+ * exit 0 = структурно OK
+ * exit 1 = структурна помилка (fact відсутній або порожній)
+ *
+ * FS ін'єктується для тестування без диска.
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { cwd as processCwd } from 'node:process'
+
+import { latestFactNNN } from './nnn.mjs'
+
+const FRONT_MATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/
+const SECTION_RE = /^## (.+)$/m
+const LINE_SPLIT_RE = /\r?\n/
+
+/**
+ * Читає секцію за заголовком із markdown-файлу.
+ * @param {string} text вміст файлу
+ * @param {string} heading заголовок без `## `
+ * @returns {string | null} вміст секції або null
+ */
+function extractSection(text, heading) {
+  const lines = text.split(LINE_SPLIT_RE)
+  const start = lines.indexOf(`## ${heading}`)
+  if (start === -1) return null
+  const end = lines.findIndex((l, i) => i > start && SECTION_RE.test(l))
+  const section = end === -1 ? lines.slice(start) : lines.slice(start, end)
+  return section.join('\n').trimEnd()
+}
+
+/**
+ * `flow verify` handler.
+ * @param {string[]} _rest аргументи після `verify` (не використовуються)
+ * @param {{
+ *   cwd?: string,
+ *   log?: (m: string) => void,
+ *   readFile?: (path: string, enc: string) => string,
+ *   readdir?: (dir: string) => string[],
+ *   exists?: (path: string) => boolean
+ * }} [deps] ін'єкції
+ * @returns {number} exit code (0=OK, 1=структурна помилка)
+ */
+export function cmdVerify(_rest, deps = {}) {
+  const cwd = deps.cwd ?? processCwd()
+  const log = deps.log ?? console.error
+  const readFile = deps.readFile ?? ((p, enc) => readFileSync(p, enc))
+  const readdir = deps.readdir ?? (d => (existsSync(d) ? readdirSync(d) : []))
+  const exists = deps.exists ?? existsSync
+
+  const factNNN = latestFactNNN(cwd, readdir)
+  if (!factNNN) {
+    log('verify: fact_NNN.md не знайдено — структурна помилка')
+    return 1
+  }
+
+  const factPath = join(cwd, `fact_${factNNN}.md`)
+  if (!exists(factPath)) {
+    log(`verify: fact_${factNNN}.md не існує — структурна помилка`)
+    return 1
+  }
+
+  let factContent
+  try {
+    factContent = readFile(factPath, 'utf8')
+  } catch (error) {
+    log(`verify: не вдалося прочитати fact_${factNNN}.md — ${error instanceof Error ? error.message : String(error)}`)
+    return 1
+  }
+
+  const withoutFm = factContent.replace(FRONT_MATTER_RE, '').trim()
+  if (withoutFm.length === 0) {
+    log(`verify: fact_${factNNN}.md порожній — структурна помилка`)
+    return 1
+  }
+
+  const outLines = [`## verify context`, ``]
+
+  const taskPath = join(cwd, 'task.md')
+  if (exists(taskPath)) {
+    try {
+      const taskContent = readFile(taskPath, 'utf8')
+      const doneWhen = extractSection(taskContent, 'Done when')
+      if (doneWhen) outLines.push(doneWhen, '')
+    } catch {
+      // task.md недоступний — не блокуємо verify
+    }
+  }
+
+  outLines.push(`### fact_${factNNN}.md`, ``, factContent.trimEnd())
+  console.log(outLines.join('\n'))
+
+  return 0
+}

package/scripts/dispatcher/graph/lib/cmd-watch.mjs

@@ -0,0 +1,128 @@
+/**
+ * `n-cursor watch` — одноразовий скан стану DAG.
+ *
+ * Спрощена (no-daemon) реалізація:
+ * - Знаходить pending-audit без audit-result → логує (треба ручний аудит)
+ * - Знаходить stale worktrees > stale_worktree_min хвилин → попереджає
+ * - Знаходить needs-plan вузли → перелічує
+ * - exit 0 якщо чисто, exit 1 якщо потрібна увага
+ *
+ * FS і child_process ін'єктуються для тестованості.
+ */
+import { execSync } from 'node:child_process'
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import { cwd as processCwd } from 'node:process'
+
+import { loadConfig, resolveTasksDir, resolveWorktreesDir } from './config.mjs'
+import { scanNodes } from './scanner.mjs'
+import { listActiveWorktrees } from './worktree-ops.mjs'
+
+/**
+ * `watch` command handler (one-shot scan).
+ * @param {string[]} args аргументи (зазвичай порожні)
+ * @param {{
+ *   cwd?: string,
+ *   log?: (m: string) => void,
+ *   readFile?: (p: string, enc: string) => string,
+ *   readdir?: (d: string) => string[],
+ *   exists?: (p: string) => boolean,
+ *   execSync?: (cmd: string, opts?: object) => string,
+ *   statSync?: (p: string) => { mtimeMs: number },
+ *   now?: () => number
+ * }} [deps] ін'єкції
+ * @returns {Promise<number>} exit code (0=clean, 1=attention)
+ */
+export async function cmdWatch(args, deps = {}) {
+  const root = deps.cwd ?? processCwd()
+  const log = deps.log ?? console.log
+  const readFile = deps.readFile ?? ((p, enc) => readFileSync(p, enc))
+  const readdir = deps.readdir ?? (d => (existsSync(d) ? readdirSync(d) : []))
+  const exists = deps.exists ?? existsSync
+  const execSyncFn = deps.execSync ?? ((cmd, o) => execSync(cmd, { ...o, encoding: 'utf8' }))
+  const statFn = deps.statSync ?? statSync
+  const nowMs = deps.now ?? (() => Date.now())
+
+  const config = loadConfig({ root, readFile, exists })
+  const tasksDir = resolveTasksDir(config, root)
+  const worktreesDir = resolveWorktreesDir(config, root)
+  const staleMs = config.stale_worktree_min * 60 * 1000
+
+  const activeWorktrees = listActiveWorktrees(root, { execSync: execSyncFn })
+
+  const allNodes = scanNodes(tasksDir, activeWorktrees, {
+    readdirSync: readdir,
+    existsSync: exists,
+    readFileSync: readFile
+  })
+
+  let needsAttention = false
+
+  // 1. Pending-audit без audit-result
+  const pendingAudit = allNodes.filter(n => n.state === 'pending-audit')
+  if (pendingAudit.length > 0) {
+    needsAttention = true
+    log(`[watch] pending-audit (${pendingAudit.length}) — потрібна ручна перевірка:`)
+    for (const n of pendingAudit) {
+      log(`  - ${n.path}`)
+    }
+  }
+
+  // 2. Stale worktrees
+  let worktreeEntries = []
+  try {
+    worktreeEntries = readdir(worktreesDir)
+  } catch {
+    // worktrees dir може не існувати
+  }
+
+  const now = nowMs()
+  const staleWorktrees = []
+  for (const name of worktreeEntries) {
+    const wtPath = join(worktreesDir, name)
+    try {
+      const stat = statFn(wtPath)
+      const ageMs = now - stat.mtimeMs
+      if (ageMs > staleMs) {
+        staleWorktrees.push({ name, ageMin: Math.floor(ageMs / 60000) })
+      }
+    } catch {
+      // пропускаємо
+    }
+  }
+
+  if (staleWorktrees.length > 0) {
+    needsAttention = true
+    log(`[watch] stale worktrees (${staleWorktrees.length}) — неактивні > ${config.stale_worktree_min} хв:`)
+    for (const wt of staleWorktrees) {
+      log(`  - ${wt.name} (${wt.ageMin} хв)`)
+    }
+  }
+
+  // 3. Needs-plan вузли
+  const needsPlan = allNodes.filter(n => n.state === 'needs-plan')
+  if (needsPlan.length > 0) {
+    log(`[watch] needs-plan (${needsPlan.length}) — потрібне планування:`)
+    for (const n of needsPlan) {
+      log(`  - ${n.path}`)
+    }
+  }
+
+  // 4. Failed вузли
+  const failed = allNodes.filter(n => n.state === 'failed')
+  if (failed.length > 0) {
+    needsAttention = true
+    log(`[watch] failed (${failed.length}) — завершились з помилкою:`)
+    for (const n of failed) {
+      log(`  - ${n.path}`)
+    }
+  }
+
+  if (!needsAttention && pendingAudit.length === 0 && failed.length === 0) {
+    const running = allNodes.filter(n => n.state === 'running').length
+    const resolved = allNodes.filter(n => n.state === 'resolved').length
+    log(`[watch] OK — total:${allNodes.length} running:${running} resolved:${resolved}`)
+  }
+
+  return needsAttention ? 1 : 0
+}

package/scripts/dispatcher/graph/lib/config.mjs

@@ -0,0 +1,103 @@
+/**
+ * Завантаження конфігурації `.n-cursor.json` для graph-команд.
+ *
+ * Читає JSON з кореня репо (або з вказаного шляху), мержить із дефолтами.
+ * Підтримує per-node override через task.md (якщо вузол передає свої налаштування).
+ *
+ * FS ін'єктується для тестованості без диска.
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { cwd as processCwd } from 'node:process'
+
+/** Дефолтні значення конфігурації. */
+export const CONFIG_DEFAULTS = {
+  tasks_dir: './tasks',
+  worktrees_dir: './.worktrees',
+  warn_worktrees_above: 4,
+  max_worktrees: 8,
+  default_budget_sec: 1800,
+  budget_hard_sec_multiplier: 3,
+  progress_timeout_sec: 300,
+  claude_model: 'claude-sonnet-4-6',
+  audit_model: 'claude-haiku-4-5-20251001',
+  model_map: {
+    MIM: 'claude-haiku-4-5-20251001',
+    AVG: 'claude-sonnet-4-6',
+    MAX: 'claude-opus-4-8'
+  },
+  stale_worktree_min: 30,
+  system_prompt: '.n-cursor/system-prompt.md'
+}
+
+/**
+ * Завантажує конфігурацію з `.n-cursor.json` і мержить із дефолтами.
+ * @param {{
+ *   root?: string,
+ *   readFile?: (p: string, enc: string) => string,
+ *   exists?: (p: string) => boolean
+ * }} [deps] ін'єкції
+ * @returns {typeof CONFIG_DEFAULTS} злита конфігурація
+ */
+export function loadConfig(deps = {}) {
+  const root = deps.root ?? processCwd()
+  const readFile = deps.readFile ?? ((p, enc) => readFileSync(p, enc))
+  const exists = deps.exists ?? existsSync
+
+  const configPath = join(root, '.n-cursor.json')
+
+  if (!exists(configPath)) {
+    return { ...CONFIG_DEFAULTS }
+  }
+
+  let raw
+  try {
+    raw = JSON.parse(readFile(configPath, 'utf8'))
+  } catch {
+    return { ...CONFIG_DEFAULTS }
+  }
+
+  return {
+    ...CONFIG_DEFAULTS,
+    ...raw,
+    model_map: {
+      ...CONFIG_DEFAULTS.model_map,
+      ...(raw.model_map ?? {})
+    }
+  }
+}
+
+/**
+ * Повертає абсолютний шлях до tasks_dir.
+ * @param {typeof CONFIG_DEFAULTS} config конфігурація
+ * @param {string} root корінь репо
+ * @returns {string} абсолютний шлях
+ */
+export function resolveTasksDir(config, root) {
+  const d = config.tasks_dir
+  return d.startsWith('/') ? d : join(root, d)
+}
+
+/**
+ * Повертає абсолютний шлях до worktrees_dir.
+ * @param {typeof CONFIG_DEFAULTS} config конфігурація
+ * @param {string} root корінь репо
+ * @returns {string} абсолютний шлях
+ */
+export function resolveWorktreesDir(config, root) {
+  const d = config.worktrees_dir
+  return d.startsWith('/') ? d : join(root, d)
+}
+
+/**
+ * Резолвить модель за model_tier із model_map або повертає claude_model (дефолт).
+ * @param {typeof CONFIG_DEFAULTS} config конфігурація
+ * @param {string | undefined} modelTier 'MIM' | 'AVG' | 'MAX'
+ * @returns {string} model id
+ */
+export function resolveModelByTier(config, modelTier) {
+  if (modelTier && config.model_map[modelTier]) {
+    return config.model_map[modelTier]
+  }
+  return config.claude_model
+}

package/scripts/dispatcher/graph/lib/frontmatter.mjs

@@ -0,0 +1,224 @@
+/**
+ * YAML front-matter parser/serializer для graph task-файлів.
+ *
+ * Підтримує:
+ * - Прості `key: value` рядки
+ * - Вкладені об'єкти (блок з відступами), напр. `executor:` + indented children
+ * - Списки: `deps:` / `skills:` із рядками `  - item`
+ * - Серіалізацію назад у YAML (для запису front-matter)
+ *
+ * Чисто — без залежностей, тільки вбудований JS. FS не торкається.
+ */
+
+const FM_BOUNDARY_RE = /^---\r?\n([\s\S]*?)\r?\n---/
+
+/**
+ * Парсить YAML front-matter з markdown-тексту.
+ * Повертає словник (може містити вкладені об'єкти та масиви).
+ * @param {string} text вміст файлу
+ * @returns {Record<string, unknown>} ключ-значення, або {} якщо front-matter відсутній
+ */
+export function parseFrontMatter(text) {
+  const m = text.match(FM_BOUNDARY_RE)
+  if (!m) return {}
+  return parseYamlBlock(m[1])
+}
+
+/**
+ * Отримує тіло документа (без front-matter).
+ * @param {string} text вміст файлу
+ * @returns {string} тіло без front-matter
+ */
+export function getBody(text) {
+  const m = text.match(FM_BOUNDARY_RE)
+  if (!m) return text
+  return text.slice(m[0].length).trimStart()
+}
+
+/**
+ * Парсить YAML-блок (без --- рядків).
+ * @param {string} block YAML-текст
+ * @returns {Record<string, unknown>} розпарсений об'єкт
+ */
+function parseYamlBlock(block) {
+  const lines = block.split(/\r?\n/)
+  const result = {}
+  let i = 0
+
+  while (i < lines.length) {
+    const line = lines[i]
+    if (!line.trim() || line.trimStart().startsWith('#')) {
+      i++
+      continue
+    }
+
+    const indent = getIndent(line)
+    if (indent > 0) {
+      // Верхній рівень — пропускаємо "бродячі" дочірні рядки
+      i++
+      continue
+    }
+
+    const colonIdx = line.indexOf(':')
+    if (colonIdx === -1) {
+      i++
+      continue
+    }
+
+    const key = line.slice(0, colonIdx).trim()
+    const rawVal = line.slice(colonIdx + 1).trim()
+
+    if (rawVal.length > 0) {
+      // Inline значення — scalar
+      result[key] = parseScalar(rawVal)
+      i++
+    } else {
+      // Значення відсутнє після ':' — дивимось наступні рядки
+      i++
+      if (i >= lines.length) {
+        result[key] = null
+        continue
+      }
+
+      const nextLine = lines[i]
+      if (!nextLine.trim()) {
+        result[key] = null
+        continue
+      }
+
+      const nextIndent = getIndent(nextLine)
+      if (nextIndent === 0) {
+        // Без відступу — null
+        result[key] = null
+        continue
+      }
+
+      const nextTrimmed = nextLine.trimStart()
+      if (nextTrimmed.startsWith('- ')) {
+        // Список
+        const arr = []
+        while (i < lines.length) {
+          const l = lines[i]
+          if (!l.trim()) {
+            i++
+            continue
+          }
+          const ind = getIndent(l)
+          if (ind === 0) break
+          const t = l.trimStart()
+          if (t.startsWith('- ')) {
+            arr.push(parseScalar(t.slice(2).trim()))
+          }
+          i++
+        }
+        result[key] = arr
+      } else {
+        // Вкладений об'єкт
+        const childLines = []
+        while (i < lines.length) {
+          const l = lines[i]
+          if (!l.trim()) {
+            i++
+            continue
+          }
+          if (getIndent(l) === 0) break
+          // Нормалізуємо відступ (видаляємо перший рівень)
+          childLines.push(l.slice(nextIndent))
+          i++
+        }
+        result[key] = parseYamlBlock(childLines.join('\n'))
+      }
+    }
+  }
+
+  return result
+}
+
+/**
+ * Повертає кількість пробілів на початку рядка.
+ * @param {string} line рядок
+ * @returns {number} кількість пробілів
+ */
+function getIndent(line) {
+  let count = 0
+  for (const ch of line) {
+    if (ch === ' ') count++
+    else break
+  }
+  return count
+}
+
+/**
+ * Парсить скалярне значення: число, булеве, null, або рядок.
+ * @param {string} s рядок-значення
+ * @returns {unknown} розпарсене значення
+ */
+function parseScalar(s) {
+  if (s === 'true') return true
+  if (s === 'false') return false
+  if (s === 'null' || s === '~') return null
+  const n = Number(s)
+  if (!Number.isNaN(n) && s.trim().length > 0) return n
+  // Знімаємо лапки
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1)
+  }
+  return s
+}
+
+/**
+ * Серіалізує об'єкт у YAML-рядок (для front-matter).
+ * Підтримує прості scalar, масиви та вкладені об'єкти.
+ * @param {Record<string, unknown>} obj об'єкт для серіалізації
+ * @param {number} [indentLevel=0] рівень відступу
+ * @returns {string} YAML-рядок (без --- маркерів)
+ */
+export function serializeYaml(obj, indentLevel = 0) {
+  const indent = '  '.repeat(indentLevel)
+  const lines = []
+
+  for (const [key, val] of Object.entries(obj)) {
+    if (val === null || val === undefined) {
+      lines.push(`${indent}${key}:`)
+    } else if (Array.isArray(val)) {
+      lines.push(`${indent}${key}:`)
+      for (const item of val) {
+        lines.push(`${indent}  - ${serializeScalar(item)}`)
+      }
+    } else if (typeof val === 'object') {
+      lines.push(`${indent}${key}:`)
+      lines.push(serializeYaml(val, indentLevel + 1))
+    } else {
+      lines.push(`${indent}${key}: ${serializeScalar(val)}`)
+    }
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Серіалізує скалярне значення у рядок.
+ * @param {unknown} val значення
+ * @returns {string} рядкове представлення
+ */
+function serializeScalar(val) {
+  if (typeof val === 'string') {
+    // Додаємо лапки якщо містить спецсимволи
+    if (/[:#\[\]{},\n]/.test(val) || val.trim() !== val) {
+      return `"${val.replace(/"/g, '\\"')}"`
+    }
+    return val
+  }
+  return String(val)
+}
+
+/**
+ * Будує markdown-файл із front-matter і тілом.
+ * @param {Record<string, unknown>} fm об'єкт front-matter
+ * @param {string} [body=''] тіло документа
+ * @returns {string} повний вміст файлу
+ */
+export function buildMarkdown(fm, body = '') {
+  const yaml = serializeYaml(fm)
+  return ['---', yaml, '---', '', body].join('\n')
+}

package/scripts/dispatcher/graph/lib/nnn.mjs

@@ -0,0 +1,127 @@
+/**
+ * NNN-нумерація для артефактів вузлів графу (run_NNN.md, fact_NNN.md, тощо).
+ *
+ * Всі функції — чисті утиліти, файлову систему отримують через ін'єкцію.
+ * NNN = рядок з ведучими нулями до 3 цифр: '001', '002', …
+ */
+
+const RUN_FILE_RE = /^run_(\d+)\.md$/
+const PLAN_FILE_RE = /^plan_(\d+)\.md$/
+const FACT_FILE_RE = /^fact_(\d+)\.md$/
+const PENDING_AUDIT_FILE_RE = /^pending-audit_(\d+)\.md$/
+const AUDIT_RESULT_FILE_RE = /^audit-result_(\d+)\.md$/
+
+/**
+ * Форматує число як NNN рядок (три цифри з ведучими нулями).
+ * @param {number} n невід'ємне ціле число
+ * @returns {string} '001', '002', …
+ */
+export function padNNN(n) {
+  return String(n).padStart(3, '0')
+}
+
+/**
+ * Знаходить максимальний NNN серед файлів що відповідають regex, або 0 якщо не знайдено.
+ * @param {string[]} files список файлів директорії
+ * @param {RegExp} re regex з групою захоплення числа
+ * @returns {number} максимальний NNN або 0
+ */
+function maxNNN(files, re) {
+  let max = 0
+  for (const f of files) {
+    const m = f.match(re)
+    if (m) {
+      const n = parseInt(m[1], 10)
+      if (n > max) max = n
+    }
+  }
+  return max
+}
+
+/**
+ * Наступний NNN для run_NNN.md: count(run_*.md) + 1.
+ * @param {string} nodeDir абсолютний шлях до директорії вузла
+ * @param {(dir: string) => string[]} readdirSync ін'єктована функція readdir
+ * @returns {string} наступний NNN рядок
+ */
+export function nextRunNNN(nodeDir, readdirSync) {
+  const files = readdirSync(nodeDir)
+  let count = 0
+  for (const f of files) {
+    if (RUN_FILE_RE.test(f)) count++
+  }
+  return padNNN(count + 1)
+}
+
+/**
+ * Наступний NNN для plan_NNN.md: max(plan_*.md numbers) + 1.
+ * @param {string} nodeDir абсолютний шлях до директорії вузла
+ * @param {(dir: string) => string[]} readdirSync ін'єктована функція readdir
+ * @returns {string} наступний NNN рядок
+ */
+export function nextPlanNNN(nodeDir, readdirSync) {
+  const files = readdirSync(nodeDir)
+  return padNNN(maxNNN(files, PLAN_FILE_RE) + 1)
+}
+
+/**
+ * Найвищий NNN серед fact_NNN.md, або null якщо немає.
+ * @param {string} nodeDir абсолютний шлях до директорії вузла
+ * @param {(dir: string) => string[]} readdirSync ін'єктована функція readdir
+ * @returns {string | null} NNN рядок або null
+ */
+export function latestFactNNN(nodeDir, readdirSync) {
+  const files = readdirSync(nodeDir)
+  const m = maxNNN(files, FACT_FILE_RE)
+  return m > 0 ? padNNN(m) : null
+}
+
+/**
+ * Перевіряє чи є pending-audit без відповідного audit-result.
+ * @param {string} nodeDir абсолютний шлях до директорії вузла
+ * @param {(dir: string) => string[]} readdirSync ін'єктована функція readdir
+ * @returns {{ has: boolean, nnn: string | null }} результат
+ */
+export function hasPendingAudit(nodeDir, readdirSync) {
+  const files = readdirSync(nodeDir)
+  const fileSet = new Set(files)
+
+  const pendingNNNs = []
+  for (const f of files) {
+    const m = f.match(PENDING_AUDIT_FILE_RE)
+    if (m) pendingNNNs.push(m[1])
+  }
+
+  for (const nnn of pendingNNNs) {
+    const resultFile = `audit-result_${nnn}.md`
+    if (!fileSet.has(resultFile)) {
+      return { has: true, nnn: padNNN(parseInt(nnn, 10)) }
+    }
+  }
+
+  return { has: false, nnn: null }
+}
+
+/**
+ * Знаходить NNN для останнього pending-audit_NNN.md (для audit-result).
+ * @param {string} nodeDir абсолютний шлях до директорії вузла
+ * @param {(dir: string) => string[]} readdirSync ін'єктована функція readdir
+ * @returns {string | null} NNN рядок або null
+ */
+export function latestPendingAuditNNN(nodeDir, readdirSync) {
+  const files = readdirSync(nodeDir)
+  const m = maxNNN(files, PENDING_AUDIT_FILE_RE)
+  return m > 0 ? padNNN(m) : null
+}
+
+/**
+ * Знаходить NNN для останнього audit-result_NNN.md.
+ * @param {string} nodeDir абсолютний шлях до директорії вузла
+ * @param {(dir: string) => string[]} readdirSync ін'єктована функція readdir
+ * @returns {string | null} NNN рядок або null
+ */
+export function latestAuditResultNNN(nodeDir, readdirSync) {
+  const files = readdirSync(nodeDir)
+  const m = maxNNN(files, AUDIT_RESULT_FILE_RE)
+  return m > 0 ? padNNN(m) : null
+}