@nitra/cursor 3.28.0 → 4.0.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [4.0.0] - 2026-06-07
+
+### Changed
+
+- major version bump to 4.0.0
+- docgen Tier 1: пряму ollama HTTP замінено на pi+resolveModel('min') — universally через каскад
+
+## [3.29.0] - 2026-06-07
+
+### Added
+
+- resolveModel(tier) — прозорий каскадний fallback local→cloud для всіх 3 тирів (min/avg/max)
+
 ## [3.28.0] - 2026-06-06
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitra/cursor",
-  "version": "3.28.0",
+  "version": "4.0.0",
   "description": "CLI для завантаження cursor-правил (префікс n-) у локальний репозиторій",
   "keywords": [
     "cli",
@@ -51,8 +51,6 @@
     "rename-yaml-extensions": "bun ./bin/n-cursor.js rename-yaml-extensions"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.0",
-    "@anthropic-ai/sdk": "^0.100.1",
     "oxc-parser": "^0.128.0",
     "picomatch": "^4.0.4",
     "smol-toml": "^1.6.1",

package/scripts/coverage-classify/index.mjs

@@ -1,26 +1,20 @@
 /**
  * Public API класифікатора: classify(survived, cwd, opts) → verdicts[]
  *
- * Orchestration:
- *   1. Перевірка ANTHROPIC_API_KEY + dynamic import SDK (graceful skip).
- *   2. Для кожного мутанта: cache lookup → класифікація → cache write.
- *   3. На неуспішну класифікацію після retries — conservative fallback worth-testing/confidence=0.
- *
- * Prompt caching: system-prompt передається з cache_control: ephemeral —
- * усі мутанти одного прогону reuse кешований префікс на стороні API.
+ * Routing:
+ *   1. Cache lookup → hit → використати збережений verdict.
+ *   2. Cache miss → Tier 1 (LOCAL_MIN через pi) → parseVerdict.
+ *   3. Tier 1 fail (pi error / bad JSON / Zod) → Tier 2 (CLOUD_MIN через pi).
+ *   4. Tier 2 fail → conservative fallback worth-testing/confidence=0.
  */
+import { spawnSync } from 'node:child_process'
 import { join } from 'node:path'
-import { env } from 'node:process'
-import { setTimeout } from 'node:timers/promises'
 
+import { CLOUD_MIN, resolveModel } from '../../lib/models.mjs'
 import { deriveCacheKey, readCache, writeCache } from './cache.mjs'
 import { buildUserPrompt, SYSTEM_PROMPT } from './prompt.mjs'
 import { parseVerdict } from './verdict-schema.mjs'
 
-const MODEL = 'claude-sonnet-4-6'
-const MAX_RETRIES = 2
-const DEFAULT_RETRY_DELAY_MS = 1000
-
 const FALLBACK_VERDICT = {
   verdict: 'worth-testing',
   confidence: 0,
@@ -28,36 +22,67 @@ const FALLBACK_VERDICT = {
 }
 
 /**
- * Класифікує survived мутантів через Claude API.
- * Без API key / без SDK / при критичних помилках — повертає [] (graceful skip).
- * @param {Array<{file: string, mutants: Array<object>, exampleTest?: object|null, recommendationText?: string|null}>} survived список survived груп (як у COVERAGE.md)
- * @param {string} cwd корінь проєкту
- * @param {{cachePath?: string, client?: object, retryDelayMs?: number}} [opts] ін'єкції для тестів
- * @returns {Promise<Array<{key: string, verdict: object}>>} verdicts
+ * Викликає pi і повертає raw stdout.
+ * @param {string} prompt
+ * @param {string} model  provider/model-id або '' для pi-дефолту
+ * @returns {string}
+ * @throws якщо pi не знайдено або повертає ненульовий exit code
  */
-export async function classify(survived, cwd, opts = {}) {
-  const cachePath = opts.cachePath ?? join(cwd, 'npm/reports/coverage-classify.cache.json')
-  const retryDelayMs = opts.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS
+function callPi(prompt, model) {
+  const modelArgs = model ? ['--model', model] : []
+  const r = spawnSync('pi', ['-p', prompt, ...modelArgs, '--no-session', '--mode', 'text', '--no-tools'], {
+    encoding: 'utf8',
+    timeout: 60_000
+  })
+  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, 200) ?? ''}`)
+  return r.stdout?.trim() ?? ''
+}
 
-  if (!env.ANTHROPIC_API_KEY) {
-    console.warn('⚠ coverage classify: ANTHROPIC_API_KEY not set, classification skipped')
-    return []
-  }
+/**
+ * Два тири: LOCAL_MIN → Tier 2 CLOUD_MIN → FALLBACK_VERDICT.
+ * @param {{file: string, mutants: object[]}} group
+ * @param {object} mutant
+ * @param {string} cwd
+ * @param {(prompt: string, model: string) => string} callPiFn  ін'єкція для тестів
+ * @returns {object} verdict
+ */
+function classifyOne(group, mutant, cwd, callPiFn) {
+  const prompt = `${SYSTEM_PROMPT}\n\n${buildUserPrompt({ ...mutant, file: group.file }, cwd)}`
+  const loc = `${group.file}:${mutant.line}:${mutant.col}`
 
-  let SDK
+  // Tier 1: resolveModel('min') — каскад local→cloud якщо локалі нема
   try {
-    SDK = await import('@anthropic-ai/sdk')
+    const text = callPiFn(prompt, resolveModel('min'))
+    return parseVerdict(text)
   } catch {
-    console.warn('⚠ coverage classify: @anthropic-ai/sdk not installed, classification skipped')
-    return []
+    // Tier 2: CLOUD_MIN
+    try {
+      const text = callPiFn(prompt, CLOUD_MIN)
+      return parseVerdict(text)
+    } catch (e) {
+      console.warn(`⚠ coverage classify: ${loc} both tiers failed: ${e.message}`)
+      return { ...FALLBACK_VERDICT }
+    }
   }
-  const Anthropic = SDK.default
-  const client = opts.client ?? new Anthropic()
+}
+
+/**
+ * Класифікує survived мутантів через pi (LOCAL_MIN → CLOUD_MIN → fallback).
+ * @param {Array<{file: string, mutants: object[], exampleTest?: object|null, recommendationText?: string|null}>} survived
+ * @param {string} cwd корінь проєкту
+ * @param {{cachePath?: string, callPi?: Function}} [opts] ін'єкції для тестів
+ * @returns {Promise<Array<{key: string, verdict: object}>>} verdicts
+ */
+export async function classify(survived, cwd, opts = {}) {
+  const cachePath = opts.cachePath ?? join(cwd, 'npm/reports/coverage-classify.cache.json')
+  const callPiFn = opts.callPi ?? callPi
+  const cacheModel = `${resolveModel('min') || 'default'}+${CLOUD_MIN || 'cloud'}`
 
   const cache = readCache(cachePath)
-  if (cache.model !== MODEL) {
+  if (cache.model !== cacheModel) {
     cache.entries = {}
-    cache.model = MODEL
+    cache.model = cacheModel
   }
 
   const verdicts = []
@@ -77,7 +102,7 @@ export async function classify(survived, cwd, opts = {}) {
         }
       }
       if (!verdict) {
-        verdict = await classifyOne(client, group, mutant, cwd, retryDelayMs)
+        verdict = classifyOne(group, mutant, cwd, callPiFn)
         if (cacheKey) {
           cache.entries[cacheKey] = { ...verdict, classifiedAt: new Date().toISOString() }
         }
@@ -90,40 +115,3 @@ export async function classify(survived, cwd, opts = {}) {
   writeCache(cachePath, cache)
   return verdicts
 }
-
-/**
- * Один виклик API з retry. На фейл після MAX_RETRIES — повертає FALLBACK_VERDICT.
- * @param {{messages: {create: Function}}} client SDK client
- * @param {{file: string}} group group для контексту
- * @param {object} mutant mutant data
- * @param {string} cwd корінь
- * @param {number} retryDelayMs base delay для exp-backoff (0 у тестах)
- * @returns {Promise<object>} verdict (parsed або fallback)
- */
-async function classifyOne(client, group, mutant, cwd, retryDelayMs) {
-  const userPrompt = buildUserPrompt({ ...mutant, file: group.file }, cwd)
-  let lastError = null
-
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    try {
-      const response = await client.messages.create({
-        model: MODEL,
-        max_tokens: 1024,
-        system: [{ type: 'text', text: SYSTEM_PROMPT, cache_control: { type: 'ephemeral' } }],
-        messages: [{ role: 'user', content: userPrompt }]
-      })
-      const text = response?.content?.[0]?.text ?? ''
-      return parseVerdict(text)
-    } catch (error) {
-      lastError = error
-      if (attempt < MAX_RETRIES && retryDelayMs > 0) {
-        await setTimeout(retryDelayMs * 2 ** attempt)
-      }
-    }
-  }
-
-  console.warn(
-    `⚠ coverage classify: ${group.file}:${mutant.line}:${mutant.col} failed after ${MAX_RETRIES + 1} attempts: ${lastError?.message ?? 'unknown'}`
-  )
-  return { ...FALLBACK_VERDICT }
-}

package/scripts/coverage-fix.mjs

@@ -1,13 +1,18 @@
 /**
- * `n-cursor coverage --fix`: запускає Claude Code агента для написання тестів
+ * `n-cursor coverage --fix`: запускає pi-агента для написання тестів
  * по вцілілих мутантах Stryker. Агент отримує список мутантів з контекстом
  * (file, line, оригінальний код, вцілілий варіант, тип мутації) і самостійно
  * знаходить або створює відповідні test-файли.
  *
- * Залежить від `@anthropic-ai/claude-agent-sdk` (dependencies у npm/package.json).
+ * Модель: CLOUD_MAX (складна агентна задача) або N_CURSOR_COVERAGE_FIX_MODEL.
  */
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+import { resolveModel } from '../lib/models.mjs'
+
+const MODEL = process.env.N_CURSOR_COVERAGE_FIX_MODEL ?? resolveModel('max')
 
 /**
  * @typedef {{line:number, col:number, mutantType:string, original:string, replacement:string}} MutantDetail
@@ -15,12 +20,13 @@ import { join } from 'node:path'
  */
 
 /**
- * Запускає Claude Code агента для написання тестів по вцілілих мутантах.
+ * Запускає pi-агента для написання тестів по вцілілих мутантах.
  * @param {SurvivedFileGroup[]} survived вцілілі мутанти, згруповані по файлах
  * @param {string} projectRoot абсолютний шлях до кореня проєкту
+ * @param {{ callPi?: (prompt: string, model: string, opts: { cwd: string }) => void }} [opts] ін'єкції для тестів
  * @returns {Promise<void>}
  */
-export async function fixSurvivedMutants(survived, projectRoot) {
+export async function fixSurvivedMutants(survived, projectRoot, opts = {}) {
   const totalMutants = survived.reduce((s, g) => s + g.mutants.length, 0)
   if (totalMutants === 0) {
     console.log('✓ Всі мутанти вбиті — доповнення тестів не потрібне')
@@ -30,26 +36,23 @@ export async function fixSurvivedMutants(survived, projectRoot) {
   const prompt = await buildFixPrompt(survived, projectRoot)
   console.log(`\n🤖 coverage --fix: запускаю агента для ${totalMutants} вцілілих мутантів...\n`)
 
-  // Dynamic import: @anthropic-ai/claude-agent-sdk завантажується лише при --fix,
-  // щоб не гальмувати звичайний coverage-прогін за відсутності пакету.
-  const { query } = await import('@anthropic-ai/claude-agent-sdk')
+  const callPiFn = opts.callPi ?? callPi
+  callPiFn(prompt, MODEL, { cwd: projectRoot })
+}
 
-  for await (const msg of query({
-    prompt,
-    options: {
-      cwd: projectRoot,
-      maxTurns: 20,
-      allowedTools: ['Read', 'Edit', 'Bash'],
-      // Без permissionMode headless-агент SDK не отримує дозволу на запис/Bash —
-      // він крутиться, палить токени, але НЕ редагує файли (підтверджено пробом).
-      // `bypassPermissions` потрібен, бо агент і пише тести (Edit), і ганяє `bun test` (Bash);
-      // `acceptEdits` авто-підтверджує лише edits, а Bash лишився б заблокованим.
-      permissionMode: 'bypassPermissions'
-    }
-  })) {
-    if (msg.type === 'text') process.stdout.write(msg.text)
-  }
-  process.stdout.write('\n')
+/**
+ * Викликає pi в агентному режимі з live-output до stdout.
+ * @param {string} prompt
+ * @param {string} model  provider/model-id або '' для pi-дефолту
+ * @param {{ cwd?: string }} [piOpts]
+ */
+function callPi(prompt, model, { cwd } = {}) {
+  const modelArgs = model ? ['--model', model] : []
+  spawnSync('pi', ['-p', prompt, ...modelArgs, '--no-session'], {
+    cwd,
+    stdio: 'inherit',
+    timeout: 900_000
+  })
 }
 
 /**

package/scripts/dispatcher/index.mjs

@@ -1,86 +1,45 @@
 /**
- * CLI-диспетчер `n-cursor flow` (spec §8 Dual-Mode Dispatcher).
+ * CLI-диспетчер `n-cursor flow` (думка.MD — протокол всередині вузла графу).
  *
- * Два фасади навколо єдиного джерела істини `.flow.json`:
- *  - **Пасивний Турнікет** (Фасад A): `init`, `verify`, `release` — для IDE-
- *    агентів (Cursor/Claude Code), що самі пишуть код; `n-cursor` лише судить.
- *  - **Активний Раннер** (Фасад B): `run`, `resume`, `cancel`, `repair` —
- *    повний 5-фазний polyfill-цикл для headless/CI.
+ * flow plan    — Stage 1: читає task.md, створює plan_NNN.md, виводить контекст
+ * flow verify  — Stage 2: структурний check + ## Done when + outputs на stdout
+ * flow done    — CWD → node path → `graph done <path>`
+ * flow audit   — CWD → node path → pending-audit_NNN.md → `graph audit <path>`
+ * flow failed  — CWD → node path → `graph failed <path>`
+ * flow spawn   — CWD → node path → `graph spawn <path>`
  */
-import { cancel, repair, resume, run } from './lib/active.mjs'
-import { init, release, verify } from './lib/commands.mjs'
-import { gate } from './lib/gate.mjs'
-import { plan } from './lib/plan.mjs'
-import { review } from './lib/review.mjs'
-import { spec } from './lib/spec.mjs'
+import { plan } from './lib/flow-plan.mjs'
+import { verify } from './lib/flow-verify.mjs'
+import { audit, done, failed, spawn } from './lib/flow-signals.mjs'
 
 const USAGE = [
   'Usage:',
-  '  npx @nitra/cursor flow init "<опис>"      # Фасад A: worktree + .flow.json (+ level)',
-  '  npx @nitra/cursor flow spec [--panel]     # Фасад A: фаза дизайну → docs/specs/<…>',
-  '  npx @nitra/cursor flow plan [--panel]     # Фасад A: фаза плану → docs/plans/<…> + state',
-  '  npx @nitra/cursor flow verify             # Фасад A: Quality Gates (pass/fail)',
-  '  npx @nitra/cursor flow review             # Фасад A: adversarial diff-review (за level)',
-  '  npx @nitra/cursor flow gate               # Фасад A: вердикт PASS/CONCERNS/FAIL (verify+review)',
-  '  npx @nitra/cursor flow release            # Фасад A: .changes + completion snapshot',
-  '  npx @nitra/cursor flow run "<опис>"       # Фасад B: повний 5-фазний цикл',
-  '  npx @nitra/cursor flow resume             # продовжити з чекпойнта',
-  '  npx @nitra/cursor flow cancel             # скасувати, прибрати стан',
-  '  npx @nitra/cursor flow repair [--discard-step-work]   # відновлення пошкодженого стану'
+  '  npx @nitra/cursor flow plan     # Stage 1: читає task.md, створює plan_NNN.md',
+  '  npx @nitra/cursor flow verify   # Stage 2: структурна перевірка + stdout-контекст для агента',
+  '  npx @nitra/cursor flow done     # успіх → graph done <node-path>',
+  '  npx @nitra/cursor flow audit    # аудит → pending-audit_NNN.md → graph audit <node-path>',
+  '  npx @nitra/cursor flow failed   # провал → graph failed <node-path>',
+  '  npx @nitra/cursor flow spawn    # розклад → graph spawn <node-path>'
 ].join('\n')
 
 /**
- * Усі handler-и реальні (Ф1 Spec/Plan + Ф2 Турнікет + Ф4 Активний Раннер).
  * @type {Record<string, (rest: string[], deps: object) => Promise<number>>}
  */
-export const DEFAULT_HANDLERS = { init, spec, plan, verify, review, gate, release, run, resume, cancel, repair }
-
-/**
- * Витягує опційний `--branch <гілка>` з аргументів (для cwd-незалежного резолву
- * стану — беклог #1). Повертає очищені аргументи й значення гілки.
- * @param {string[]} args аргументи після підкоманди
- * @returns {{ rest: string[], branch: string | undefined }} очищені аргументи + гілка
- */
-export function extractBranchFlag(args) {
-  const rest = []
-  let branch
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--branch') {
-      const val = args[i + 1]
-      // Поглинаємо наступний аргумент як значення лише якщо це справді значення,
-      // а не інший прапорець / кінець аргументів (інакше `--branch` був би no-op,
-      // що тихо ковтав би сусідній прапорець).
-      if (val !== undefined && !val.startsWith('-')) {
-        branch = val
-        i++
-      }
-      continue
-    }
-    const inline = args[i].startsWith('--branch=') ? args[i].slice('--branch='.length) : null
-    if (inline !== null) {
-      if (inline !== '') branch = inline
-      continue
-    }
-    rest.push(args[i])
-  }
-  return { rest, branch }
-}
+export const DEFAULT_HANDLERS = { plan, verify, done, audit, failed, spawn }
 
 /**
  * Точка входу `case 'flow'` у `bin/n-cursor.js`. Парсить підкоманду й
  * маршрутизує до handler-а. Невідома/відсутня підкоманда → usage + код 1.
- * Опційний `--branch <гілка>` прокидається в `deps.branch` (резолв стану поза worktree).
  * @param {string[]} args аргументи після `flow`
- * @param {{ handlers?: Record<string, (rest: string[], deps: object) => Promise<number>>, branch?: string }} [deps] ін'єкція handler-ів (для тестів)
+ * @param {{ handlers?: Record<string, (rest: string[], deps: object) => Promise<number>> }} [deps] ін'єкція handler-ів (для тестів)
  * @returns {Promise<number>} exit code
  */
 export async function runFlowCli(args, deps = {}) {
-  const [sub, ...raw] = args
+  const [sub, ...rest] = args
   const handlers = deps.handlers ?? DEFAULT_HANDLERS
   if (!sub || !Object.hasOwn(handlers, sub)) {
     console.error(USAGE)
     return 1
   }
-  const { rest, branch } = extractBranchFlag(raw)
-  return await handlers[sub](rest, { ...deps, branch: deps.branch ?? branch })
+  return await handlers[sub](rest, deps)
 }

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

@@ -0,0 +1,153 @@
+/**
+ * Handler `flow plan` — Stage 1 (думка.MD § "flow plan").
+ *
+ * Читає `task.md` у поточному вузлі, розбирає `mode` і `hint` з front-matter,
+ * знаходить наступний номер `plan_NNN.md`, пише шаблон і виводить контекст для
+ * агента (task + mode + hint) на stdout.
+ *
+ * FS та path-резолвінг ін'єктуються — тестується без реального диска.
+ */
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { cwd as processCwd } from 'node:process'
+
+const FRONT_MATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/
+
+/**
+ * Парсить YAML front-matter (мінімально: лише прості `key: value` рядки).
+ * @param {string} text вміст файлу
+ * @returns {Record<string, string>} ключ-значення з front-matter (рядки)
+ */
+function parseFrontMatter(text) {
+  const m = text.match(FRONT_MATTER_RE)
+  if (!m) return {}
+  const result = {}
+  for (const line of m[1].split(/\r?\n/)) {
+    const idx = line.indexOf(':')
+    if (idx === -1) continue
+    const key = line.slice(0, idx).trim()
+    const val = line.slice(idx + 1).trim()
+    if (key) result[key] = val
+  }
+  return result
+}
+
+/**
+ * Знаходить наступний номер `plan_NNN.md` у директорії вузла.
+ * @param {string} dir абсолютний шлях до директорії вузла
+ * @param {(dir: string) => string[]} readdir інжектована readdir
+ * @returns {string} рядок типу `001`, `002`, …
+ */
+function nextPlanNumber(dir, readdir) {
+  const files = readdir(dir)
+  let max = 0
+  for (const f of files) {
+    const m = f.match(/^plan_(\d+)\.md$/)
+    if (m) {
+      const n = parseInt(m[1], 10)
+      if (n > max) max = n
+    }
+  }
+  return String(max + 1).padStart(3, '0')
+}
+
+/**
+ * Будує вміст шаблону `plan_NNN.md`.
+ * @param {{ mode: string, hint: string, now: string }} params параметри
+ * @returns {string} вміст файлу
+ */
+export function buildPlanTemplate({ mode, hint, now }) {
+  return [
+    '---',
+    `created_at: ${now}`,
+    `mode: ${mode}`,
+    `decision: ${hint || 'atomic | composite'}`,
+    '---',
+    '',
+    '## Context',
+    "<!-- Чому саме такий підхід — що агент/людина з'ясували -->",
+    '',
+    '## Approach',
+    '<!-- atomic: покроковий план виконання -->',
+    '<!-- composite: список дочірніх вузлів з описами -->',
+    '',
+    '## Risks',
+    '<!-- Що може піти не так -->',
+    ''
+  ].join('\n')
+}
+
+/**
+ * `flow plan` handler.
+ *
+ * @param {string[]} _rest аргументи після `plan` (не використовуються)
+ * @param {{
+ *   cwd?: string,
+ *   log?: (m: string) => void,
+ *   readFile?: (path: string, enc: string) => string,
+ *   writeFile?: (path: string, content: string, enc: string) => void,
+ *   readdir?: (dir: string) => string[],
+ *   exists?: (path: string) => boolean,
+ *   now?: () => string
+ * }} [deps] ін'єкції
+ * @returns {Promise<number>} exit code
+ */
+export async function plan(_rest, deps = {}) {
+  const cwd = deps.cwd ?? processCwd()
+  const log = deps.log ?? console.error
+  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 nowFn = deps.now ?? (() => new Date().toISOString())
+
+  const taskPath = join(cwd, 'task.md')
+  if (!exists(taskPath)) {
+    log('flow plan: task.md не знайдено в CWD')
+    return 1
+  }
+
+  let taskContent
+  try {
+    taskContent = readFile(taskPath, 'utf8')
+  } catch (err) {
+    log(`flow plan: не вдалося прочитати task.md — ${err instanceof Error ? err.message : String(err)}`)
+    return 1
+  }
+
+  const fm = parseFrontMatter(taskContent)
+  const mode = fm.mode || 'human'
+  const hint = fm.hint || ''
+
+  const num = nextPlanNumber(cwd, readdir)
+  const planPath = join(cwd, `plan_${num}.md`)
+
+  const content = buildPlanTemplate({ mode, hint, now: nowFn() })
+  try {
+    writeFile(planPath, content, 'utf8')
+  } catch (err) {
+    log(`flow plan: не вдалося записати ${planPath} — ${err instanceof Error ? err.message : String(err)}`)
+    return 1
+  }
+
+  log(`flow plan: створено ${planPath}`)
+
+  // Виводимо контекст для агента на stdout
+  const outLines = [
+    `## flow plan context`,
+    ``,
+    `mode: ${mode}`,
+    hint ? `hint: ${hint}` : `hint: (не задано — агент вирішує сам)`,
+    `plan: plan_${num}.md`,
+    ``
+  ]
+  // Додаємо вміст task.md для контексту (без front-matter)
+  outLines.push(`### task.md`)
+  const bodyStart = taskContent.indexOf('\n---\n', 4)
+  const taskBody = bodyStart !== -1 ? taskContent.slice(bodyStart + 5).trimStart() : taskContent
+  outLines.push(taskBody.trimEnd())
+
+  console.log(outLines.join('\n'))
+
+  return 0
+}