@nitra/cursor 3.29.0 → 4.0.0

package/skills/docgen/js/docgen-gen.mjs

@@ -1,70 +1,14 @@
 /** @see ./docs/docgen-gen.md */
 import { readFileSync } from 'node:fs'
 import { basename } from 'node:path'
-import { request } from 'node:http'
 import { spawnSync } from 'node:child_process'
 import { env } from 'node:process'
-import { LOCAL_MIN, resolveModel } from '../../../lib/models.mjs'
+import { resolveModel } from '../../../lib/models.mjs'
 import { extractFacts } from './docgen-extract.mjs'
-import { sectionMessages, oneShotMessages, STYLE, oneShotPromptText } from './docgen-prompts.mjs'
-
-/** Strips provider prefix from tier string for direct ollama HTTP (ollama/gemma3:4b → gemma3:4b). */
-function localModelId(tier) {
-  if (!tier) return 'gemma3:4b'
-  const i = tier.indexOf('/')
-  return i === -1 ? tier : tier.slice(i + 1)
-}
+import { STYLE, oneShotPromptText, sectionMessages } from './docgen-prompts.mjs'
 
 const QUALITY_THRESHOLD = 70
 
-/** Один виклик чату до ollama зі streaming (токени стримуються → socket активний, жодного timeout). */
-async function ollamaChat(messages, { model, numPredict = 600 }) {
-  const body = JSON.stringify({
-    model,
-    messages,
-    stream: true,
-    think: false,
-    options: { num_ctx: 8192, temperature: 0.2, num_predict: numPredict },
-    keep_alive: '15m'
-  })
-  return new Promise((resolve, reject) => {
-    const req = request(
-      {
-        hostname: 'localhost',
-        port: 11434,
-        path: '/api/chat',
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) }
-      },
-      res => {
-        let text = '',
-          genTok = 0,
-          buf = ''
-        res.on('data', chunk => {
-          buf += chunk.toString()
-          const lines = buf.split('\n')
-          buf = lines.pop()
-          for (const line of lines) {
-            if (!line.trim()) continue
-            try {
-              const j = JSON.parse(line)
-              text += j.message?.content ?? ''
-              if (j.done) genTok = j.eval_count ?? 0
-            } catch {
-              /* partial line */
-            }
-          }
-        })
-        res.on('end', () => resolve({ text, genTok }))
-        res.on('error', reject)
-      }
-    )
-    req.on('error', reject)
-    req.write(body)
-    req.end()
-  })
-}
-
 /** Прибирає ```-обгортку й випадковий провідний `##`-заголовок із секції. */
 function stripSection(text) {
   let t = text.trim()
@@ -145,17 +89,21 @@ function scoreDoc(md, facts) {
   return { score: Math.max(0, score), issues }
 }
 
-/** Tier 2: виклик через pi (провайдер-нейтрально). model — рядок `provider/model-id`. */
-function piOneShot(facts, src, model) {
-  const fullPrompt = `${STYLE}\n\n${oneShotPromptText(facts, src)}`
+/** Викликає pi і повертає stdout. Кидає якщо pi повертає ненульовий код. */
+function callPi(prompt, model, timeoutMs) {
   const modelArgs = model ? ['--model', model] : []
-  const r = spawnSync('pi', ['-p', fullPrompt, ...modelArgs, '--no-session', '--mode', 'text', '--no-tools'], {
+  const r = spawnSync('pi', ['-p', prompt, ...modelArgs, '--no-session', '--mode', 'text', '--no-tools'], {
     encoding: 'utf8',
-    timeout: 120_000
+    timeout: timeoutMs
   })
-  if (r.error) throw new Error(`pi Tier 2 error: ${r.error.message}`)
-  if (r.status !== 0) throw new Error(`pi Tier 2 exit ${r.status}: ${r.stderr?.slice(0, 300) ?? ''}`)
-  const text = r.stdout?.trim() ?? ''
+  if (r.error) throw new Error(`pi error: ${r.error.message}`)
+  if (r.status !== 0) throw new Error(`pi exit ${r.status}: ${r.stderr?.slice(0, 300) ?? ''}`)
+  return r.stdout?.trim() ?? ''
+}
+
+/** One-shot: один pi-виклик на весь документ. */
+function piOneShot(facts, src, model, timeoutMs = 120_000) {
+  const text = callPi(`${STYLE}\n\n${oneShotPromptText(facts, src)}`, model, timeoutMs)
   let md = stripSignatures(stripSection(text))
   if (!md.startsWith('#')) md = `# ${basename(facts.relPath)}\n\n${md}`
   return { md: md + '\n', genTok: 0 }
@@ -177,58 +125,43 @@ function assemble(stem, sections) {
   return parts.join('\n\n') + '\n'
 }
 
-/** Оркестрований режим: секційно-мінімальний контекст — код інгестується лише в `behavior`. */
-async function generateOrchestrated(facts, src, model) {
+/**
+ * Orchestrated: N окремих pi-викликів, по одному на секцію.
+ * Код потрапляє лише в `behavior`; решта секцій — на мінімальному факт-листі.
+ */
+function piOrchestrated(facts, src, model, timeoutMs) {
   const sections = {}
-  let genTok = 0
   for (const s of sectionMessages(facts, src)) {
-    const { text, genTok: g } = await ollamaChat(s.messages, { model, numPredict: s.numPredict })
-    sections[s.key] = stripSignatures(stripSection(text))
-    genTok += g
+    // messages = [{role:'system',content}, {role:'user',content}] → plain text prompt для pi
+    const prompt = s.messages.map(m => m.content).join('\n\n')
+    sections[s.key] = stripSignatures(stripSection(callPi(prompt, model, timeoutMs)))
   }
-  return { md: assemble(basename(facts.relPath), sections), genTok }
+  return { md: assemble(basename(facts.relPath), sections), genTok: 0 }
 }
 
-/** One-shot режим: один промпт на весь документ. */
-async function generateOneShot(facts, src, model) {
-  const { text, genTok } = await ollamaChat(oneShotMessages(facts, src), { model, numPredict: 1500 })
-  let md = stripSignatures(stripSection(text)) // Stage-2 лінт і для one-shot
-  if (!md.startsWith('#')) md = `# ${basename(facts.relPath)}\n\n${md}`
-  return { md: md + '\n', genTok }
-}
 
-/** Файли з sym ≥ цього значення одразу йдуть у Tier 2 (без локального проходу). */
+
+/** Файли з sym ≥ цього значення одразу йдуть у Tier 2 (без Tier 1 проходу). */
 const DEFAULT_SYM_THRESHOLD = 4
-/** Максимальний час локальної генерації на один файл перед ескалацією у Tier 2. */
+/** Максимальний час Tier 1 генерації на один файл перед ескалацією у Tier 2. */
 const LOCAL_TIMEOUT_MS = 5 * 60 * 1000
-/** Дефолтна Tier 1 модель: N_CURSOR_DOCGEN_MODEL → LOCAL_MIN → ollama gemma3:4b. */
-const DEFAULT_LOCAL_MODEL = localModelId(env.N_CURSOR_DOCGEN_MODEL ?? LOCAL_MIN)
-/** Дефолтна Tier 2 модель (provider/model-id для pi): N_CURSOR_DOCGEN_CLOUD_MODEL → resolveModel('avg'). */
+/** Дефолтна Tier 1 модель: N_CURSOR_DOCGEN_MODEL → resolveModel('min'). */
+const DEFAULT_LOCAL_MODEL = env.N_CURSOR_DOCGEN_MODEL ?? resolveModel('min')
+/** Дефолтна Tier 2 модель: N_CURSOR_DOCGEN_CLOUD_MODEL → resolveModel('avg'). */
 const DEFAULT_CLOUD_MODEL = env.N_CURSOR_DOCGEN_CLOUD_MODEL ?? resolveModel('avg')
 
-/** Повертає promise, що відхиляється через `ms` мс з повідомленням про timeout. */
-function withTimeout(promise, ms) {
-  return Promise.race([
-    promise,
-    new Promise((_, reject) => setTimeout(() => reject(new Error(`local timeout after ${ms / 1000}s`)), ms))
-  ])
-}
-
 /**
  * Головний API: файл → { md, genTok, ms, score, issues, tier }.
  *
  * Routing (sym-threshold):
- *   sym < symThreshold  → Tier 1 local (timeout: LOCAL_TIMEOUT_MS) + det-scorer
+ *   sym < symThreshold  → Tier 1 pi(resolveModel('min'), timeout=5хв) + det-scorer
  *                       → timeout або det-score < threshold → Tier 2
  *   sym >= symThreshold → Pre-routing одразу Tier 2
- *
- * @param {string}  cloudModel    — модель для Tier 2 генерації (Sonnet за замовч.)
  */
 export async function generateDoc(
   file,
   {
     model = DEFAULT_LOCAL_MODEL,
-    mode = 'orchestrated',
     cloudModel = DEFAULT_CLOUD_MODEL,
     threshold = QUALITY_THRESHOLD,
     symThreshold = DEFAULT_SYM_THRESHOLD
@@ -238,39 +171,24 @@ export async function generateDoc(
   const facts = extractFacts(src, file)
   const t0 = Date.now()
 
-  // Pre-routing: складні файли (sym ≥ symThreshold) → одразу Tier 2, не витрачаємо local-час
+  // Pre-routing: складні файли (sym ≥ symThreshold) → одразу Tier 2
   const complexity = facts.internalSymbols?.length ?? 0
   if (complexity >= symThreshold && cloudModel) {
     const r2 = piOneShot(facts, src, cloudModel)
-    return {
-      ...r2,
-      ms: Date.now() - t0,
-      score: null,
-      issues: [`pre-routed:sym=${complexity}`],
-      tier: 2,
-      model: cloudModel
-    }
+    return { ...r2, ms: Date.now() - t0, score: null, issues: [`pre-routed:sym=${complexity}`], tier: 2, model: cloudModel }
   }
 
-  // Tier 1: локальна генерація з timeout 5 хв — при перевищенні одразу Tier 2
+  // Tier 1: pi orchestrated (секція за секцією), timeout на секцію = LOCAL_TIMEOUT_MS
+  // facts.unsupported → one-shot (структура файлу нестандартна)
   let r
   try {
-    const localPromise =
-      facts.unsupported || mode === 'oneshot'
-        ? generateOneShot(facts, src, model)
-        : generateOrchestrated(facts, src, model)
-    r = await withTimeout(localPromise, LOCAL_TIMEOUT_MS)
+    r = facts.unsupported
+      ? piOneShot(facts, src, model, LOCAL_TIMEOUT_MS)
+      : piOrchestrated(facts, src, model, LOCAL_TIMEOUT_MS)
   } catch (e) {
     if (cloudModel) {
       const r2 = piOneShot(facts, src, cloudModel)
-      return {
-        ...r2,
-        ms: Date.now() - t0,
-        score: null,
-        issues: [`local-timeout: ${e.message}`],
-        tier: 2,
-        model: cloudModel
-      }
+      return { ...r2, ms: Date.now() - t0, score: null, issues: [`tier1-error: ${e.message}`], tier: 2, model: cloudModel }
     }
     throw e
   }
@@ -286,19 +204,18 @@ export async function generateDoc(
   return { ...r, ms: Date.now() - t0, score: detScore, issues: detIssues, tier: 1, model }
 }
 
-// CLI: node docgen-gen.mjs <file> [--oneshot] [--model <m>] [--sym-threshold N] [--tier-only]
+// CLI: node docgen-gen.mjs <file> [--model <m>] [--sym-threshold N] [--tier-only]
 import { isRunAsCli } from '../../../scripts/cli-entry.mjs'
 if (isRunAsCli(import.meta.url)) {
   const args = process.argv.slice(2)
   const file = args.find(a => !a.startsWith('--'))
-  const mode = args.includes('--oneshot') ? 'oneshot' : 'orchestrated'
   const tierOnly = args.includes('--tier-only')
   const mi = args.indexOf('--model')
   const model = mi >= 0 ? args[mi + 1] : DEFAULT_LOCAL_MODEL
   const si = args.indexOf('--sym-threshold')
   const symThreshold = si >= 0 ? Number(args[si + 1]) : DEFAULT_SYM_THRESHOLD
   if (!file) {
-    console.error('Usage: node docgen-gen.mjs <file> [--oneshot] [--model <m>] [--sym-threshold N] [--tier-only]')
+    console.error('Usage: node docgen-gen.mjs <file> [--model <m>] [--sym-threshold N] [--tier-only]')
     process.exit(1)
   }
   if (tierOnly) {
@@ -313,8 +230,8 @@ if (isRunAsCli(import.meta.url)) {
     process.stdout.write(`${icon} ${label}  |  ${file}\n`)
     process.exit(0)
   }
-  const r = await generateDoc(file, { model, mode, symThreshold })
+  const r = await generateDoc(file, { model, symThreshold })
   const issuesTxt = r.issues?.length ? ` issues=${r.issues.join(',')}` : ''
-  process.stderr.write(`[tier${r.tier} ${mode}] ${r.ms}ms / ${r.genTok} tok / score=${r.score}${issuesTxt}\n`)
+  process.stderr.write(`[tier${r.tier} pi-orchestrated] ${r.ms}ms / score=${r.score}${issuesTxt}\n`)
   process.stdout.write(r.md)
 }

package/scripts/dispatcher/lib/active.mjs

@@ -1,222 +0,0 @@
-/**
- * Активний Раннер (spec §8.1 Фасад B): `run`/`resume`/`cancel`/`repair`. Зшиває
- * ensureWorktree + planner + executor + verify у повний 5-фазний цикл. Уся IO
- * ін'єктується (`runner`/`verify`/`commit`/`run`/`now`) — тестується без
- * реальних LLM/git/gates.
- */
-import { spawnSync } from 'node:child_process'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { cwd as processCwd } from 'node:process'
-
-import { BudgetExceeded, withBudget } from './budget.mjs'
-import { ensureWorktree, realRun } from './commands.mjs'
-import { flowEventsPath } from './events.mjs'
-import { executePlan } from './executor.mjs'
-import { generatePlan } from './planner.mjs'
-import { runReview } from './reviewer.mjs'
-import { cleanupFlowSiblings, flowStatePath, readState, updateState, writeState } from './state-store.mjs'
-import { createRunner } from './subagent-runner.mjs'
-
-/**
- * Дефолтний commit: `git add -A && git commit -m` у worktree.
- * @param {string} cwd worktree
- * @param {string} msg повідомлення
- * @returns {void}
- */
-function defaultCommit(cwd, msg) {
-  spawnSync('git', ['add', '-A'], { cwd })
-  spawnSync('git', ['commit', '-m', msg], { cwd })
-}
-
-/**
- * Дефолтний verify для executor-а: проганяє gates і повертає verdict.
- * @param {string} cwd worktree
- * @returns {{ pass: boolean, failedOutput: string | null }} verdict
- */
-function defaultVerify(cwd) {
-  return runReview({ run: realRun, cwd, fingerprint: () => null })
-}
-
-/**
- * Читає `flow.autonomous` із `.n-cursor.json` (бюджет автономного режиму).
- * @param {string} cwd корінь
- * @returns {{ maxApiCalls?: number, maxCostUsd?: number, onBudgetExceeded?: string }} конфіг бюджету
- */
-function readFlowAutonomous(cwd) {
-  try {
-    const cfg = JSON.parse(readFileSync(join(cwd, '.n-cursor.json'), 'utf8'))
-    return cfg?.flow?.autonomous ?? {}
-  } catch {
-    return {}
-  }
-}
-
-/**
- * `flow run [--autonomous] <branch> "<task>"` — повний цикл: ensureWorktree →
- * план → executor. У `--autonomous` runner обгортається budget guard-ом (§9.4).
- * @param {string[]} rest аргументи (`--autonomous` + `<branch> <task...>`)
- * @param {{ runner?: object, verify?: (cwd: string) => object, commit?: (cwd: string, msg: string) => void, run?: (cmd: string, args: string[], opts: object) => object, autonomous?: boolean, budget?: object, cwd?: string, log?: (m: string) => void, now?: () => number }} [deps] ін'єкції
- * @returns {Promise<number>} exit code: 0 done, 1 fail, 2 blocked-on-human
- */
-export async function run(rest, deps = {}) {
-  const log = deps.log ?? console.error
-  const now = deps.now ?? Date.now
-  const autonomous = deps.autonomous ?? rest.includes('--autonomous')
-  const positional = rest.filter(a => !a.startsWith('--'))
-
-  const ew = ensureWorktree(positional, deps)
-  if (ew.code !== 0) return ew.code
-  const { worktreeDir, branch, desc, baseCommit } = ew
-  const statePath = flowStatePath(worktreeDir)
-  writeState(statePath, {
-    branch,
-    status: 'in_progress',
-    started_at: new Date(now()).toISOString(),
-    metadata: { base_commit: baseCommit },
-    plan: []
-  })
-
-  let runner
-  try {
-    runner = deps.runner ?? (await createRunner(deps))
-  } catch (error) {
-    log(`run: ${error.message}`)
-    return 1
-  }
-  if (autonomous) {
-    const budget = deps.budget ?? readFlowAutonomous(deps.cwd ?? processCwd())
-    runner = withBudget(runner, { maxApiCalls: budget.maxApiCalls, log })
-  }
-
-  try {
-    const plan = await generatePlan({ runner, task: desc, cwd: worktreeDir })
-    updateState(statePath, s => ({ ...s, plan }))
-    const result = await executePlan(
-      { statePath, eventsPath: flowEventsPath(worktreeDir) },
-      { runner, verify: deps.verify ?? defaultVerify, commit: deps.commit ?? defaultCommit, cwd: worktreeDir, log, now }
-    )
-    if (result.status === 'done') {
-      log('run: build done — далі `flow release`')
-      return 0
-    }
-    if (result.status === 'blocked-on-human') {
-      log(`run: blocked-on-human на кроці ${result.step}`)
-      return 2
-    }
-    return 1
-  } catch (error) {
-    if (error instanceof BudgetExceeded) {
-      log(`run: ${error.message} — abort`)
-      updateState(statePath, s => ({ ...s, status: 'failed' }))
-      return 1
-    }
-    log(`run: ${error.message}`)
-    return 1
-  }
-}
-
-/**
- * `flow resume` — продовжує з чекпойнта. Safe-resume (§4.1.7): скидає частковий
- * доробок до останнього коміту; застосовує HITL-відповіді як підказки й дає
- * крокам свіжі спроби.
- * @param {string[]} _rest аргументи (не використовуються)
- * @param {object} [deps] ін'єкції (як у `run`)
- * @returns {Promise<number>} exit code
- */
-export async function resume(_rest, deps = {}) {
-  const cwd = deps.cwd ?? processCwd()
-  const log = deps.log ?? console.error
-  const now = deps.now ?? Date.now
-  const run_ = deps.run ?? realRun
-
-  const statePath = flowStatePath(cwd)
-  const state = readState(statePath)
-  if (!state) {
-    log('resume: стану нема')
-    return 1
-  }
-
-  const openHitl = (state.hitl ?? []).filter(q => !q.answer)
-  if (state.status === 'blocked-on-human' && openHitl.length > 0) {
-    log(`resume: ще blocked — ${openHitl.length} відкритих HITL-питань (заповни answer і повтори)`)
-    return 2
-  }
-  if (!state.plan?.length) {
-    log('resume: нема плану')
-    return 1
-  }
-
-  // safe-resume: скинути частковий доробок невдалого кроку до останнього коміту
-  run_('git', ['reset', '--hard', 'HEAD'], { cwd })
-
-  // застосувати HITL-відповіді як hint + дати незавершеним крокам свіжі спроби
-  const answers = new Map((state.hitl ?? []).filter(q => q.answer).map(q => [q.step, q.answer]))
-  updateState(statePath, s => ({
-    ...s,
-    status: 'in_progress',
-    plan: s.plan.map(st =>
-      st.status === 'done'
-        ? st
-        : { ...st, retry_count: 0, ...(answers.has(st.step) ? { hint: answers.get(st.step) } : {}) }
-    ),
-    hitl: (s.hitl ?? []).map(q => (q.answer ? { ...q, status: 'answered' } : q))
-  }))
-
-  let runner
-  try {
-    runner = deps.runner ?? (await createRunner(deps))
-  } catch (error) {
-    log(`resume: ${error.message}`)
-    return 1
-  }
-
-  const result = await executePlan(
-    { statePath, eventsPath: flowEventsPath(cwd) },
-    { runner, verify: deps.verify ?? defaultVerify, commit: deps.commit ?? defaultCommit, cwd, log, now }
-  )
-  if (result.status === 'done') return 0
-  if (result.status === 'blocked-on-human') return 2
-  return 1
-}
-
-/**
- * `flow cancel` — скасування: прибирає transient sibling-и (стан/журнал/lock).
- * @param {string[]} _rest аргументи
- * @param {{ cwd?: string, log?: (m: string) => void }} [deps] ін'єкції
- * @returns {Promise<number>} 0
- */
-export async function cancel(_rest, deps = {}) {
-  const cwd = deps.cwd ?? processCwd()
-  const log = deps.log ?? console.error
-  cleanupFlowSiblings(cwd)
-  log('cancel: стан і sibling-и прибрано')
-  return 0
-}
-
-/**
- * `flow repair [--discard-step-work]` — fail-closed escape: діагностика стану або
- * жорстке скидання робочого дерева до HEAD (свідоме викидання доробку).
- * @param {string[]} rest аргументи
- * @param {{ run?: (cmd: string, args: string[], opts: object) => object, cwd?: string, log?: (m: string) => void }} [deps] ін'єкції
- * @returns {Promise<number>} exit code
- */
-export async function repair(rest, deps = {}) {
-  const cwd = deps.cwd ?? processCwd()
-  const log = deps.log ?? console.error
-  const run_ = deps.run ?? realRun
-
-  if (rest.includes('--discard-step-work')) {
-    run_('git', ['reset', '--hard', 'HEAD'], { cwd })
-    log('repair: робоче дерево скинуто до HEAD (--discard-step-work)')
-    return 0
-  }
-  try {
-    const state = readState(flowStatePath(cwd))
-    log(state ? `repair: стан валідний (status: ${state.status})` : 'repair: стану нема')
-    return 0
-  } catch (error) {
-    log(`repair: стан пошкоджено — ${error.message}. Спробуй \`flow repair --discard-step-work\` або \`flow cancel\`.`)
-    return 1
-  }
-}

package/scripts/dispatcher/lib/artifact.mjs

@@ -1,79 +0,0 @@
-/**
- * Спільні утиліти фаз `spec`/`plan` (Пасивний Турнікет): резолв traceable-
- * артефакту в `docs/<kind>/`, екстракт кроків плану зі секції `## Кроки`, і
- * read-only перевірка цілісності ланцюга через `n-cursor trace` (`trace.mjs`).
- *
- * Лінки front-matter (`spec.plan`/`plan.spec`/`plan.flow`) пише сам агент за
- * контрактом `flow.mdc` — тут лише ВЕРИФІКАЦІЯ (мутатора `trace link` нема).
- */
-import { existsSync, readdirSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { runTraceCli } from '../trace.mjs'
-
-/**
- * Резолвить артефакт у `docs/<kind>/`. Пріоритет: файли, чия назва містить
- * хвіст гілки (slug, напр. `flow-gate` з `claude/flow-gate`); серед них (або
- * серед усіх, якщо збігу нема) — **найсвіжіший за mtime**. Лексикографічний
- * вибір був хибним при кількох артефактах на одну дату (виявлено dogfood'ом).
- * @param {string} cwd корінь worktree
- * @param {'specs' | 'plans'} kind підкаталог `docs`
- * @param {string} [branch] гілка задачі — для пріоритету за slug
- * @returns {string | null} абсолютний шлях або null, якщо каталог/файли відсутні
- */
-export function resolveArtifact(cwd, kind, branch) {
-  const dir = join(cwd, 'docs', kind)
-  if (!existsSync(dir)) return null
-  const md = readdirSync(dir).filter(f => f.endsWith('.md'))
-  if (md.length === 0) return null
-
-  const slug = branch ? branch.split('/').pop() : null
-  const matched = slug ? md.filter(f => f.includes(slug)) : []
-  const pool = matched.length > 0 ? matched : md
-
-  const best = pool
-    .map(f => ({ f, mtime: statSync(join(dir, f)).mtimeMs }))
-    .toSorted((a, b) => a.mtime - b.mtime || (a.f < b.f ? -1 : 1))
-    .at(-1)
-  return join(dir, best.f)
-}
-
-/** Маркер критерію приймання в рядку кроку (порівняння — case-insensitive). */
-const ACCEPTANCE_MARK = '— acceptance:'
-/** Лише цифри — перевірка нумерації кроку (лінійний, без backtracking). */
-const DIGITS_RE = /^\d+$/u
-
-/**
- * Кроки зі секції плану — нумерований список `N. <task> — acceptance: <crit>`.
- * Best-effort парсинг через `indexOf` (без regex-backtracking): рядки поза
- * форматом ігноруються.
- * @param {string} text вміст plan-doc
- * @returns {{ task: string, acceptance?: string }[]} кроки у порядку появи
- */
-export function extractSteps(text) {
-  const steps = []
-  for (const raw of String(text).split('\n')) {
-    const line = raw.trim()
-    const dot = line.indexOf('. ')
-    if (dot <= 0 || !DIGITS_RE.test(line.slice(0, dot))) continue
-    const body = line.slice(dot + 2).trim()
-    const sep = body.toLowerCase().indexOf(ACCEPTANCE_MARK)
-    if (sep === -1) {
-      steps.push({ task: body })
-    } else {
-      steps.push({ task: body.slice(0, sep).trim(), acceptance: body.slice(sep + ACCEPTANCE_MARK.length).trim() })
-    }
-  }
-  return steps
-}
-
-/**
- * Read-only перевірка цілісності ланцюга артефактів (не мутує — лише сигнал).
- * @param {string} cwd корінь worktree
- * @param {(cwd: string) => number} [runTrace] runner trace (0 — цілісно, 1 — розрив); ін'єкція для тестів
- * @returns {boolean} true, якщо ланцюг цілісний
- */
-export function verifyTrace(cwd, runTrace) {
-  const run = runTrace ?? (c => runTraceCli([], { cwd: c, log: () => {} }))
-  return run(cwd) === 0
-}

package/scripts/dispatcher/lib/budget.mjs

@@ -1,36 +0,0 @@
-/**
- * Budget guard для автономного режиму (spec §9.4): обгортає SubagentRunner
- * лічильником викликів і кидає `BudgetExceeded` при перевищенні `maxApiCalls`.
- * Це запобіжник проти неконтрольованих витрат на сервері (де нема людини).
- *
- * (`maxCostUsd` — коли runner повертатиме tokens/cost; наразі рахуємо виклики.)
- */
-
-/** Помилка перевищення бюджету (ловиться в `run`, §9.4). */
-export class BudgetExceeded extends Error {}
-
-/**
- * Обгортає runner лічильником API-викликів.
- * @param {{ backend?: string, runStep: (prompt: string, opts?: object) => object }} runner базовий runner
- * @param {{ maxApiCalls?: number, log?: (m: string) => void }} [opts] ліміт і лог
- * @returns {{ backend: string, runStep: (prompt: string, opts?: object) => Promise<object>, readonly calls: number }} обгорнутий runner
- */
-export function withBudget(runner, opts = {}) {
-  const maxApiCalls = opts.maxApiCalls ?? Number.POSITIVE_INFINITY
-  const log = opts.log ?? (() => {})
-  let calls = 0
-  return {
-    backend: runner.backend,
-    get calls() {
-      return calls
-    },
-    async runStep(prompt, stepOpts) {
-      if (calls >= maxApiCalls) {
-        throw new BudgetExceeded(`budget: вичерпано maxApiCalls=${maxApiCalls}`)
-      }
-      calls += 1
-      log(`budget: API-виклик ${calls}/${maxApiCalls}`)
-      return runner.runStep(prompt, stepOpts)
-    }
-  }
-}

package/scripts/dispatcher/lib/capability.mjs

@@ -1,59 +0,0 @@
-/**
- * Capability Router — резолвер режиму оркестрації (`native` vs `polyfill`)
- * за **явною декларацією моделі** (spec §2.2).
- *
- * Рантайм-детекції моделі в кодобазі немає — тому модель НЕ вгадуємо, а
- * оголошуємо за пріоритетом: CLI `--model` > env `N_CURSOR_FLOW_MODEL` >
- * config `flow.model`. Default-режим (`polyfill`) дозволений ЛИШЕ за наявного
- * `SubagentRunner` (§15.1); інакше — fail (caller кидає помилку), бо polyfill
- * без runner-а не «працює з будь-якою моделлю».
- *
- * Усі функції чисті (без I/O) — джерела (`args`/`env`/`config`/`matrix`/
- * `hasRunner`) передаються ззовні, що робить модуль тривіально тестованим.
- */
-
-export const DEFAULT_ORCHESTRATION = 'polyfill'
-
-/**
- * Витягує значення `--model <value>` з argv. Не мутує вхід.
- * @param {string[]} args аргументи підкоманди flow
- * @returns {string | null} оголошена модель або null
- */
-export function parseModelFlag(args) {
-  const i = args.indexOf('--model')
-  return i !== -1 && i + 1 < args.length ? args[i + 1] : null
-}
-
-/**
- * Оголошена модель за пріоритетом CLI > env > config.
- * @param {{ cliModel?: string | null, envModel?: string | null, configModel?: string | null }} sources джерела декларації
- * @returns {string | null} модель або null, якщо ніде не оголошено
- */
-export function declaredModel({ cliModel = null, envModel = null, configModel = null } = {}) {
-  return cliModel || envModel || configModel || null
-}
-
-/**
- * Режим оркестрації для оголошеної моделі за `capability-matrix`.
- * Невідома/неоголошена модель → `matrix.default` → `DEFAULT_ORCHESTRATION`.
- * @param {string | null} model оголошена модель
- * @param {{ models?: Record<string, { orchestration?: string }>, default?: { orchestration?: string } }} matrix матриця можливостей
- * @returns {'native' | 'polyfill'} режим
- */
-export function orchestrationFor(model, matrix) {
-  const entry = model && matrix && matrix.models ? matrix.models[model] : null
-  return (
-    (entry && entry.orchestration) ||
-    (matrix && matrix.default && matrix.default.orchestration) ||
-    DEFAULT_ORCHESTRATION
-  )
-}
-
-/**
- * Чи стартує polyfill: потрібен доступний `SubagentRunner`.
- * @param {{ hasRunner: boolean }} ctx контекст середовища
- * @returns {boolean} true, якщо runner у наявності
- */
-export function polyfillStartable({ hasRunner }) {
-  return hasRunner === true
-}