@nitra/cursor 3.29.0 → 4.0.0

package/scripts/dispatcher/lib/commands.mjs

@@ -1,296 +0,0 @@
-/**
- * Handler-и підкоманд `flow` (spec §8). Уся IO — через ін'єктовані `run`/`log`/
- * `fingerprint`/`now`, щоб логіку тестувати без реальних процесів.
- *
- * Ф2 (Пасивний Турнікет): `init` (worktree + стан), `verify` (Суддя), `release`
- * (change + completion snapshot). `run`/`resume`/`cancel`/`repair` — Ф4.
- */
-import { spawnSync } from 'node:child_process'
-import { isAbsolute, join } from 'node:path'
-import { cwd as processCwd } from 'node:process'
-
-import { worktreePaths } from '../../lib/worktree.mjs'
-import { collectChangedFilesSince } from '../../lib/changed-files.mjs'
-import { worktreeFingerprint } from '../../utils/worktree-fingerprint.mjs'
-import { getMonorepoProjectRootDirs } from '../../../rules/changelog/lib/package-manifest.mjs'
-import { flowEventsPath } from './events.mjs'
-import { detectLevel, detectRisk } from './level.mjs'
-import { runReview } from './reviewer.mjs'
-import { buildCompletionSnapshot, writeSummaryToTaskRecord } from './snapshot.mjs'
-import { flowStatePath, readState, recordTransition, writeState } from './state-store.mjs'
-import { resolveActiveFlowState } from './flow-resolve.mjs'
-
-/**
- * Реальний sync-runner із захопленням виводу.
- * @param {string} cmd виконуваний
- * @param {string[]} args аргументи
- * @param {object} [opts] додаткові опції spawnSync (напр. `cwd`)
- * @returns {{ status: number, stdout: string, stderr: string }} результат
- */
-export function realRun(cmd, args, opts = {}) {
-  const r = spawnSync(cmd, args, { encoding: 'utf8', ...opts })
-  return { status: r.status ?? 1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' }
-}
-
-/**
- * Чи `cwd` — уже linked worktree (не основний checkout і не submodule).
- * @param {(cmd: string, args: string[], opts: object) => { status: number, stdout: string }} run runner
- * @param {string} cwd робочий каталог
- * @returns {boolean} true, якщо вже в worktree
- */
-function inLinkedWorktree(run, cwd) {
-  const gitDir = run('git', ['rev-parse', '--git-dir'], { cwd })
-  const gitCommon = run('git', ['rev-parse', '--git-common-dir'], { cwd })
-  if ((gitDir.status ?? 1) !== 0 || (gitCommon.status ?? 1) !== 0) return false
-  const superproject = run('git', ['rev-parse', '--show-superproject-working-tree'], { cwd })
-  const isSubmodule = (superproject.stdout ?? '').trim() !== ''
-  return !isSubmodule && (gitDir.stdout ?? '').trim() !== (gitCommon.stdout ?? '').trim()
-}
-
-/**
- * `flow init <branch> "<опис>"` — ізоляція + ініціалізація стану (§8.1). Якщо вже
- * в worktree — не вкладає новий (detect existing isolation).
- * @param {string[]} rest аргументи: `<branch> <опис...>`
- * @param {{ run?: (cmd: string, args: string[], opts: object) => { status: number, stdout: string, stderr: string }, cwd?: string, log?: (m: string) => void, now?: () => number }} [deps] ін'єкції
- * @returns {Promise<number>} exit code
- */
-/**
- * Гарантує worktree для задачі: парсить `<branch> <опис>`, детектить існуючу
- * ізоляцію (§8.1) або створює новий worktree, читає `base_commit`. Спільне для
- * `init` (Фасад A) і `run` (Фасад B).
- * @param {string[]} rest аргументи `<branch> <опис...>`
- * @param {{ run?: (cmd: string, args: string[], opts: object) => object, cwd?: string, log?: (m: string) => void }} [deps] ін'єкції
- * @returns {{ code: number, worktreeDir?: string, branch?: string, desc?: string, baseCommit?: string | null }} результат
- */
-export function ensureWorktree(rest, deps = {}) {
-  const run = deps.run ?? realRun
-  const cwd = deps.cwd ?? processCwd()
-  const log = deps.log ?? console.error
-
-  const branch = rest[0]
-  const desc = rest.slice(1).join(' ').trim()
-  if (!branch || !desc) {
-    log('Usage: n-cursor flow <init|run> <branch> "<опис>"')
-    return { code: 1 }
-  }
-
-  let worktreeDir
-  if (inLinkedWorktree(run, cwd)) {
-    worktreeDir = cwd
-    log(`flow: уже в worktree (${cwd}) — не вкладаю новий`)
-  } else {
-    const add = run('npx', ['@nitra/cursor', 'worktree', 'add', branch, desc], { cwd })
-    if ((add.status ?? 1) !== 0) {
-      const detail = add.stderr ? `: ${add.stderr.trim()}` : ''
-      log(`flow: worktree add не вдався${detail}`)
-      return { code: 1 }
-    }
-    worktreeDir = worktreePaths(cwd, branch).checkout
-  }
-
-  const head = run('git', ['rev-parse', 'HEAD'], { cwd: worktreeDir })
-  const baseCommit = (head.status ?? 1) === 0 ? (head.stdout ?? '').trim() : null
-  return { code: 0, worktreeDir, branch, desc, baseCommit }
-}
-
-/**
- * `flow init <branch> "<опис>"` — ізоляція + ініціалізація стану (§8.1).
- * @param {string[]} rest аргументи `<branch> <опис...>`
- * @param {{ run?: (cmd: string, args: string[], opts: object) => object, cwd?: string, log?: (m: string) => void, now?: () => number }} [deps] ін'єкції
- * @returns {Promise<number>} exit code
- */
-export async function init(rest, deps = {}) {
-  const ew = ensureWorktree(rest, deps)
-  if (ew.code !== 0) return ew.code
-  const now = deps.now ?? Date.now
-  const log = deps.log ?? console.error
-  const statePath = flowStatePath(ew.worktreeDir)
-  const level = detectLevel(ew.desc)
-  const risk = detectRisk(ew.desc)
-  writeState(statePath, {
-    branch: ew.branch,
-    status: 'in_progress',
-    started_at: new Date(now()).toISOString(),
-    metadata: { base_commit: ew.baseCommit },
-    level,
-    risk,
-    plan: []
-  })
-  log(`init: ${ew.branch} (level ${level}, risk ${risk}) → ${statePath}`)
-  return 0
-}
-
-/**
- * `flow verify` — проганяє Quality Gates у поточному worktree (Турнікет, §8.1).
- * На фейл друкує вивід проваленого gate. Якщо поряд є стан — записує
- * gate-результати + fingerprint. Read-only щодо коду.
- * @param {string[]} _rest аргументи (не використовуються)
- * @param {{ run?: (cmd: string, args: string[], opts: object) => { status: number, stdout: string, stderr: string }, cwd?: string, log?: (m: string) => void, fingerprint?: () => string | null }} [deps] ін'єкції
- * @returns {Promise<number>} exit code (0 — pass, 1 — fail)
- */
-export async function verify(_rest, deps = {}) {
-  const run = deps.run ?? realRun
-  const cwd0 = deps.cwd ?? processCwd()
-  const log = deps.log ?? console.error
-
-  // cwd-незалежний резолв активного flow. verify толерантний: без активного flow
-  // гейти все одно прогоняються (standalone) у поточному cwd, лише без запису стану.
-  const resolved = resolveActiveFlowState({ cwd: cwd0, branch: deps.branch }, deps)
-  if (resolved.statePath && resolved.autoResolved) {
-    log(`flow: авторезолвлено активний flow «${resolved.label}» (cwd поза worktree)`)
-  }
-  // Явний `--branch`, що не резолвиться, — це помилка наміру: не деградуємо тихо
-  // на поточний cwd (інакше `flow verify --branch typo` міг би «зеленіти» в CI).
-  if (deps.branch && !resolved.statePath) {
-    log(`❌ verify: ${resolved.error}`)
-    return 1
-  }
-  const cwd = resolved.worktreeDir ?? cwd0
-  const fingerprint =
-    deps.fingerprint ?? (() => worktreeFingerprint((cmd, args, opts) => spawnSync(cmd, args, { ...opts, cwd })))
-
-  const statePath = resolved.statePath
-  const state = statePath ? readState(statePath) : null
-  if (!state) {
-    // statePath null → resolved.error пояснює (нема/кілька активних); statePath є,
-    // але стан не читається → пошкоджений .flow.json. В обох випадках verify
-    // толерантний: гейти прогоняються standalone у `cwd`, без запису стану.
-    if (resolved.error) log(`⚠️ verify: ${resolved.error}`)
-    log(`⚠️ verify: активного flow не визначено — гейти прогнано у ${cwd} без запису стану`)
-  }
-  // М'які ворота: відсутній план — лише попередження, exit-код визначають gate-и.
-  if (state && !state.plan?.length) {
-    log('⚠️ verify: плану не зафіксовано (`flow plan`) — рекомендовано спершу сформувати план')
-  }
-
-  const verdict = runReview({ run, cwd, fingerprint })
-
-  for (const g of verdict.gates) {
-    log(`${g.ok ? '✅' : '❌'} gate: ${g.name}`)
-  }
-  if (!verdict.pass && verdict.failedOutput) log(verdict.failedOutput)
-  log(verdict.pass ? '✅ verify: усі gate-и пройдено' : '❌ verify: провалено')
-
-  if (state) {
-    recordTransition({ statePath, eventsPath: flowEventsPath(cwd) }, { type: 'verify', pass: verdict.pass }, state => ({
-      ...state,
-      gates: verdict.gates,
-      fingerprint: verdict.fingerprint,
-      status: verdict.pass ? state.status : 'failed'
-    }))
-  }
-
-  return verdict.pass ? 0 : 1
-}
-
-/**
- * Які з subworkspace-тек мають змінені файли — для авто-`--ws` у `release`.
- * Кожен файл відноситься до НАЙГЛИБШОГО воркспейсу-збігу, тож вкладені воркспейси
- * (`apps` + `apps/web`) не дають хибного «кілька воркспейсів» для `apps/web/x`.
- * @param {string[]} subWorkspaces теки воркспейсів без кореня (`.`)
- * @param {string[]} changedFiles змінені шляхи відносно кореня репо (posix)
- * @returns {string[]} підмножина `subWorkspaces`, під якими є зміни (у вхідному порядку)
- */
-export function matchChangedWorkspaces(subWorkspaces, changedFiles) {
-  const byDepthDesc = subWorkspaces.toSorted((a, b) => b.length - a.length)
-  const hit = new Set()
-  for (const f of changedFiles) {
-    const ws = byDepthDesc.find(w => f === w || f.startsWith(`${w}/`))
-    if (ws) hit.add(ws)
-  }
-  return subWorkspaces.filter(w => hit.has(w))
-}
-
-/**
- * Додає `--ws <шлях>` до аргументів `change`, інферячи воркспейс зі змін від
- * `base_commit`, якщо `--ws` не задано явно. Один змінений subworkspace → авто-`--ws`;
- * кілька → `{ error: true }` (fail-hard, exit 1 у release); нуль / без subworkspace →
- * лишаємо як є (change дефолтиться на `.`). Помилку самого інференсу (недосяжний base,
- * збій `listWorkspaces`) трактуємо fail-soft — не блокуємо, лишаємо дефолт.
- * @param {{ rest: string[], baseCommit: string | null, cwd: string, listWorkspaces: (cwd: string) => Promise<string[]>, changedFilesSince: (base: string | null, cwd: string) => string[], log: (m: string) => void }} input ін'єкції
- * @returns {Promise<{ args: string[], error?: boolean }>} аргументи для `change` або `{ error: true }`
- */
-async function resolveChangeWsArgs({ rest, baseCommit, cwd, listWorkspaces, changedFilesSince, log }) {
-  // Поважаємо явно заданий воркспейс в обох формах (`--ws x` і `--ws=x`).
-  if (rest.includes('--ws') || rest.some(a => a.startsWith('--ws='))) return { args: rest }
-  try {
-    const workspaces = await listWorkspaces(cwd)
-    const subWs = workspaces.filter(w => w !== '.')
-    if (subWs.length === 0) return { args: rest }
-    const hits = matchChangedWorkspaces(subWs, changedFilesSince(baseCommit, cwd))
-    if (hits.length > 1) {
-      log(`release: зміни у кількох воркспейсах (${hits.join(', ')}) — вкажи --ws явно`)
-      return { args: rest, error: true }
-    }
-    if (hits.length === 1) {
-      log(`release: change → воркспейс «${hits[0]}» (інферено з diff від base)`)
-      return { args: [...rest, '--ws', hits[0]] }
-    }
-    return { args: rest }
-  } catch (error) {
-    log(`⚠️ release: інференс воркспейсу пропущено (${error instanceof Error ? error.message : String(error)})`)
-    return { args: rest }
-  }
-}
-
-/**
- * `flow release [--bump … --section … --message …]` — генерує `.changes` і пише
- * completion snapshot (§3 Ф5, §7). Потребує наявного стану (`init`).
- * @param {string[]} rest аргументи, що прокидаються у `n-cursor change`
- * @param {{ run?: (cmd: string, args: string[], opts: object) => { status: number, stdout: string, stderr: string }, cwd?: string, log?: (m: string) => void, now?: () => number }} [deps] ін'єкції
- * @returns {Promise<number>} exit code
- */
-export async function release(rest, deps = {}) {
-  const run = deps.run ?? realRun
-  const cwd = deps.cwd ?? processCwd()
-  const log = deps.log ?? console.error
-  const now = deps.now ?? Date.now
-
-  const resolved = resolveActiveFlowState({ cwd, branch: deps.branch }, deps)
-  if (!resolved.statePath) {
-    log(`release: ${resolved.error}`)
-    return 1
-  }
-  if (resolved.autoResolved) log(`flow: авторезолвлено активний flow «${resolved.label}» (cwd поза worktree)`)
-  const effectiveCwd = resolved.worktreeDir ?? cwd
-  const statePath = resolved.statePath
-  const state = readState(statePath)
-  if (!state) {
-    log('release: стану нема — спершу `flow init`')
-    return 1
-  }
-  // М'які ворота: FAIL-гейт — лише попередження, рішення за людиною.
-  if (state.gate?.verdict === 'FAIL') {
-    log(`⚠️ release: gate = FAIL (score ${state.gate.score}) — релізиш свідомо? (див. flow gate)`)
-  }
-
-  const wsResolved = await resolveChangeWsArgs({
-    rest,
-    baseCommit: state.metadata?.base_commit ?? null,
-    cwd: effectiveCwd,
-    listWorkspaces: deps.listWorkspaces ?? getMonorepoProjectRootDirs,
-    changedFilesSince: deps.changedFilesSince ?? collectChangedFilesSince,
-    log
-  })
-  if (wsResolved.error) return 1
-
-  const ch = run('npx', ['@nitra/cursor', 'change', ...wsResolved.args], { cwd: effectiveCwd })
-  if ((ch.status ?? 1) !== 0) {
-    const detail = ch.stderr ? `: ${ch.stderr.trim()}` : ''
-    log(`release: change не вдався${detail}`)
-    return 1
-  }
-
-  const snapshot = buildCompletionSnapshot({ ...state, status: 'done' }, now)
-  recordTransition(
-    { statePath, eventsPath: flowEventsPath(effectiveCwd) },
-    { type: 'release' },
-    state_ => ({ ...state_, status: 'done', completion: snapshot }),
-    now
-  )
-  if (state.task) {
-    writeSummaryToTaskRecord(isAbsolute(state.task) ? state.task : join(effectiveCwd, state.task), snapshot)
-  }
-  log('release: done')
-  return 0
-}

package/scripts/dispatcher/lib/flow-lock.mjs

@@ -1,39 +0,0 @@
-/**
- * Серіалізація мутацій стану `flow` через **reuse** спільного `withLock`
- * (spec §4.1.3). `withLock` уже коректно чистить stale-локи (TTL +
- * `process.kill(pid,0)`) і релізить на SIGINT/SIGTERM — не дублюємо це.
- *
- * **Override для flow:** `onWaitTimeout: 'fail'` — на відміну від lint (де
- * прийнятно «після таймауту запустити без локу»), мутацію стану двома writer-ами
- * не допускаємо → fail-closed. Dedup за fingerprint вимкнено (`getFingerprint:
- * () => null`): flow завжди має виконатись, а не пропуститись за «тим самим
- * деревом».
- *
- * Лок-кеш — sibling `.worktrees/.flow-lock-<branch>/` (поряд зі станом), щоб не
- * залежати від глобального кеш-каталогу.
- */
-import { basename, dirname, isAbsolute, join } from 'node:path'
-
-import { withLock } from '../../utils/with-lock.mjs'
-
-/**
- * Виконує `runFn` під per-branch локом flow. Кидає (fail-closed), якщо лок не
- * вдалося взяти за `waitTimeout`.
- * @param {string} worktreeDir абсолютний шлях checkout (`…/.worktrees/feat-x`)
- * @param {() => unknown | Promise<unknown>} runFn критична секція
- * @param {object} [opts] прокидається у `withLock` (напр. `waitTimeout`, `pollInterval`)
- * @returns {Promise<unknown>} результат `runFn`
- */
-export function withFlowLock(worktreeDir, runFn, opts = {}) {
-  if (!isAbsolute(worktreeDir)) {
-    throw new Error(`withFlowLock: очікується абсолютний шлях (отримано: ${worktreeDir})`)
-  }
-  const base = basename(worktreeDir)
-  const cacheDir = join(dirname(worktreeDir), `.flow-lock-${base}`)
-  return withLock(`flow-${base}`, runFn, {
-    onWaitTimeout: 'fail',
-    cacheDir,
-    getFingerprint: () => null,
-    ...opts
-  })
-}

package/scripts/dispatcher/lib/gate.mjs

@@ -1,91 +0,0 @@
-/**
- * `flow gate` — структурований вердикт релізної готовності (ідея BMAD qa-gate, у
- * нашому стані). Синтезує механічні гейти `verify` (`state.gates`) і adversarial
- * findings `review` (`state.review.findings`) у єдине PASS/CONCERNS/FAIL + score
- * + причини. Дає traceability «чому готово/не готово». `gate` лише агрегує —
- * рішення verify/review не дублює.
- *
- * Уся IO (`now`) ін'єктується; `computeGate` — чиста (тестується без стану на диску).
- */
-import { cwd as processCwd } from 'node:process'
-
-import { flowEventsPath } from './events.mjs'
-import { readState, recordTransition } from './state-store.mjs'
-import { resolveActiveFlowState } from './flow-resolve.mjs'
-
-/** Штрафи score за кожен тип проблеми. */
-const PENALTY = { failedGate: 40, high: 25, med: 8, noVerify: 15 }
-
-/**
- * Чистий синтез вердикту з наявного стану.
- * @param {{ gates?: { name: string, ok: boolean }[], review?: { findings?: { severity?: string }[] } }} state стан flow
- * @returns {{ verdict: 'PASS' | 'CONCERNS' | 'FAIL', score: number, reasons: string[] }} вердикт
- */
-export function computeGate(state) {
-  const gates = state.gates ?? []
-  const findings = state.review?.findings ?? []
-  const failedGates = gates.filter(g => !g.ok)
-  const high = findings.filter(f => f.severity === 'high')
-  const med = findings.filter(f => f.severity === 'med')
-  const noVerify = gates.length === 0
-
-  const reasons = []
-  for (const g of failedGates) reasons.push(`gate «${g.name}» провалено`)
-  if (high.length > 0) reasons.push(`${high.length} high-severity review finding(s)`)
-  if (med.length > 0) reasons.push(`${med.length} med-severity review finding(s)`)
-  if (noVerify) reasons.push('verify ще не запускався')
-
-  let verdict = 'PASS'
-  if (failedGates.length > 0 || high.length > 0) {
-    verdict = 'FAIL'
-  } else if (med.length > 0 || noVerify) {
-    verdict = 'CONCERNS'
-  }
-
-  const penalty =
-    PENALTY.failedGate * failedGates.length +
-    PENALTY.high * high.length +
-    PENALTY.med * med.length +
-    (noVerify ? PENALTY.noVerify : 0)
-  const score = Math.max(0, Math.min(100, 100 - penalty))
-
-  return { verdict, score, reasons }
-}
-
-/**
- * `flow gate` — обчислює й фіксує вердикт у `.flow.json`.
- * @param {string[]} _rest аргументи (не використовуються)
- * @param {{ cwd?: string, log?: (m: string) => void, now?: () => number }} [deps] ін'єкції
- * @returns {Promise<number>} exit code (FAIL → 1; PASS/CONCERNS → 0)
- */
-export async function gate(_rest, deps = {}) {
-  const cwd0 = deps.cwd ?? processCwd()
-  const log = deps.log ?? console.error
-  const now = deps.now ?? Date.now
-
-  const resolved = resolveActiveFlowState({ cwd: cwd0, branch: deps.branch }, deps)
-  if (!resolved.statePath) {
-    log(`gate: ${resolved.error}`)
-    return 1
-  }
-  if (resolved.autoResolved) log(`flow: авторезолвлено активний flow «${resolved.label}» (cwd поза worktree)`)
-  const cwd = resolved.worktreeDir ?? cwd0
-  const statePath = resolved.statePath
-  const state = readState(statePath)
-  if (!state) {
-    log('gate: стану нема — спершу `flow init`')
-    return 1
-  }
-
-  const result = computeGate(state)
-  recordTransition(
-    { statePath, eventsPath: flowEventsPath(cwd) },
-    { type: 'gate', verdict: result.verdict },
-    s => ({ ...s, gate: { ...result, at: new Date(now()).toISOString() } }),
-    now
-  )
-
-  log(`gate: ${result.verdict} (score ${result.score})`)
-  for (const r of result.reasons) log(`  · ${r}`)
-  return result.verdict === 'FAIL' ? 1 : 0
-}

package/scripts/dispatcher/lib/level.mjs

@@ -1,135 +0,0 @@
-/**
- * Scale-adaptive рівень + ризик задачі (ідея з BMAD project-levels/risk-profile,
- * у наших термінах). `init` визначає рівень і ризик за описом; разом вони
- * right-size'ять, скільки adversarial-рецензентів спавнить `flow review` (і його
- * фокус), і які фази рекомендовані (контракт).
- *
- * Детекція — підрядками (case-insensitive), без regex (уникаємо slow-regex і
- * проблем зі словомежами для кирилиці).
- */
-
-/** L3 — велике/архітектурне. */
-const L3_KEYS = ['platform', 'migration', 'rewrite', 'architecture', 'enterprise', 'редизайн', 'міграц', 'переписат']
-/** L0 — тривіальне. ASCII-дієслова: матч цілим словом (щоб `fix` не ловило `prefix`/`fixture`). */
-const L0_WORD_KEYS = ['fix', 'typo', 'bump', 'rename', 'hotfix']
-/** L0 — кириличні ключі: підрядком (стемінг: `перейменув` ловить `перейменування`). */
-const L0_SUBSTR_KEYS = ['опечат', 'перейменув']
-/** L2 — багатофайлова фіча/рефактор. */
-const L2_KEYS = ['feature', 'epic', 'refactor', 'рефактор', 'фіча']
-/**
- * Сигнали складності (cross-cutting rules/checks/correctness): разом із L0-дієсловом
- * задача НЕ тривіальна. Перекривають L0 (мінімум L2) — щоб rules/checks-роботу не
- * класифікувати як trivial і не пропускати spec (беклог #2). Підрядком (case-insensitive).
- */
-const COMPLEXITY_KEYS = [
-  'mdc',
-  'policy',
-  'політик',
-  'rego',
-  'checker',
-  'чекер',
-  'правило',
-  'правила',
-  'rules',
-  'суперечн',
-  'інваріант',
-  'invariant',
-  'порушен',
-  'violation',
-  'кілька файл',
-  'декілька',
-  'meta-'
-]
-
-/**
- * Чи символ — ASCII-літера/цифра (межа слова). `undefined` (край рядка) — не alnum.
- * @param {string | undefined} ch символ
- * @returns {boolean} результат
- */
-function isAsciiAlnum(ch) {
-  return ch !== undefined && ((ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9'))
-}
-
-/**
- * Чи містить `text` слово `word` із межами, що не є ASCII-alnum (без regex —
- * конвенція файлу). Для ASCII L0-дієслів: `fix` у `prefix`/`fixture` не рахується.
- * @param {string} text текст (lowercase)
- * @param {string} word шукане ASCII-слово (lowercase)
- * @returns {boolean} результат
- */
-function hasWord(text, word) {
-  let i = text.indexOf(word)
-  while (i !== -1) {
-    if (!isAsciiAlnum(text[i - 1]) && !isAsciiAlnum(text[i + word.length])) return true
-    i = text.indexOf(word, i + 1)
-  }
-  return false
-}
-
-/**
- * Рівень складності задачі за описом: 0 (тривіальне) … 3 (архітектурне).
- * Пріоритет: L3 > L0 (якщо без сигналів складності) > L2/складність > дефолт L1.
- * Лише сигнал складності перекриває L0-дієслово (`fix mdc checker` → L2, не L0);
- * L2-ключі порядок L0 не змінюють (`rename feature` лишається L0, як і раніше).
- * @param {string} desc опис задачі
- * @returns {0 | 1 | 2 | 3} рівень
- */
-export function detectLevel(desc) {
-  const d = String(desc ?? '').toLowerCase()
-  const has = keys => keys.some(k => d.includes(k))
-  const isL0 = L0_WORD_KEYS.some(k => hasWord(d, k)) || L0_SUBSTR_KEYS.some(k => d.includes(k))
-  if (has(L3_KEYS)) return 3
-  if (isL0 && !has(COMPLEXITY_KEYS)) return 0
-  if (has(L2_KEYS) || has(COMPLEXITY_KEYS)) return 2
-  return 1
-}
-
-/**
- * Скільки adversarial-рецензентів спавнити для рівня (глибина review за розміром).
- * @param {number} level рівень 0..3
- * @returns {number} кількість рецензентів (1..3)
- */
-export function reviewersForLevel(level) {
-  if (level >= 3) return 3
-  if (level === 2) return 2
-  return 1
-}
-
-/** Ключові слова високого ризику (безпека/гроші/доступи). */
-const HIGH_RISK_KEYS = ['security', 'auth', 'crypto', 'payment', 'secret', 'token', 'permission', 'password', 'безпек']
-/** Ключові слова середнього ризику (дані/незворотність). */
-const MED_RISK_KEYS = ['data', ' db', 'database', 'migration', 'delete', 'gateway', 'міграц', 'видален']
-
-/**
- * Рівень ризику задачі за описом: low | med | high.
- * @param {string} desc опис задачі
- * @returns {'low' | 'med' | 'high'} ризик
- */
-export function detectRisk(desc) {
-  const d = String(desc ?? '').toLowerCase()
-  const has = keys => keys.some(k => d.includes(k))
-  if (has(HIGH_RISK_KEYS)) return 'high'
-  if (has(MED_RISK_KEYS)) return 'med'
-  return 'low'
-}
-
-/**
- * Скільки рецензентів диктує сам ризик.
- * @param {string} risk low|med|high
- * @returns {number} 1..3
- */
-export function reviewersForRisk(risk) {
-  if (risk === 'high') return 3
-  if (risk === 'med') return 2
-  return 1
-}
-
-/**
- * Підсумкова глибина review: максимум вимог за рівнем і за ризиком (кап 3).
- * @param {number} level рівень 0..3
- * @param {string} [risk] low|med|high
- * @returns {number} кількість рецензентів (1..3)
- */
-export function reviewersFor(level, risk) {
-  return Math.min(3, Math.max(reviewersForLevel(level), reviewersForRisk(risk)))
-}

package/scripts/dispatcher/lib/plan.mjs

@@ -1,88 +0,0 @@
-/**
- * `flow plan [--panel] [<plan.md>]` — фаза плану (Пасивний Турнікет, lifecycle
- * §4). Фіксує `docs/plans/<date>-<slug>.md`: дзеркалить кроки (`## Кроки`) у
- * `.flow.json plan[]`, виставляє `status: planned`, верифікує ланцюг через
- * read-only `trace`. Код не пише; лінки front-matter (`spec`/`flow`) пише агент.
- *
- * Brainstorm: human↔agent (агент пише plan-doc у діалозі) або agent↔agent
- * (`--panel`: панель персон → суддя синтезує кроки).
- */
-import { existsSync, readFileSync } from 'node:fs'
-import { cwd as processCwd } from 'node:process'
-
-import { extractSteps, resolveArtifact, verifyTrace } from './artifact.mjs'
-import { flowEventsPath } from './events.mjs'
-import { parsePlan } from './planner.mjs'
-import { runPanel } from './plan-panel.mjs'
-import { createRunner } from './subagent-runner.mjs'
-import { readState, recordTransition } from './state-store.mjs'
-import { resolveActiveFlowState } from './flow-resolve.mjs'
-
-/**
- * @param {string[]} rest аргументи (`--panel`, опц. `<plan.md>`)
- * @param {{ cwd?: string, log?: (m: string) => void, runner?: object, trace?: (cwd: string) => number, now?: () => number }} [deps] ін'єкції
- * @returns {Promise<number>} exit code (0 ok, 1 нема стану/доку/невалідний план)
- */
-export async function plan(rest, deps = {}) {
-  const cwd0 = deps.cwd ?? processCwd()
-  const log = deps.log ?? console.error
-  const resolved = resolveActiveFlowState({ cwd: cwd0, branch: deps.branch }, deps)
-  if (!resolved.statePath) {
-    log(`plan: ${resolved.error}`)
-    return 1
-  }
-  if (resolved.autoResolved) log(`flow: авторезолвлено активний flow «${resolved.label}» (cwd поза worktree)`)
-  const cwd = resolved.worktreeDir ?? cwd0
-  const statePath = resolved.statePath
-  const state = readState(statePath)
-  if (!state) {
-    log('plan: стану нема — спершу `flow init`')
-    return 1
-  }
-  if (state.status !== 'spec' && !state.spec_doc) {
-    log('plan: дизайн ще не зафіксовано — рекомендовано спершу `flow spec` (не блокує)')
-  }
-
-  const doc = rest.find(a => a.endsWith('.md')) ?? resolveArtifact(cwd, 'plans', state.branch)
-  let steps
-  if (rest.includes('--panel')) {
-    let runner = deps.runner
-    if (!runner) {
-      try {
-        runner = await createRunner(deps)
-      } catch (error) {
-        log(`plan: ${error.message}`)
-        return 1
-      }
-    }
-    steps = await runPanel({ task: state.branch, cwd, runner, log, mode: 'plan' })
-    if (!steps) return 1
-  } else {
-    if (!doc || !existsSync(doc)) {
-      log('plan: нема docs/plans/<date>-<slug>.md — спершу пройди brainstorm (див. flow.mdc)')
-      return 1
-    }
-    steps = extractSteps(readFileSync(doc, 'utf8'))
-  }
-
-  let normalized
-  try {
-    normalized = parsePlan(JSON.stringify(steps))
-  } catch (error) {
-    log(`plan: ${error.message}`)
-    return 1
-  }
-
-  if (!verifyTrace(cwd, deps.trace)) {
-    log('⚠️ plan: trace виявив розрив ланцюга — перевір лінки spec/plan/flow')
-  }
-
-  recordTransition(
-    { statePath, eventsPath: flowEventsPath(cwd) },
-    { type: 'plan', steps: normalized.length },
-    s => ({ ...s, plan: normalized, plan_doc: doc ?? null, status: 'planned' }),
-    deps.now ?? Date.now
-  )
-  log(`plan: зафіксовано ${normalized.length} кроків → status: planned`)
-  return 0
-}