@7n/test 0.11.1 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.12.0] - 2026-07-04
+
+### Added
+
+- 🤖 feat(core): спільний prompt-budget (бюджет символів + per-call maxTokens за типом задачі через streamFn-обгортку), батчинг fix-tests під бюджет з анти-starvation, повтор на обрізану генерацію (stopReason length)
+
+### Fixed
+
+- 🤖 fix(core): coverage-скан виключає `**/*.d.ts` — vitest 4 прибрав дефолтний exclude, і v8-remap падав із RolldownError на TS-синтаксисі декларацій у цільових проєктах (CLI-прапорець у coverage-per-file та exclude у shim-конфігу)
+- CLI більше не висить після завершення роботи: явний process.exit у bin (незакриті pi-сесії тримали event loop) і session.dispose() у finally для callText/callAgent
+
+## [0.11.2] - 2026-07-04
+
+### Fixed
+
+- 🤖 fix(core): кап runtime-probe виходів (shape-summary + tmp-cwd) і bounded backoff на omlx memory-guard замість миттєвого падіння
+
 ## [0.11.1] - 2026-07-04
 
 ### Changed

package/bin/7n-test.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
 import { run } from '../src/index.js'
 
-process.exitCode = await run(process.argv.slice(2))
+// Незакриті pi-сесії (createAgentSession) тримають event loop, тож без явного
+// process.exit процес висить після завершення роботи навіть з кодом 0.
+// eslint-disable-next-line n/no-process-exit
+process.exit(await run(process.argv.slice(2)))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/test",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "CLI-утиліта @7n/test",
   "keywords": [
     "7n",

package/src/coverage-per-file.mjs

@@ -112,6 +112,8 @@ export async function measureCoveragePerFile(dir) {
         '--coverage.reporter=lcov',
         // vitest 4 прибрав coverage.all — явний include, щоб файли без тестів лишались у lcov (0%)
         '--coverage.include=**/*.{js,mjs,ts,vue}',
+        // vitest 4 прибрав дефолтний exclude **/*.d.ts — без нього v8-remap падає на TS-синтаксисі декларацій
+        '--coverage.exclude=**/*.d.ts',
         `--coverage.reportsDirectory=${lcovDir}`,
         '--reporter=verbose',
         '--reporter=json',

package/src/docs/coverage-per-file.md

@@ -3,7 +3,7 @@ type: JS Module
 title: coverage-per-file.mjs
 resource: npm/src/coverage-per-file.mjs
 docgen:
-  crc: d167dff5
+  crc: 2b4a460d
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
   issues: judge:inaccurate:0.98

package/src/docs/fix-tests.md

@@ -3,7 +3,7 @@ type: JS Module
 title: fix-tests.mjs
 resource: npm/src/fix-tests.mjs
 docgen:
-  crc: b807d1bc
+  crc: f198a4b3
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
   issues: judge:inaccurate:0.98

package/src/docs/gen-tests.md

@@ -3,7 +3,7 @@ type: JS Module
 title: gen-tests.mjs
 resource: npm/src/gen-tests.mjs
 docgen:
-  crc: 243806c4
+  crc: 531f870e
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
   issues: judge:inaccurate:0.99

package/src/fix-tests.mjs

@@ -20,6 +20,7 @@ import { tmpdir } from 'node:os'
 import { join, relative } from 'node:path'
 import { env } from 'node:process'
 import { callText, MEMORY_ERROR_RE } from './lib/pi-client.mjs'
+import { budgetFor, capText, packBatch } from './lib/prompt-budget.mjs'
 import { findTestRules } from './gen-tests.mjs'
 import { parseFailingTests } from './coverage-per-file.mjs'
 import { resolveVitestRun } from './lib/vitest-shim.mjs'
@@ -108,6 +109,44 @@ function extractCode(text) {
   return text.slice(bodyStart + 1, end).trim()
 }
 
+/**
+ * Читає складники секції одного падаючого файлу для промпту.
+ * @param {{file: string, errors: string[]}} failure падаючий тест-файл
+ * @param {string} [dir] project root
+ * @returns {{file: string, errBlock: string, testCode: string, sourceCode: string|null}} сирі частини секції
+ */
+function readFailureParts({ file, errors }, dir) {
+  const absPath = dir ? join(dir, file) : file
+  const testCode = existsSync(absPath) ? readFileSync(absPath, 'utf8').slice(0, 6000) : '(файл не знайдено)'
+  // Heuristically find source file: strip tests/ prefix from path
+  const sourcePath = inferSourcePath(absPath)
+  const sourceCode =
+    sourcePath && existsSync(sourcePath) ? readFileSync(sourcePath, 'utf8').slice(0, MAX_SRC_BYTES) : null
+  return { file, errBlock: errors.join('\n\n'), testCode, sourceCode }
+}
+
+/**
+ * Складає секцію файлу з готових частин.
+ * @param {{file: string, errBlock: string, testCode: string, sourceCode: string|null}} parts частини з `readFailureParts`
+ * @returns {string} markdown-секція файлу
+ */
+function buildFileSection({ file, errBlock, testCode, sourceCode }) {
+  return [
+    `### \`${file}\``,
+    '',
+    '**Помилки:**',
+    '```',
+    errBlock,
+    '```',
+    '',
+    '**Поточний тест-файл:**',
+    '```js',
+    testCode,
+    '```',
+    ...(sourceCode ? ['', '**Source (для довідки, не міняй):**', '```js', sourceCode, '```'] : [])
+  ].join('\n')
+}
+
 /**
  * Builds a prompt to fix one failing test file.
  * Includes current file content so the LLM doesn't need file-read tools.
@@ -117,34 +156,17 @@ function extractCode(text) {
  */
 export function buildFixTestsPrompt(failures, dir) {
   const testRules = dir ? findTestRules(dir) : null
+  const sections = failures.map(f => buildFileSection(readFailureParts(f, dir)))
+  return buildPromptShell(sections, testRules)
+}
 
-  const sections = failures.map(({ file, errors }) => {
-    const absPath = dir ? join(dir, file) : file
-    const testCode = existsSync(absPath) ? readFileSync(absPath, 'utf8').slice(0, 6000) : '(файл не знайдено)'
-
-    // Heuristically find source file: strip tests/ prefix from path
-    const sourcePath = inferSourcePath(absPath)
-    const sourceCode =
-      sourcePath && existsSync(sourcePath) ? readFileSync(sourcePath, 'utf8').slice(0, MAX_SRC_BYTES) : null
-
-    const errBlock = errors.join('\n\n')
-
-    return [
-      `### \`${file}\``,
-      '',
-      '**Помилки:**',
-      '```',
-      errBlock,
-      '```',
-      '',
-      '**Поточний тест-файл:**',
-      '```js',
-      testCode,
-      '```',
-      ...(sourceCode ? ['', '**Source (для довідки, не міняй):**', '```js', sourceCode, '```'] : [])
-    ].join('\n')
-  })
-
+/**
+ * Обгортає секції файлів спільними правилами й інструкцією формату відповіді.
+ * @param {string[]} sections markdown-секції падаючих файлів
+ * @param {string|null} testRules конвенції тестів проєкту
+ * @returns {string} повний текст промпту
+ */
+function buildPromptShell(sections, testRules) {
   return [
     'Виправ падаючі unit-тести. Поверни ПОВНИЙ вміст КОЖНОГО виправленого тест-файлу.',
     '',
@@ -176,6 +198,54 @@ export function buildFixTestsPrompt(failures, dir) {
   ].join('\n')
 }
 
+/**
+ * Складає промпт під бюджет `budgetFor('fix')`: скільки файлів влазить —
+ * стільки в батч (найменші першими), решта — у `deferred` на наступний
+ * прохід. Файл, що сам-один перевищує бюджет, отримує соло-промпт із
+ * внутрішнім обрізанням (`fitToBudget`: спершу ріжеться source-довідка,
+ * потім vitest-помилки; сам тест-код захищений) — ніколи не скипається.
+ * @param {Array<{file: string, errors: string[]}>} failures падаючі тест-файли
+ * @param {string} [dir] project root
+ * @returns {{prompt: string, included: string[], deferred: string[]}} промпт + розподіл файлів
+ */
+export function buildFixTestsBatch(failures, dir) {
+  const testRules = dir ? findTestRules(dir) : null
+  const shellOverhead = buildPromptShell([], testRules).length
+  const sectionBudget = Math.max(1000, budgetFor('fix').maxPromptChars - shellOverhead)
+
+  const parts = failures.map(f => {
+    const p = readFailureParts(f, dir)
+    return { ...p, section: buildFileSection(p) }
+  })
+  const { included, deferred } = packBatch(
+    parts.map(p => ({ key: p.file, size: p.section.length })),
+    sectionBudget
+  )
+
+  if (included.length === 0) {
+    // Соло-режим: навіть найменший файл не влазить — жорстко обрізаємо
+    // нутрощі секції (source геть, помилки до чверті бюджету, тест-код —
+    // найцінніше — до половини), замість мовчазного skip
+    const smallest = parts.toSorted((a, b) => a.section.length - b.section.length)[0]
+    console.log(`  ⚠ ${smallest.file}: секція завелика (${smallest.section.length} симв.) — соло-виклик з обрізанням`)
+    const section = buildFileSection({
+      file: smallest.file,
+      errBlock: capText(smallest.errBlock, Math.floor(sectionBudget / 4)),
+      testCode: capText(smallest.testCode, Math.floor(sectionBudget / 2)),
+      sourceCode: null
+    })
+    return {
+      prompt: buildPromptShell([section], testRules),
+      included: [smallest.file],
+      deferred: failures.map(f => f.file).filter(f => f !== smallest.file)
+    }
+  }
+
+  const includedSet = new Set(included)
+  const sections = parts.filter(p => includedSet.has(p.file)).map(p => p.section)
+  return { prompt: buildPromptShell(sections, testRules), included, deferred }
+}
+
 /**
  * Parses fenced JavaScript blocks with file markers from LLM response.
  * @param {string} text LLM response text.
@@ -256,7 +326,8 @@ function writeFixedFiles(fixed, remaining, dir) {
  * @returns {Promise<{count: number, fixed: number, remaining: number}>} fix result summary
  */
 export async function fixFailingTests(dir, opts = {}) {
-  const callTextFn = opts.callTextFn ?? (prompt => callText(prompt, { model: MODEL, cwd: dir }))
+  const callTextFn =
+    opts.callTextFn ?? (prompt => callText(prompt, { model: MODEL, cwd: dir, maxTokens: budgetFor('fix').maxTokens }))
   const failures = opts.failures ?? (await getFailingTests(dir))
 
   if (failures.length === 0) return { count: 0, fixed: 0, remaining: 0 }
@@ -268,15 +339,27 @@ export async function fixFailingTests(dir, opts = {}) {
   console.log()
 
   let remaining = failures
-  for (let attempt = 1; attempt <= MAX_FIX_ATTEMPTS && remaining.length > 0; attempt++) {
-    if (attempt > 1) {
-      console.log(`\n🔄 Спроба ${attempt}/${MAX_FIX_ATTEMPTS}: залишилось ${remaining.length} файлів...\n`)
+  const attempts = new Map()
+  let prevDeferred = new Set()
+  for (;;) {
+    // Спроби рахуються per-file (лише коли файл реально був у батчі),
+    // тож deferred-черга не з'їдає ліміт файлів, які ще не пробували
+    const eligible = remaining
+      .filter(f => (attempts.get(f.file) ?? 0) < MAX_FIX_ATTEMPTS)
+      // Анти-starvation: відкладені минулого разу файли йдуть першими
+      .toSorted((a, b) => (prevDeferred.has(b.file) ? 1 : 0) - (prevDeferred.has(a.file) ? 1 : 0))
+    if (eligible.length === 0) break
+
+    const batch = buildFixTestsBatch(eligible, dir)
+    if (batch.deferred.length) {
+      console.log(`  📦 батч: ${batch.included.length} файлів, відкладено на наступний прохід: ${batch.deferred.length}`)
     }
+    for (const file of batch.included) attempts.set(file, (attempts.get(file) ?? 0) + 1)
+    prevDeferred = new Set(batch.deferred)
 
-    const prompt = buildFixTestsPrompt(remaining, dir)
     let response
     try {
-      response = await callTextFn(prompt)
+      response = await callTextFn(batch.prompt)
     } catch (error) {
       // memory-guard: не звичайна per-file помилка — RAM-стеля фіксована, продовжувати
       // до наступного файлу немає сенсу. Пробиваємо нагору до CLI, аби процес завершився.
@@ -292,7 +375,8 @@ export async function fixFailingTests(dir, opts = {}) {
       break
     }
 
-    writeFixedFiles(fixed, remaining, dir)
+    const includedSet = new Set(batch.included)
+    writeFixedFiles(fixed, eligible.filter(f => includedSet.has(f.file)), dir)
 
     remaining = await getFailingTests(dir)
   }

package/src/gen-tests.mjs

@@ -17,6 +17,7 @@ import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node
 import { spawnSync } from 'node:child_process'
 import { join, relative, dirname } from 'node:path'
 import { callText, MEMORY_ERROR_RE } from './lib/pi-client.mjs'
+import { budgetFor } from './lib/prompt-budget.mjs'
 import { resolveVitestRun } from './lib/vitest-shim.mjs'
 import { extractExportsWithComplexity } from './classify-exports.mjs'
 import { analyzeModule } from './lib/ast-analyze.mjs'
@@ -867,7 +868,7 @@ async function generateSharedHeader(ctx, dir, callTextFn) {
   try {
     const headerResp = await callTextFn(
       buildHeaderPrompt({ file, testFilePath, importPath, hasSideEffects, content, exports, testRules, astInfo }),
-      { cwd: dir }
+      { cwd: dir, maxTokens: budgetFor('header').maxTokens }
     )
     const header = extractCode(headerResp)
     if (header) return header
@@ -892,7 +893,7 @@ async function generateLocalBlock(opts) {
   const result = await generateBlockWithLoop(
     blockPrompt,
     callLocalFn,
-    {},
+    { maxTokens: budgetFor('block').maxTokens },
     header,
     dir,
     testDir,
@@ -920,7 +921,7 @@ async function generateCloudBlock(opts) {
   const result = await generateBlockWithLoop(
     blockPrompt,
     callTextFn,
-    { cwd: dir },
+    { cwd: dir, maxTokens: budgetFor('block').maxTokens },
     header,
     dir,
     testDir,
@@ -1109,7 +1110,7 @@ async function generateOneTest(fileInfo, dir, callTextFn) {
   const prompt = buildSingleFilePrompt(fileInfo, dir)
   let response
   try {
-    response = await callTextFn(prompt, { cwd: dir })
+    response = await callTextFn(prompt, { cwd: dir, maxTokens: budgetFor('single-file').maxTokens })
   } catch (error) {
     if (MEMORY_ERROR_RE.test(error.message ?? '')) throw error
     console.error(`  ✗ pi помилка для ${fileInfo.file}: ${error.message}`)
@@ -1181,7 +1182,7 @@ export async function generateTests(files, dir, opts = {}) {
 
   const callTextFn = opts.callText ?? callText
   const localModel = resolveLocalModel(opts)
-  const localFn = localModel ? prompt => callTextFn(prompt, { model: localModel, cwd: dir }) : null
+  const localFn = localModel ? (prompt, opts = {}) => callTextFn(prompt, { ...opts, model: localModel, cwd: dir }) : null
 
   const mode = localFn ? `per-export (local:${localModel} + cloud)` : 'single-file (cloud)'
   console.log(`\n🤖 Генерую тести для ${files.length} файлів [${mode}]...\n`)

package/src/lib/docs/runtime-probe.md

@@ -3,7 +3,7 @@ type: JS Module
 title: runtime-probe.mjs
 resource: npm/src/lib/runtime-probe.mjs
 docgen:
-  crc: 31dd4fd6
+  crc: 6455ded4
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
   issues: judge:inaccurate:0.98

package/src/lib/docs/vitest-shim.md

@@ -3,7 +3,7 @@ type: JS Module
 title: vitest-shim.mjs
 resource: npm/src/lib/vitest-shim.mjs
 docgen:
-  crc: e08618cc
+  crc: 144cb026
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
   issues: judge:inaccurate:0.97
@@ -18,7 +18,7 @@ docgen:
 
 VITEST_BIN — Абсолютний шлях до вбудованого виконуваного файлу Vitest.
 VITEST_SHIM_CONFIG — Абсолютний шлях до тимчасового файлу конфігурації Vitest, що забезпечує роботу збірки без встановлення Vitest у цільовому проекті.
-ensureVitestShim — Гарантує існування файлу конфігурації Vitest, записуючи мінімальний конфіг у тимчасову директорію, ігноруючи шляхи до `node_modules`.
+ensureVitestShim — Гарантує існування файлу конфігурації Vitest, записуючи мінімальний конфіг у тимчасову директорію, ігноруючи шляхи до `node_modules` та декларації типів `**/*.d.ts`.
 
 ## Публічний API
 
@@ -28,4 +28,4 @@ ensureVitestShim — Гарантує існування файлу конфіг
 
 ## Гарантії поведінки
 
-- Свідомо пропускає шляхи: `node_modules`.
+- Свідомо пропускає шляхи: `node_modules` і декларації типів `**/*.d.ts` (vitest 4 прибрав дефолтний exclude — без нього v8-remap падає на TS-синтаксисі декларацій).

package/src/lib/pi-client.mjs

@@ -1,5 +1,5 @@
 /**
- * Programmatic pi client via @earendil-works/pi-coding-agent SDK.
+ * Programmatic pi client via `@earendil-works/pi-coding-agent` SDK.
  * Replaces spawnSync('pi', ...) with direct in-process calls.
  *
  * Two modes:
@@ -9,83 +9,168 @@
  * Both retry transient connection failures (e.g. a shared local model server
  * that's momentarily busy under concurrent load) with exponential backoff
  * instead of failing the caller's file on the first hiccup. A memory-guard
- * rejection (the shared machine can't fit the prompt in RAM) is not
- * retryable — retrying against a fixed RAM ceiling can't succeed, so it
- * prints the request body to stdout and terminates the process instead.
+ * rejection gets its own longer bounded backoff: oMLX (local model server)
+ * одночасно, тож відмова зазвичай відображає залишкову пам'ять попереднього
+ * запиту, яку сервер вивільняє сам за десятки секунд. Лише після
+ * `N_PI_MEMORY_RETRY_ATTEMPTS` невдач тіло запиту друкується в stdout і
+ * помилка прокидається як термінальна (виклики-власники процесу мають дати
+ * їй впасти, не ковтати як звичайну per-file помилку).
  */
 import { createAgentSession, SessionManager, ModelRegistry, AuthStorage } from '@earendil-works/pi-coding-agent'
+import { randomInt } from 'node:crypto'
 import { env } from 'node:process'
 import { setTimeout as sleep } from 'node:timers/promises'
 
 let _registry = null
 /**
- *
+ * Повертає або ініціалізує спільний model registry для поточного процесу.
+ * @returns {object} спільний registry
  */
-async function getRegistry() {
+function getRegistry() {
   if (_registry) return _registry
   _registry = ModelRegistry.create(AuthStorage.create())
   return _registry
 }
 
 const RETRYABLE_ERROR_RE = /connection error|ECONNREFUSED|ETIMEDOUT|fetch failed|network/i
+const OMLX_CODE_RE = /"(?:omlx_)?code"\s*:\s*"([^"]+)"/
+const OMLX_ESTIMATED_BYTES_RE = /"estimated_bytes"\s*:\s*(\d+)/
+const OMLX_LIMIT_BYTES_RE = /"limit_bytes"\s*:\s*(\d+)/
 /** Matches a local model server (e.g. oMLX) rejecting a prompt for lack of RAM. */
 export const MEMORY_ERROR_RE = /memory guard|memory limit|prefill would require/i
 const MAX_ATTEMPTS = Number(env.N_PI_RETRY_ATTEMPTS) || 4
 const BASE_DELAY_MS = Number(env.N_PI_RETRY_DELAY_MS) || 1500
 const MAX_DELAY_MS = 15_000
+/** Скільки разів пробуємо промпт, відкинутий memory guard (включно з першою спробою). */
+const MEMORY_MAX_ATTEMPTS = Number(env.N_PI_MEMORY_RETRY_ATTEMPTS) || 3
+/** Базова затримка перед повтором після memory-guard відмови (експоненційно: 15s → 30s → …). */
+const MEMORY_BASE_DELAY_MS = Number(env.N_PI_MEMORY_RETRY_DELAY_MS) || 15_000
+const MEMORY_MAX_DELAY_MS = 60_000
+
+/**
+ * Витягує структуровані поля oMLX-помилки з тексту повідомлення, якщо тіло
+ * 400 (`omlx_code`/`estimated_bytes`/`limit_bytes`) потрапило в message.
+ * `estimated_bytes`/`limit_bytes` — байти GPU/Metal-пам'яті сервера,
+ * ТІЛЬКИ для діагностики й логів (не «скільки символів промпту зрізати»).
+ * @param {string} message текст помилки від SDK/сервера
+ * @returns {{omlxCode?: string, estimatedBytes?: number, limitBytes?: number} | null} знайдені поля або `null`
+ */
+function parseOmlxErrorDetails(message) {
+  const code = OMLX_CODE_RE.exec(message)?.[1]
+  const estimated = OMLX_ESTIMATED_BYTES_RE.exec(message)?.[1]
+  const limit = OMLX_LIMIT_BYTES_RE.exec(message)?.[1]
+  if (!code && !estimated && !limit) return null
+  const details = {}
+  if (code) details.omlxCode = code
+  if (estimated) details.estimatedBytes = Number(estimated)
+  if (limit) details.limitBytes = Number(limit)
+  return details
+}
+
+/**
+ * Розпізнає memory-guard відмову і збагачує помилку структурованими полями
+ * (`omlxCode`, `estimatedBytes`, `limitBytes`), коли вони доступні в message.
+ * @param {Error} error помилка з виклику моделі
+ * @returns {boolean} `true`, якщо це memory-guard відмова
+ */
+function isMemoryGuardError(error) {
+  const details = parseOmlxErrorDetails(error.message ?? '')
+  if (details) Object.assign(error, details)
+  return error.omlxCode === 'prefill_memory_exceeded' || MEMORY_ERROR_RE.test(error.message ?? '')
+}
 
 /**
- * Prints the request body that triggered a memory-guard rejection to stdout
- * and throws — there's no RAM to retry into. Callers that own the process
- * lifecycle (CLI entrypoints) must let this propagate uncaught instead of
- * swallowing it like a normal per-file error, so the process exits instead
- * of quietly continuing against a RAM ceiling that won't change.
- * @param {Error} error the memory-guard error thrown by the model server
- * @param {string} requestBody prompt sent to the model
- * @returns {never} always throws
+ * Термінальний вихід після вичерпання memory-retry: друкує тіло запиту в
+ * stdout (лише тут — не на проміжних спробах) і кидає помилку далі,
+ * зберігаючи структуровані поля й оригінал у `cause`. Виклики-власники
+ * процесу (CLI) мають дати їй впасти, не ковтати як per-file помилку.
+ * @param {Error} error memory-guard помилка останньої спроби
+ * @param {string} requestBody промпт, надісланий моделі
+ * @returns {never} завжди кидає
  */
 function failOnMemoryGuard(error, requestBody) {
   console.log('--- omlx memory-guard: тіло запиту ---')
   console.log(requestBody)
   console.log(`✗ omlx memory-guard: ${error.message}`)
-  throw new Error(`omlx memory-guard: ${error.message}`)
+  const wrapped = new Error(`omlx memory-guard: ${error.message}`, { cause: error })
+  for (const key of ['omlxCode', 'estimatedBytes', 'limitBytes']) {
+    if (error[key] !== undefined) wrapped[key] = error[key]
+  }
+  throw wrapped
 }
 
 /**
  * Retries `fn` with exponential backoff + jitter when it throws a transient
  * connection-ish error (shared local model server busy/restarting); other
  * errors (auth, malformed request) are re-thrown immediately. A memory-guard
- * rejection throws via `failOnMemoryGuard` instead of retrying — see its docs.
+ * rejection has its own bounded schedule (`MEMORY_MAX_ATTEMPTS` спроб,
+ * затримки від `MEMORY_BASE_DELAY_MS` експоненційно): одно-слотова черга
+ * oMLX вивільняє залишкову пам'ять попереднього запиту сама, тож повтор
+ * того самого промпту після паузи легітимний. Після вичерпання —
+ * `failOnMemoryGuard` (друк тіла + термінальний throw).
  * @template T
  * @param {() => Promise<T>} fn operation to retry
- * @param {string} requestBody prompt sent to the model, printed if a memory-guard error terminates the process
+ * @param {string} requestBody prompt sent to the model, printed if a memory-guard error exhausts its retries
  * @returns {Promise<T>} result of the first successful attempt
  */
 async function withRetry(fn, requestBody) {
-  for (let attempt = 1; ; attempt++) {
+  let memoryAttempts = 0
+  let connAttempts = 0
+  for (;;) {
     try {
       return await fn()
     } catch (error) {
-      if (MEMORY_ERROR_RE.test(error.message ?? '')) failOnMemoryGuard(error, requestBody)
-      if (attempt >= MAX_ATTEMPTS || !RETRYABLE_ERROR_RE.test(error.message ?? '')) throw error
-      const delay = Math.min(BASE_DELAY_MS * 2 ** (attempt - 1), MAX_DELAY_MS)
-      const jitter = delay * (0.5 + Math.random() * 0.5)
+      if (isMemoryGuardError(error)) {
+        memoryAttempts++
+        if (memoryAttempts >= MEMORY_MAX_ATTEMPTS) failOnMemoryGuard(error, requestBody)
+        const delay = Math.min(MEMORY_BASE_DELAY_MS * 2 ** (memoryAttempts - 1), MEMORY_MAX_DELAY_MS)
+        await sleep(delay * (0.5 + randomInt(5000) / 10000))
+        continue
+      }
+      connAttempts++
+      if (connAttempts >= MAX_ATTEMPTS || !RETRYABLE_ERROR_RE.test(error.message ?? '')) throw error
+      const delay = Math.min(BASE_DELAY_MS * 2 ** (connAttempts - 1), MAX_DELAY_MS)
+      const jitter = delay * (0.5 + randomInt(5000) / 10000)
       await sleep(jitter)
     }
   }
 }
 
+/**
+ * Стеля відповіді моделі для подвоєння на `stopReason: 'length'` — межа
+ * `maxTokens` реєстру для локальної моделі (див. `~/.pi/agent/models.json`).
+ */
+const MAX_TOKENS_CEILING = 32_768
+
+/**
+ * Обгортає `session.agent.streamFn`, додаючи per-call `maxTokens` у
+ * options LLM-виклику. SDK не має публічного per-call параметра
+ * (спайк: `session.prompt(text, options)` не прокидає options у loop
+ * config), але `options.maxTokens` у streamFn перекриває дефолт моделі —
+ * перевірено на дроті через myllm-проксі (`max_completion_tokens`
+ * змінюється).
+ * @param {object} session сесія з `createAgentSession`
+ * @param {number} maxTokens стеля відповіді для всіх викликів цієї сесії
+ * @returns {void}
+ */
+function applyMaxTokens(session, maxTokens) {
+  const orig = session.agent.streamFn
+  session.agent.streamFn = (model, context, options) => orig(model, context, { ...options, maxTokens })
+}
+
 /**
  * Sends a single prompt to pi in text mode (no tools) and returns the response.
  * Reads auth/model config from ~/.pi/ same as the CLI.
- * @param {string} prompt
- * @param {object} [opts]
- * @param {string} [opts.cwd]
- * @param {string} [opts.model] provider/model-id passed to pi (e.g. "openai/gpt-4o"); omit for pi default
- * @returns {Promise<string>}
+ * @param {string} prompt текст запиту для моделі
+ * @param {object} [opts] додаткові параметри виклику
+ * @param {string} [opts.cwd] робоча директорія для session
+ * @param {string} [opts.model] provider/model-id для pi (наприклад, "openai/gpt-4o"); без значення — default pi
+ * @param {number} [opts.maxTokens] стеля відповіді для цього виклику (перекриває дефолт моделі);
+ *   на `stopReason: 'length'` (обрізана генерація) виклик повторюється один раз із подвоєною стелею
+ * @returns {Promise<string>} текстова відповідь моделі
  */
 export async function callText(prompt, opts = {}) {
-  return withRetry(async () => {
+  const result = await withRetry(async () => {
     const cwd = opts.cwd ?? process.cwd()
     const sessionOpts = {
       tools: [],
@@ -97,35 +182,51 @@ export async function callText(prompt, opts = {}) {
       const slashIdx = opts.model.indexOf('/')
       const provider = slashIdx === -1 ? null : opts.model.slice(0, slashIdx)
       const modelId = slashIdx === -1 ? opts.model : opts.model.slice(slashIdx + 1)
-      const resolved = provider ? registry.find(provider, modelId) : null
+      const resolved = provider ? Reflect.apply(registry.find, registry, [provider, modelId]) : null
       sessionOpts.modelRegistry = registry
       sessionOpts.model = resolved ?? opts.model
     }
     const { session } = await createAgentSession(sessionOpts)
+    if (opts.maxTokens) applyMaxTokens(session, opts.maxTokens)
+    try {
+      await session.prompt(prompt)
 
-    await session.prompt(prompt)
-
-    const state = session.state
-    const last = state.messages.at(-1)
-    if (!last || last.role !== 'assistant') return ''
-    if (last.stopReason === 'error' || last.stopReason === 'aborted') {
-      throw new Error(`pi error: ${last.errorMessage ?? last.stopReason}`)
+      const state = session.state
+      const last = state.messages.at(-1)
+      if (!last || last.role !== 'assistant') return { text: '', truncated: false }
+      if (last.stopReason === 'error' || last.stopReason === 'aborted') {
+        throw new Error(`pi error: ${last.errorMessage ?? last.stopReason}`)
+      }
+      return {
+        text: last.content
+          .filter(c => c.type === 'text')
+          .map(c => c.text)
+          .join(''),
+        truncated: last.stopReason === 'length'
+      }
+    } finally {
+      session.dispose()
     }
-    return last.content
-      .filter(c => c.type === 'text')
-      .map(c => c.text)
-      .join('')
   }, prompt)
+
+  // Обрізана генерація зі зниженою стелею — не палимо retry-цикли колера
+  // на «invalid block», а один раз повторюємо з подвоєною стелею.
+  if (result.truncated && opts.maxTokens && opts.maxTokens < MAX_TOKENS_CEILING && !opts._lengthRetried) {
+    const doubled = Math.min(opts.maxTokens * 2, MAX_TOKENS_CEILING)
+    console.log(`  ⚠ відповідь обрізана (stopReason: length) — повтор із maxTokens ${opts.maxTokens} → ${doubled}`)
+    return callText(prompt, { ...opts, maxTokens: doubled, _lengthRetried: true })
+  }
+  return result.text
 }
 
 /**
  * Sends a prompt to pi in agent mode with full coding tools (read/write/bash/edit).
  * The agent writes test files directly — no need to parse output.
- * @param {string} prompt
- * @param {string} cwd project root where files should be written
- * @returns {Promise<void>}
+ * @param {string} prompt текст завдання для агента
+ * @param {string} cwd робоча директорія, куди агент може писати файли
+ * @returns {Promise<void>} проміс завершується після виконання агента
  */
-export async function callAgent(prompt, cwd) {
+export function callAgent(prompt, cwd) {
   return withRetry(async () => {
     const { session } = await createAgentSession({
       tools: ['read', 'write', 'edit', 'bash', 'grep', 'find', 'ls'],
@@ -133,6 +234,10 @@ export async function callAgent(prompt, cwd) {
       cwd
     })
 
-    await session.prompt(prompt)
+    try {
+      await session.prompt(prompt)
+    } finally {
+      session.dispose()
+    }
   }, prompt)
 }

package/src/lib/prompt-budget.mjs

@@ -0,0 +1,125 @@
+/**
+ * Спільний бюджет LLM-промптів (фаза 2 спеки
+ * `docs/specs/2026-07-04-omlx-prompt-budget.md`, Д3): єдина точка правди
+ * для ліміту символів промпту та стелі відповіді (`maxTokens`) за типом
+ * задачі. Захищає від класу проблем «безлімітна секція роздула промпт до
+ * memory guard» — кожен колер (gen-tests, fix-tests) бере бюджет звідси
+ * замість власних розрізнених констант.
+ *
+ * Дві незалежні утиліти:
+ * - `fitToBudget` — внутрішньопромптове обрізання: дропає/вкорочує
+ *   низькопріоритетні chunks, поки промпт не влізе в ліміт;
+ * - `packBatch` — батчинг цілих одиниць (файлів): скільки влазить зараз,
+ *   решта — у наступний прохід.
+ */
+
+/** Бюджети за типом задачі: ліміт символів промпту і стеля відповіді. */
+const BUDGETS = {
+  header: { maxPromptChars: 8000, maxTokens: 2048 },
+  block: { maxPromptChars: 40_000, maxTokens: 8192 },
+  'single-file': { maxPromptChars: 60_000, maxTokens: 16_384 },
+  fix: { maxPromptChars: 60_000, maxTokens: 16_384 }
+}
+
+/** Частка голови chunk-а, що лишається при обрізанні (решта — хвіст + маркер). */
+const TRUNCATE_HEAD_RATIO = 0.7
+/** Мінімальний розмір, до якого має сенс обрізати chunk (менше — просто дроп). */
+const MIN_TRUNCATED_CHARS = 400
+
+/**
+ * Повертає бюджет для типу задачі.
+ * @param {'header'|'block'|'single-file'|'fix'} taskKind тип LLM-задачі
+ * @returns {{maxPromptChars: number, maxTokens: number}} копія бюджету
+ */
+export function budgetFor(taskKind) {
+  const budget = BUDGETS[taskKind]
+  if (!budget) throw new Error(`prompt-budget: невідомий taskKind "${taskKind}"`)
+  return { ...budget }
+}
+
+/**
+ * Символьно-безпечне обрізання середини: голова + маркер + хвіст.
+ * @param {string} text вихідний текст
+ * @param {number} maxChars цільовий розмір
+ * @returns {string} обрізаний текст із маркером
+ */
+export function capText(text, maxChars) {
+  return truncateMiddle(text, maxChars)
+}
+
+/**
+ * Внутрішня реалізація `capText` (окреме ім'я — щоб `fitToBudget` не
+ * залежав від публічного контракту).
+ * @param {string} text вихідний текст
+ * @param {number} maxChars цільовий розмір
+ * @returns {string} обрізаний текст із маркером
+ */
+function truncateMiddle(text, maxChars) {
+  const chars = [...text]
+  if (chars.length <= maxChars) return text
+  const head = Math.floor(maxChars * TRUNCATE_HEAD_RATIO)
+  const tail = Math.max(0, maxChars - head)
+  const dropped = chars.length - head - tail
+  return `${chars.slice(0, head).join('')}\n...[обрізано ${dropped} символів]...\n${chars.slice(chars.length - tail).join('')}`
+}
+
+/**
+ * Вкладає chunks у бюджет: спершу обрізає, потім дропає найнижчі
+ * пріоритети, поки сумарний текст не влізе. Chunk із НАЙВИЩИМ
+ * пріоритетом (сама задача / останній user-запит) захищений — його
+ * текст не ріжеться і не дропається ніколи.
+ * @param {Array<{text: string, priority: number, label?: string}>} chunks частини промпту; нижчий priority ріжеться першим
+ * @param {number} maxChars бюджет символів на весь результат
+ * @returns {{text: string, dropped: string[]}} зібраний промпт + мітки скорочених/викинутих частин
+ */
+export function fitToBudget(chunks, maxChars) {
+  const parts = chunks.map((c, i) => ({ ...c, label: c.label ?? `chunk#${i}`, kept: true, out: c.text }))
+  const maxPriority = Math.max(...parts.map(p => p.priority))
+  const total = () => parts.filter(p => p.kept).reduce((sum, p) => sum + p.out.length + 1, 0)
+  const dropped = []
+
+  const candidates = parts.filter(p => p.priority < maxPriority).toSorted((a, b) => a.priority - b.priority)
+  // Прохід 1: обрізати кандидатів (від найнижчого пріоритету)
+  for (const part of candidates) {
+    if (total() <= maxChars) break
+    const overflow = total() - maxChars
+    const target = Math.max(MIN_TRUNCATED_CHARS, part.out.length - overflow)
+    if (part.out.length > target) {
+      part.out = truncateMiddle(part.out, target)
+      dropped.push(`${part.label} (обрізано)`)
+    }
+  }
+  // Прохід 2: дропнути кандидатів цілком, якщо обрізання не вистачило
+  for (const part of candidates) {
+    if (total() <= maxChars) break
+    part.kept = false
+    dropped.push(`${part.label} (видалено)`)
+  }
+
+  return { text: parts.filter(p => p.kept).map(p => p.out).join('\n'), dropped }
+}
+
+/**
+ * Пакує одиниці (файли) у бюджет: найменші першими, щоб максимізувати
+ * кількість виправлень за один виклик. Одиниця, що сама-одна перевищує
+ * бюджет, потрапляє в `deferred` — колер робить для неї соло-виклик із
+ * жорсткішим внутрішнім обрізанням (`fitToBudget`), а не мовчазний skip.
+ * @param {Array<{key: string, size: number}>} items одиниці з розмірами
+ * @param {number} maxChars бюджет символів на батч
+ * @returns {{included: string[], deferred: string[]}} ключі включених і відкладених одиниць
+ */
+export function packBatch(items, maxChars) {
+  const sorted = items.toSorted((a, b) => a.size - b.size)
+  const included = []
+  const deferred = []
+  let used = 0
+  for (const item of sorted) {
+    if (item.size + (included.length === 0 ? 0 : used) <= maxChars) {
+      included.push(item.key)
+      used += item.size
+    } else {
+      deferred.push(item.key)
+    }
+  }
+  return { included, deferred }
+}

package/src/lib/runtime-probe.mjs

@@ -9,10 +9,26 @@
  * 4. probeHelpers — extracts non-exported helper functions from source and calls them
  *    with generic param combos to reveal their actual output shapes.
  */
-import { readFileSync } from 'node:fs'
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
 import { spawnSync } from 'node:child_process'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 
 const PROBE_TIMEOUT_MS = 10_000
+/**
+ * Кап на серіалізований probe-вихід (символів). Довший вихід замінюється
+ * shape-summary — стислим описом форми замість значення: гігантський дамп
+ * (напр. функція, що читає файл проєкту) інакше роздуває LLM-промпт до
+ * сотень тисяч символів і впирається в memory guard моделі, а обрізаний
+ * JSON модель копіює в expected як сміття.
+ */
+const PROBE_OUTPUT_MAX_CHARS = 600
+/** Максимум probe-рядків на один export — багато середніх виходів теж не мають роздувати промпт. */
+const PROBE_MAX_ENTRIES_PER_EXPORT = 12
+/** Глибина рекурсії shape-summary. */
+const SHAPE_MAX_DEPTH = 4
+/** Скільки ключів об'єкта показує shape-summary до «…». */
+const SHAPE_MAX_KEYS = 8
 
 /** Generic argument combos to try when probing async/fetch functions. */
 const FETCH_ARG_COMBOS = [
@@ -70,6 +86,97 @@ const PROBE_INPUTS = [
   ['42', '42']
 ]
 
+/**
+ * Рекурсивно описує форму значення без самих даних.
+ * @param {unknown} value розпарсене JSON-значення
+ * @param {number} [depth] залишкова глибина рекурсії; за замовчуванням `SHAPE_MAX_DEPTH`
+ * @returns {string} стислий опис форми, напр. `Array(34) of {file: string, mutants: Array(12)}`
+ */
+export function describeShape(value, depth = SHAPE_MAX_DEPTH) {
+  if (value === null) return 'null'
+  if (Array.isArray(value)) {
+    if (value.length === 0) return 'Array(0)'
+    if (depth <= 0) return `Array(${value.length})`
+    return `Array(${value.length}) of ${describeShape(value[0], depth - 1)}`
+  }
+  const type = typeof value
+  if (type === 'object') {
+    const keys = Object.keys(value)
+    if (depth <= 0 || keys.length === 0) return 'Object'
+    const shown = keys.slice(0, SHAPE_MAX_KEYS)
+    const inner =
+      depth > 1 ? shown.map(k => `${k}: ${describeShape(value[k], depth - 1)}`).join(', ') : shown.join(', ')
+    return `{${inner}${keys.length > shown.length ? ', …' : ''}}`
+  }
+  if (type === 'string') return 'string'
+  return type
+}
+
+/**
+ * Обмежує серіалізований probe-вихід: до `PROBE_OUTPUT_MAX_CHARS` — без змін,
+ * довший — shape-summary замість значення (модель бачить структуру для
+ * asserts на форму, але не тягне дамп у промпт і не копіює його в expected).
+ * @param {string} serialized JSON-серіалізований вихід probe
+ * @returns {string} оригінал або `[shape-summary, ~N chars] <форма>`
+ */
+export function capProbeOutput(serialized) {
+  if (typeof serialized !== 'string' || serialized.length <= PROBE_OUTPUT_MAX_CHARS) return serialized
+  let shape
+  try {
+    shape = describeShape(JSON.parse(serialized))
+  } catch {
+    shape = 'string'
+  }
+  const summary = `[shape-summary, ~${serialized.length} chars] ${shape}`
+  return summary.length > PROBE_OUTPUT_MAX_CHARS ? `${summary.slice(0, PROBE_OUTPUT_MAX_CHARS - 1)}…` : summary
+}
+
+/**
+ * Застосовує кап виходів і ліміт кількості рядків до результатів `probeModule`.
+ * @param {Record<string, Array<{input: string, output: string}> | {constant: string}>} results сирі результати з дочірнього процесу
+ * @returns {typeof results} результати з capped-виходами
+ */
+function capModuleResults(results) {
+  const capped = {}
+  for (const [name, section] of Object.entries(results)) {
+    if (Array.isArray(section)) {
+      capped[name] = section
+        .slice(0, PROBE_MAX_ENTRIES_PER_EXPORT)
+        .map(entry => ({ ...entry, output: capProbeOutput(entry.output) }))
+    } else if (section && typeof section === 'object' && 'constant' in section) {
+      capped[name] = { constant: capProbeOutput(section.constant) }
+    } else {
+      capped[name] = section
+    }
+  }
+  return capped
+}
+
+/**
+ * Запускає node з probe-скриптом у порожній тимчасовій cwd: відносні
+ * I/O-читання probe-ованих функцій (напр. `readFile('COVERAGE.md')` при
+ * порожньому аргументі шляху) не бачать файлів проєкту — вихід
+ * детермінований між машинами і не може випадково затягнути великий
+ * файл репозиторію у LLM-промпт.
+ * @param {string} script код для виконання
+ * @param {number} [timeout] ліміт очікування в мс; за замовчуванням `PROBE_TIMEOUT_MS`
+ * @returns {import('node:child_process').SpawnSyncReturns<string>} результат spawnSync
+ */
+function spawnProbe(script, timeout = PROBE_TIMEOUT_MS) {
+  const cwd = mkdtempSync(join(tmpdir(), 'n-probe-'))
+  try {
+    return spawnSync('node', ['--input-type=module'], {
+      input: script,
+      encoding: 'utf8',
+      timeout,
+      env: { ...process.env },
+      cwd
+    })
+  } finally {
+    rmSync(cwd, { recursive: true, force: true })
+  }
+}
+
 /**
  * Пробує експорти модуля у дочірньому процесі й повертає фактичні виходи.
  * @param {string} absFilePath абсолютний шлях до джерела модуля
@@ -122,18 +229,13 @@ for (const name of names) {
 process.stdout.write(JSON.stringify(results))
 `
 
-  const proc = spawnSync('node', ['--input-type=module'], {
-    input: script,
-    encoding: 'utf8',
-    timeout: PROBE_TIMEOUT_MS,
-    env: { ...process.env }
-  })
+  const proc = spawnProbe(script)
 
   if (!proc.stdout) return {}
   try {
     const parsed = JSON.parse(proc.stdout)
     if (parsed.__importError) return {}
-    return parsed
+    return capModuleResults(parsed)
   } catch {
     return {}
   }
@@ -150,12 +252,7 @@ process.stdout.write(JSON.stringify(results))
  * @returns {Record<string, unknown> | null} розпарсений JSON або `null` при помилці
  */
 function runProbeScript(script, timeout = PROBE_TIMEOUT_MS) {
-  const proc = spawnSync('node', ['--input-type=module'], {
-    input: script,
-    encoding: 'utf8',
-    timeout,
-    env: { ...process.env }
-  })
+  const proc = spawnProbe(script, timeout)
   if (!proc.stdout) return null
   try {
     const parsed = JSON.parse(proc.stdout)
@@ -211,6 +308,33 @@ process.stdout.write(JSON.stringify(results))
   return runProbeScript(script) ?? {}
 }
 
+/**
+ * Застосовує кап до результатів `probeHelpers`: завеликий `result`
+ * замінюється shape-summary рядком, кількість комбо на helper обмежується.
+ * @param {Record<string, Array<{params: Record<string, unknown>, result: unknown}>>} results сирі результати helper-probe
+ * @returns {typeof results} результати з capped-виходами
+ */
+function capHelperResults(results) {
+  const capped = {}
+  for (const [name, entries] of Object.entries(results)) {
+    if (!Array.isArray(entries)) {
+      capped[name] = entries
+      continue
+    }
+    capped[name] = entries.slice(0, PROBE_MAX_ENTRIES_PER_EXPORT).map(entry => {
+      let serialized
+      try {
+        serialized = JSON.stringify(entry.result)
+      } catch {
+        return entry
+      }
+      if (typeof serialized !== 'string' || serialized.length <= PROBE_OUTPUT_MAX_CHARS) return entry
+      return { ...entry, result: capProbeOutput(serialized) }
+    })
+  }
+  return capped
+}
+
 // ---------------------------------------------------------------------------
 // Probe 3: time-variant detection
 // ---------------------------------------------------------------------------
@@ -386,5 +510,5 @@ for (const name of ${names}) {
 }
 process.stdout.write(JSON.stringify(results))
 `
-  return runProbeScript(script) ?? {}
+  return capHelperResults(runProbeScript(script) ?? {})
 }

package/src/lib/vitest-shim.mjs

@@ -51,7 +51,8 @@ export function ensureVitestShim() {
       `      include: ['**/*.{js,mjs,ts,vue}'],\n` +
       // Exclude test files that use non-vitest runners (bun:test, jest) from
       // the coverage scan so they don't cause import errors or skewed data.
-      `      exclude: ['**/node_modules/**'],\n` +
+      // *.d.ts: vitest 4 прибрав дефолтний exclude — v8-remap падає на TS-синтаксисі декларацій.
+      `      exclude: ['**/node_modules/**', '**/*.d.ts'],\n` +
       `    },\n` +
       `  },\n` +
       `})\n`