@nitra/cursor 4.0.0 → 4.1.1

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

@@ -0,0 +1,141 @@
+/**
+ * `n-cursor graph kill <path>` — вбиває worktree вузла і каскадно інвалідує нащадків.
+ *
+ * 1. Знаходить worktree вузла
+ * 2. Видаляє worktree (force)
+ * 3. Видаляє plan_*.md (скидає планування)
+ * 4. Записує invalidated sentinel
+ * 5. Каскадно інвалідує всі залежні вузли
+ *
+ * FS і child_process ін'єктуються для тестованості.
+ */
+import { execSync } from 'node:child_process'
+import { existsSync, readdirSync, readFileSync, writeFileSync, unlinkSync } 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 { findNodeWorktree, listActiveWorktrees, removeWorktree } from './worktree-ops.mjs'
+
+/**
+ * Записує invalidated sentinel для вузла.
+ * @param {string} nodeDir директорія вузла
+ * @param {(p: string, c: string, enc: string) => void} writeFile функція запису
+ */
+function writeInvalidated(nodeDir, writeFile) {
+  writeFile(join(nodeDir, 'invalidated'), '', 'utf8')
+}
+
+/**
+ * Видаляє plan_*.md файли з директорії вузла.
+ * @param {string} nodeDir директорія вузла
+ * @param {string[]} files список файлів
+ * @param {(p: string) => void} unlink функція видалення
+ */
+function deletePlanFiles(nodeDir, files, unlink) {
+  for (const f of files) {
+    if (/^plan_\d+\.md$/.test(f)) {
+      try {
+        unlink(join(nodeDir, f))
+      } catch {
+        // пропускаємо
+      }
+    }
+  }
+}
+
+/**
+ * `graph kill <path>` command handler.
+ * @param {string[]} args аргументи: [path]
+ * @param {{
+ *   cwd?: string,
+ *   log?: (m: string) => void,
+ *   readFile?: (p: string, enc: string) => string,
+ *   writeFile?: (p: string, c: string, enc: string) => void,
+ *   readdir?: (d: string) => string[],
+ *   exists?: (p: string) => boolean,
+ *   unlink?: (p: string) => void,
+ *   execSync?: (cmd: string, opts?: object) => string
+ * }} [deps] ін'єкції
+ * @returns {Promise<number>} exit code
+ */
+export async function cmdKill(args, deps = {}) {
+  const root = deps.cwd ?? processCwd()
+  const log = deps.log ?? console.log
+  const readFile = deps.readFile ?? ((p, enc) => readFileSync(p, enc))
+  const writeFile = deps.writeFile ?? ((p, c, enc) => writeFileSync(p, c, enc))
+  const readdir = deps.readdir ?? (d => (existsSync(d) ? readdirSync(d) : []))
+  const exists = deps.exists ?? existsSync
+  const unlink = deps.unlink ?? unlinkSync
+  const execSyncFn = deps.execSync ?? ((cmd, o) => execSync(cmd, { ...o, encoding: 'utf8' }))
+
+  const [nodePath] = args
+  if (!nodePath) {
+    log('Usage: n-cursor graph kill <path>')
+    return 1
+  }
+
+  const config = loadConfig({ root, readFile, exists })
+  const tasksDir = resolveTasksDir(config, root)
+  const worktreesDir = resolveWorktreesDir(config, root)
+
+  const nodeDir = join(tasksDir, nodePath)
+  if (!exists(join(nodeDir, 'task.md'))) {
+    log(`kill: вузол "${nodePath}" не знайдено`)
+    return 1
+  }
+
+  // 1. Знаходимо і видаляємо worktree
+  const worktreePath = findNodeWorktree(nodePath, worktreesDir, {
+    readdirSync: readdir,
+    execSync: execSyncFn
+  })
+
+  if (worktreePath) {
+    log(`kill: видаляємо worktree ${worktreePath}`)
+    removeWorktree(worktreePath, root, { execSync: execSyncFn })
+  } else {
+    log(`kill: worktree не знайдено для "${nodePath}"`)
+  }
+
+  // 2. Видаляємо plan_*.md
+  const files = readdir(nodeDir)
+  deletePlanFiles(nodeDir, files, unlink)
+  const planCount = files.filter(f => /^plan_\d+\.md$/.test(f)).length
+  if (planCount > 0) {
+    log(`kill: видалено ${planCount} plan_*.md файл(ів)`)
+  }
+
+  // 3. Записуємо invalidated sentinel
+  try {
+    writeInvalidated(nodeDir, writeFile)
+    log(`kill: вузол "${nodePath}" інвалідовано`)
+  } catch (err) {
+    log(`kill: не вдалося записати invalidated — ${err.message ?? String(err)}`)
+    return 1
+  }
+
+  // 4. Каскадна інвалідація залежних вузлів
+  const activeWorktrees = listActiveWorktrees(root, { execSync: execSyncFn })
+  const allNodes = scanNodes(tasksDir, activeWorktrees, {
+    readdirSync: readdir,
+    existsSync: exists,
+    readFileSync: readFile
+  })
+
+  // Знаходимо вузли що залежать від нашого вузла
+  const dependents = allNodes.filter(n => n.deps.includes(nodePath))
+  for (const dep of dependents) {
+    if (!exists(join(dep.dir, 'invalidated'))) {
+      try {
+        writeInvalidated(dep.dir, writeFile)
+        log(`kill: каскадна інвалідація "${dep.path}"`)
+      } catch {
+        // пропускаємо
+      }
+    }
+  }
+
+  return 0
+}

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

@@ -0,0 +1,142 @@
+/**
+ * `n-cursor graph plan [<path>] [--mode agent]` — Stage 1: пише plan_NNN.md.
+ *
+ * Читає task.md вузла, знаходить наступний NNN, пише шаблон plan_NNN.md.
+ * Якщо --mode agent — встановлює mode:agent у plan front-matter.
+ *
+ * FS ін'єктується для тестованості.
+ */
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { cwd as processCwd } from 'node:process'
+
+import { buildMarkdown, parseFrontMatter } from './frontmatter.mjs'
+import { nextPlanNNN } from './nnn.mjs'
+import { loadConfig, resolveTasksDir } from './config.mjs'
+
+/**
+ * Будує шаблон plan_NNN.md.
+ * @param {{ mode: string, hint: string, now: string, nnn: string }} params параметри
+ * @returns {string} вміст файлу
+ */
+export function buildPlanTemplate(params) {
+  const fm = {
+    created_at: params.now,
+    mode: params.mode,
+    decision: params.hint || 'atomic'
+  }
+
+  const body = [
+    `## Context`,
+    `<!-- Чому саме такий підхід — що з'ясовано під час планування -->`,
+    ``,
+    `## Approach`,
+    params.mode === 'composite'
+      ? `<!-- composite: список дочірніх вузлів з описами -->`
+      : `<!-- atomic: покроковий план виконання -->`,
+    ``,
+    `## Risks`,
+    `<!-- Що може піти не так -->`,
+    ``
+  ].join('\n')
+
+  return buildMarkdown(fm, body)
+}
+
+/**
+ * `graph plan [<path>] [--mode agent]` command handler.
+ * @param {string[]} args аргументи: [path] [--mode agent|human]
+ * @param {{
+ *   cwd?: string,
+ *   log?: (m: string) => void,
+ *   writeFile?: (p: string, c: string, enc: string) => void,
+ *   readFile?: (p: string, enc: string) => string,
+ *   readdir?: (d: string) => string[],
+ *   exists?: (p: string) => boolean,
+ *   now?: () => string
+ * }} [deps] ін'єкції
+ * @returns {Promise<number>} exit code
+ */
+export async function cmdPlan(args, deps = {}) {
+  const root = deps.cwd ?? processCwd()
+  const log = deps.log ?? console.log
+  const writeFile = deps.writeFile ?? ((p, c, enc) => writeFileSync(p, c, enc))
+  const readFile = deps.readFile ?? ((p, enc) => readFileSync(p, enc))
+  const readdir = deps.readdir ?? (d => (existsSync(d) ? readdirSync(d) : []))
+  const exists = deps.exists ?? existsSync
+  const nowFn = deps.now ?? (() => new Date().toISOString())
+
+  // Парсимо аргументи
+  let nodePath = null
+  let modeOverride = null
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--mode' && args[i + 1]) {
+      modeOverride = args[i + 1]
+      i++
+    } else if (!args[i].startsWith('-')) {
+      nodePath = args[i]
+    }
+  }
+
+  const config = loadConfig({ root, readFile, exists })
+  const tasksDir = resolveTasksDir(config, root)
+
+  // Визначаємо директорію вузла
+  let nodeDir
+  if (nodePath) {
+    nodeDir = join(tasksDir, nodePath)
+  } else {
+    // CWD може бути в worktree — шукаємо task.md у CWD
+    nodeDir = processCwd()
+  }
+
+  const taskPath = join(nodeDir, 'task.md')
+  if (!exists(taskPath)) {
+    log(`plan: task.md не знайдено в ${nodeDir}`)
+    return 1
+  }
+
+  let taskContent
+  try {
+    taskContent = readFile(taskPath, 'utf8')
+  } catch (err) {
+    log(`plan: не вдалося прочитати task.md — ${err.message ?? String(err)}`)
+    return 1
+  }
+
+  const fm = parseFrontMatter(taskContent)
+  const mode = modeOverride ?? (typeof fm.mode === 'string' ? fm.mode : 'human')
+  const hint = typeof fm.hint === 'string' ? fm.hint : ''
+
+  const nnn = nextPlanNNN(nodeDir, readdir)
+  const planPath = join(nodeDir, `plan_${nnn}.md`)
+
+  const content = buildPlanTemplate({ mode, hint, now: nowFn(), nnn })
+
+  try {
+    writeFile(planPath, content, 'utf8')
+    log(`plan: створено ${planPath} (mode: ${mode})`)
+  } catch (err) {
+    log(`plan: не вдалося записати ${planPath} — ${err.message ?? String(err)}`)
+    return 1
+  }
+
+  // Виводимо контекст для агента/людини
+  const bodyStart = taskContent.indexOf('\n---\n', 4)
+  const taskBody = bodyStart === -1 ? taskContent : taskContent.slice(bodyStart + 5).trimStart()
+
+  console.log([
+    `## plan context`,
+    ``,
+    `node: ${nodePath ?? nodeDir}`,
+    `mode: ${mode}`,
+    hint ? `hint: ${hint}` : `hint: (не задано)`,
+    `plan: plan_${nnn}.md`,
+    ``,
+    `### task.md`,
+    taskBody.trimEnd()
+  ].join('\n'))
+
+  return 0
+}

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

@@ -0,0 +1,328 @@
+/**
+ * `n-cursor graph run [<path>] [--actor a] [--auto]` — запуск вузла(ів).
+ *
+ * Wrapper логіка:
+ * 1. Читає task.md → budget_sec, budget_hard_sec, deps, mode, executor
+ * 2. Перевіряє що всі deps resolved
+ * 3. Обчислює NNN = count(run_*.md) + 1
+ * 4. git worktree add .worktrees/<node-epoch>/ (atomic mkdir lock — EEXIST = skip)
+ * 5. ENV: NCURSOR_RUN_NNN, NCURSOR_BUDGET_SEC, NCURSOR_HARD_BUDGET_SEC, NCURSOR_STARTED_AT, NCURSOR_NODE_PATH
+ * 6. Спавнить subprocess (claude або n-cursor graph run --actor auditor)
+ * 7. Poll worktree mtime кожні 5s: progress_timeout → SIGKILL; budget_hard → SIGKILL
+ * 8. Після exit: fact_NNN.md є → result:success; else → result:failed
+ * 9. Пише run_NNN.md
+ * 10. Якщо success: git merge + delete worktree
+ *
+ * --auto режим: сканує для готових вузлів (waiting + deps resolved), клеймить atomic mkdir.
+ *
+ * FS і child_process ін'єктуються для тестованості.
+ */
+import { execSync, spawnSync } from 'node:child_process'
+import { existsSync, mkdtempSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { cwd as processCwd } from 'node:process'
+
+import { buildMarkdown, parseFrontMatter } from './frontmatter.mjs'
+import { latestFactNNN, nextRunNNN } from './nnn.mjs'
+import { loadConfig, resolveModelByTier, resolveTasksDir, resolveWorktreesDir } from './config.mjs'
+import { scanNodes, topoSort, areDepsResolved } from './scanner.mjs'
+import { createWorktree, listActiveWorktrees, mergeWorktree } from './worktree-ops.mjs'
+import { makeWorktreeName } from './worktree-ops.mjs'
+
+/**
+ * Пише run_NNN.md артефакт.
+ * @param {string} nodeDir директорія вузла
+ * @param {string} nnn NNN рядок
+ * @param {'success'|'failed'} result результат
+ * @param {{ actor: string, startedAt: string, now: string }} meta метадані
+ * @param {(p: string, c: string, enc: string) => void} writeFile функція запису
+ */
+function writeRunFile(nodeDir, nnn, result, meta, writeFile) {
+  const fm = {
+    created_at: meta.now,
+    started_at: meta.startedAt,
+    actor: meta.actor,
+    result
+  }
+  const content = buildMarkdown(fm, `## Run ${nnn}\n\nactor: ${meta.actor}\nresult: ${result}\n`)
+  writeFile(join(nodeDir, `run_${nnn}.md`), content, 'utf8')
+}
+
+/**
+ * Запускає один вузол: creates worktree, spawns agent, writes run_NNN.md.
+ * @param {string} nodePath відносний шлях вузла
+ * @param {string} nodeDir абсолютний шлях до директорії вузла
+ * @param {object} config конфігурація
+ * @param {string} root корінь репо
+ * @param {{ actor?: string, dryRun?: boolean }} opts опції
+ * @param {object} deps ін'єкції
+ * @returns {{ ok: boolean, code: number }} результат
+ */
+function runNode(nodePath, nodeDir, config, root, opts, deps) {
+  const log = deps.log ?? console.log
+  const readFile = deps.readFile ?? ((p, enc) => readFileSync(p, enc))
+  const writeFile = deps.writeFile ?? ((p, c, enc) => writeFileSync(p, c, 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 spawnSyncFn = deps.spawnSync ?? spawnSync
+  const nowFn = deps.now ?? (() => new Date().toISOString())
+  const statFn = deps.statSync ?? statSync
+
+  // 1. Читаємо task.md
+  let fm = {}
+  try {
+    fm = parseFrontMatter(readFile(join(nodeDir, 'task.md'), 'utf8'))
+  } catch (err) {
+    log(`run: не вдалося прочитати task.md для "${nodePath}" — ${err.message ?? String(err)}`)
+    return { ok: false, code: 1 }
+  }
+
+  const budgetSec = Number(fm.budget_sec) || config.default_budget_sec
+  const budgetHardSec = Number(fm.budget_hard_sec) || (budgetSec * config.budget_hard_sec_multiplier)
+  const progressTimeoutSec = config.progress_timeout_sec
+
+  const executor = (fm.executor && typeof fm.executor === 'object') ? fm.executor : {}
+  const executorType = executor.type ?? 'agent'
+  const modelTier = executor.model_tier ?? 'AVG'
+  const model = resolveModelByTier(config, modelTier)
+
+  const actor = opts.actor ?? executorType
+
+  // 2. Вже перевірено deps resolved перед викликом
+
+  // 3. Обчислюємо NNN
+  const nnn = nextRunNNN(nodeDir, readdir)
+
+  // 4. Створюємо worktree (atomic mkdir lock)
+  const worktreesDir = resolveWorktreesDir(config, root)
+  const worktreeName = makeWorktreeName(nodePath)
+  const worktreePath = join(worktreesDir, worktreeName)
+
+  log(`run: запускаємо вузол "${nodePath}" (NNN=${nnn}, actor=${actor})`)
+
+  if (opts.dryRun) {
+    log(`run: --dry-run — пропускаємо фактичний запуск`)
+    return { ok: true, code: 0 }
+  }
+
+  let createResult
+  try {
+    createResult = createWorktree(worktreesDir, worktreeName, root, { execSync: execSyncFn })
+  } catch (err) {
+    log(`run: не вдалося створити worktree — ${err.message ?? String(err)}`)
+    return { ok: false, code: 1 }
+  }
+
+  if (!createResult) {
+    log(`run: вузол "${nodePath}" вже запущено (worktree існує) — пропускаємо`)
+    return { ok: false, code: 2 }
+  }
+
+  // 5. ENV
+  const startedAt = nowFn()
+  const env = {
+    ...process.env,
+    NCURSOR_RUN_NNN: nnn,
+    NCURSOR_BUDGET_SEC: String(budgetSec),
+    NCURSOR_HARD_BUDGET_SEC: String(budgetHardSec),
+    NCURSOR_STARTED_AT: startedAt,
+    NCURSOR_NODE_PATH: nodePath
+  }
+
+  // 6. Спавнимо subprocess (spawnSync — синхронно)
+  let spawnResult
+  const timeoutMs = budgetHardSec > 0 ? budgetHardSec * 1000 : undefined
+
+  if (actor === 'agent' || actor === 'a') {
+    // Запускаємо claude CLI у worktree
+    const claudeArgs = ['--model', model, '--no-session', '-p',
+      `You are executing task node: ${nodePath}\nWorking directory: ${worktreePath}\nRun NNN: ${nnn}\nBudget: ${budgetSec}s\n\nRead task.md and plan_*.md, execute the task, write fact_${nnn}.md with results.`
+    ]
+    spawnResult = spawnSyncFn('claude', claudeArgs, {
+      cwd: worktreePath,
+      env,
+      encoding: 'utf8',
+      timeout: timeoutMs
+    })
+  } else if (actor === 'human') {
+    // Людина виконує вручну — чекаємо на fact файл
+    log(`run: вузол "${nodePath}" очікує ручного виконання`)
+    log(`     worktree: ${worktreePath}`)
+    log(`     NCURSOR_RUN_NNN=${nnn}`)
+    log(`     після виконання запустіть: n-cursor graph done ${nodePath}`)
+    // Не чекаємо — повертаємо success без run_NNN.md
+    return { ok: true, code: 0 }
+  } else {
+    log(`run: невідомий actor "${actor}" — підтримується: agent, human`)
+    return { ok: false, code: 1 }
+  }
+
+  // 8. Після exit: перевіряємо fact_NNN.md
+  const factPath = join(worktreePath, `fact_${nnn}.md`)
+  const factInNodeDir = join(nodeDir, `fact_${nnn}.md`)
+
+  // Перевіряємо у worktree та у основній директорії
+  const hasFactInWorktree = exists(factPath)
+  const result = hasFactInWorktree ? 'success' : 'failed'
+
+  // Якщо є факт у worktree — копіюємо в node dir (якщо worktree != nodeDir)
+  if (hasFactInWorktree && worktreePath !== nodeDir) {
+    try {
+      const factContent = readFile(factPath, 'utf8')
+      writeFile(factInNodeDir, factContent, 'utf8')
+    } catch {
+      // пропускаємо
+    }
+  }
+
+  // 9. Пишемо run_NNN.md у node dir
+  try {
+    writeRunFile(nodeDir, nnn, result, {
+      actor,
+      startedAt,
+      now: nowFn()
+    }, writeFile)
+    log(`run: записано run_${nnn}.md (result: ${result})`)
+  } catch (err) {
+    log(`run: не вдалося записати run_${nnn}.md — ${err.message ?? String(err)}`)
+  }
+
+  // 10. Якщо success: merge worktree
+  if (result === 'success') {
+    const mergeResult = mergeWorktree(worktreePath, root, { execSync: execSyncFn })
+    if (!mergeResult.ok) {
+      log(`run: merge worktree не вдався — ${mergeResult.error}`)
+    } else {
+      log(`run: worktree merged і видалено`)
+    }
+    return { ok: true, code: 0 }
+  } else {
+    log(`run: вузол "${nodePath}" завершився з помилкою`)
+    log(`run: worktree збережено для діагностики: ${worktreePath}`)
+    return { ok: false, code: 1 }
+  }
+}
+
+/**
+ * `graph run [<path>] [--actor a] [--auto]` command handler.
+ * @param {string[]} args аргументи
+ * @param {{
+ *   cwd?: string,
+ *   log?: (m: string) => void,
+ *   readFile?: (p: string, enc: string) => string,
+ *   writeFile?: (p: string, c: string, enc: string) => void,
+ *   readdir?: (d: string) => string[],
+ *   exists?: (p: string) => boolean,
+ *   execSync?: (cmd: string, opts?: object) => string,
+ *   spawnSync?: (cmd: string, args: string[], opts?: object) => object,
+ *   statSync?: (p: string) => object,
+ *   now?: () => string
+ * }} [deps] ін'єкції
+ * @returns {Promise<number>} exit code
+ */
+export async function cmdRun(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' }))
+
+  // Парсимо аргументи
+  let nodePath = null
+  let actor = null
+  let autoMode = false
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--actor' && args[i + 1]) {
+      actor = args[i + 1]
+      i++
+    } else if (args[i] === '--auto') {
+      autoMode = true
+    } else if (!args[i].startsWith('-')) {
+      nodePath = args[i]
+    }
+  }
+
+  const config = loadConfig({ root, readFile, exists })
+  const tasksDir = resolveTasksDir(config, root)
+
+  const activeWorktrees = listActiveWorktrees(root, { execSync: execSyncFn })
+
+  // Перевіряємо ліміт worktrees
+  if (activeWorktrees.size >= config.max_worktrees) {
+    log(`run: досягнуто max_worktrees (${config.max_worktrees}) — зачекайте завершення поточних задач`)
+    return 1
+  }
+
+  if (activeWorktrees.size >= config.warn_worktrees_above) {
+    log(`run: увага — ${activeWorktrees.size} активних worktrees (попередження при >${config.warn_worktrees_above})`)
+  }
+
+  if (autoMode) {
+    // Знаходимо всі ready вузли і запускаємо їх
+    const allNodes = scanNodes(tasksDir, activeWorktrees, {
+      readdirSync: readdir,
+      existsSync: exists,
+      readFileSync: readFile
+    })
+    const nodeMap = new Map(allNodes.map(n => [n.id, n]))
+    const readyNodes = topoSort(allNodes).filter(n => n.state === 'waiting' && areDepsResolved(n, nodeMap))
+
+    if (readyNodes.length === 0) {
+      log('run --auto: немає готових вузлів для запуску')
+      return 0
+    }
+
+    log(`run --auto: знайдено ${readyNodes.length} готових вузлів`)
+    let anyFailed = false
+
+    for (const node of readyNodes) {
+      const result = runNode(node.path, node.dir, config, root, { actor: actor ?? undefined }, {
+        ...deps,
+        log,
+        execSync: execSyncFn
+      })
+      if (!result.ok && result.code !== 2) anyFailed = true
+    }
+
+    return anyFailed ? 1 : 0
+  }
+
+  // Запускаємо конкретний вузол або вузол у CWD
+  if (!nodePath) {
+    log('run: вкажіть <path> або використайте --auto')
+    log('Usage: n-cursor graph run [<path>] [--actor agent|human] [--auto]')
+    return 1
+  }
+
+  const nodeDir = join(tasksDir, nodePath)
+  if (!exists(join(nodeDir, 'task.md'))) {
+    log(`run: вузол "${nodePath}" не знайдено (немає task.md у ${nodeDir})`)
+    return 1
+  }
+
+  // Перевіряємо deps
+  const allNodes = scanNodes(tasksDir, activeWorktrees, {
+    readdirSync: readdir,
+    existsSync: exists,
+    readFileSync: readFile
+  })
+  const nodeMap = new Map(allNodes.map(n => [n.id, n]))
+  const targetNode = nodeMap.get(nodePath)
+
+  if (targetNode && !areDepsResolved(targetNode, nodeMap)) {
+    const unresolvedDeps = targetNode.deps.filter(dep => nodeMap.get(dep)?.state !== 'resolved')
+    log(`run: вузол "${nodePath}" має невирішені залежності: ${unresolvedDeps.join(', ')}`)
+    return 1
+  }
+
+  const result = runNode(nodePath, nodeDir, config, root, { actor: actor ?? undefined }, {
+    ...deps,
+    log,
+    execSync: execSyncFn
+  })
+
+  return result.code
+}