@7n/rules 1.34.1 → 1.35.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [1.35.0] - 2026-07-20
+
+### Added
+
+- tauri: додано концерн gitignore_target — перевірка й автофікс ignore-запису ws/src-tauri/target/ у корінному .gitignore (typo-інцидент nitra/task)
+
+### Fixed
+
+- run-v8r: не рахувати ajv schema-compile-помилку (несправна зовнішня схема, напр. unicodeRegExp-несумісність у офіційній azure-pipelines-vscode/service-schema.json) як порушення файлу — друкує ⚠-попередження й пропускає, замість постійного false-positive ✖
+- acp-runner (skill claude): watchdog дочірнього ACP-процесу — fail-fast, якщо агент не запустився чи вийшов до кінця ходу, замість вічного зависання connection.prompt
+
 ## [1.34.1] - 2026-07-20
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/rules",
-  "version": "1.34.1",
+  "version": "1.35.0",
   "description": "CLI еталонних правил і skills (префікс n-): синк у репозиторій, дельта-lint, конформність",
   "keywords": [
     "cli",

package/rules/tauri/gitignore_target/concern.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "fixability": "config",
+  "lint": {
+    "scope": "full",
+    "glob": [".gitignore", "**/src-tauri/Cargo.toml"]
+  }
+}

package/rules/tauri/gitignore_target/docs/fix-gitignore_target.md

@@ -0,0 +1,31 @@
+---
+type: JS Module
+title: fix-gitignore_target.mjs
+resource: npm/rules/tauri/gitignore_target/fix-gitignore_target.mjs
+docgen:
+  crc: 0ceef709
+  model: openai-codex/gpt-5.4-mini
+  score: 100
+  issues: judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+T0-autofix для `tauri/gitignore_target`: дописує в корінний `.gitignore` відсутні ignore-записи `<ws>/src-tauri/target/` у секцію з міткою `# Tauri — Rust build artifacts (tauri.mdc)` (константа `GITIGNORE_TARGET_HEADER`). `insertMissingTargetEntries` виконує сам текстовий splice; `patterns` — масив T0-визначень (`id`/`test`/`apply`) центрального fix-pipeline, що зчитує відсутні записи з `violation.data.missing` і застосовує `insertMissingTargetEntries` до файлів через `applyToFiles`.
+
+## Поведінка
+
+- `GITIGNORE_TARGET_HEADER` — мітка секції в корінному `.gitignore`, куди групуються записи для Tauri build artifacts.
+- `insertMissingTargetEntries` — дописує відсутні ignore-записи для `<ws>/src-tauri/target/` у `.gitignore`: або в наявну секцію з `GITIGNORE_TARGET_HEADER` (поруч з іншими entries), або в новий блок у кінець файла; якщо нічого додавати не треба (`missingEntries` порожній), повертає `null` і вміст не змінюється.
+- `patterns` — один T0-патерн (`tauri-gitignore-target-insert`): спрацьовує на violations з `data.kind === MISSING_GITIGNORE_TARGET_ENTRIES` і застосовує `insertMissingTargetEntries` до кожного цільового `.gitignore`.
+
+## Публічний API
+
+- GITIGNORE_TARGET_HEADER — заголовок секції в корінному `.gitignore` для Tauri build-артефактів.
+- insertMissingTargetEntries — додає відсутні `"<ws>/src-tauri/target/"` у відповідну секцію `.gitignore` або створює новий блок наприкінці файла.
+- patterns — T0-визначення autofix-у для detector-а `tauri/gitignore_target`, що підключається до центрального fix-pipeline.
+
+## Гарантії поведінки
+
+- (специфічних машинно-виведених гарантій немає)

package/rules/tauri/gitignore_target/docs/index.md

@@ -0,0 +1,10 @@
+---
+type: Directory Index
+title: npm/rules/tauri/gitignore_target
+resource: npm/rules/tauri/gitignore_target/
+---
+
+| Файл                                                | Тип       |
+| --------------------------------------------------- | --------- |
+| [fix-gitignore_target.mjs](fix-gitignore_target.md) | JS Module |
+| [main.mjs](main.md)                                 | JS Module |

package/rules/tauri/gitignore_target/docs/main.md

@@ -0,0 +1,37 @@
+---
+type: JS Module
+title: main.mjs
+resource: npm/rules/tauri/gitignore_target/main.mjs
+docgen:
+  crc: 83aa81ee
+  model: openai-codex/gpt-5.5
+  tier: cloud-avg
+  score: 85
+  issues: internal-name:findSrcTauriDirs,anchor-miss:(tauri.mdc),judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Файл read-only обходить усі `<ws>/src-tauri/` у монорепо спільним механізмом із `tauri/cargo_mutants_config` (`findSrcTauriDirs`), без дублювання обходу. Для кожного знайденого workspace корінний `ROOT_GITIGNORE = ".gitignore"` повинен містити точний запис `<ws>/src-tauri/target/`, звірений по точному рядку — typo на кшталт `owner/target/` (реальний інцидент у `nitra/task`) не рахується присутністю потрібного запису.
+
+## Поведінка
+
+- `MISSING_GITIGNORE_TARGET_ENTRIES` — reason `"missing-gitignore-target-entries"` для порушення, коли в корінному `.gitignore` бракує записів для Tauri build-артефактів.
+- `ROOT_GITIGNORE` — назва корінного файлу `".gitignore"`, у якому мають бути всі очікувані ignore-записи.
+- `expectedTargetEntry` — формує точний ignore-запис для `target/` конкретного `src-tauri/` відносно кореня монорепо.
+- `findMissingEntries` — визначає, яких очікуваних ignore-записів немає у `.gitignore`, за точним збігом рядка (після trim).
+- `lint` — read-only перевіряє всі знайдені `src-tauri/` у монорепо й повідомляє про відсутні ignore-записи одним violation на весь `.gitignore`.
+
+## Публічний API
+
+- MISSING_GITIGNORE_TARGET_ENTRIES — reason `missing-gitignore-target-entries` для випадків, коли в кореневому `.gitignore` немає записів для `src-tauri/target/`.
+- ROOT_GITIGNORE — файл `.gitignore` у корені монорепо, який є єдиним місцем для цих ignore-записів.
+- expectedTargetEntry — формує потрібний запис для ігнорування build-артефактів окремого workspace з `src-tauri/`.
+- findMissingEntries — визначає, яких очікуваних записів бракує в кореневому `.gitignore`; збіг рахується лише для точного рядка після trim, тому `target/` або `owner/target/` не замінюють потрібний запис.
+- lint — повідомляє про workspace з Tauri, для яких у кореневому `.gitignore` бракує `src-tauri/target/`.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).
+- Свідомо пропускає шляхи: `.git`.

package/rules/tauri/gitignore_target/fix-gitignore_target.mjs

@@ -0,0 +1,78 @@
+/** @see ./docs/fix-gitignore_target.md */
+
+/**
+ * T0-autofix для `tauri/gitignore_target` — детерміновано дописує в корінний
+ * `.gitignore` відсутні ignore-записи `<ws>/src-tauri/target/` (з violation.data.missing,
+ * а не з повторного сканування монорепо — детектор уже визначив, яких саме
+ * записів бракує). Текстовий splice (як `tauri/linux_deps`): зберігає коментарі
+ * й формат, мінімальний diff. Ідемпотентно: повторний прогін на вже
+ * виправленому файлі нічого не змінює (`findMissingEntries` у main.mjs
+ * повторно перевіряє стан файла).
+ */
+import { applyToFiles } from '../../../scripts/utils/apply-to-files.mjs'
+
+import { MISSING_GITIGNORE_TARGET_ENTRIES } from './main.mjs'
+
+/** Заголовок-коментар секції Tauri build-артефактів у корінному `.gitignore`. */
+export const GITIGNORE_TARGET_HEADER = '# Tauri — Rust build artifacts (tauri.mdc)'
+
+/**
+ * Знаходить кінець контурного блоку entries, що йде одразу за заголовком
+ * (перший порожній рядок, наступний коментар або кінець файла).
+ * @param {string[]} lines рядки `.gitignore`
+ * @param {number} headerIdx індекс рядка заголовка
+ * @returns {number} індекс, куди вставляти нові entries
+ */
+function findBlockEnd(lines, headerIdx) {
+  let i = headerIdx + 1
+  while (i < lines.length && lines[i].trim() !== '' && !lines[i].trim().startsWith('#')) i++
+  return i
+}
+
+/**
+ * Дописує відсутні `<ws>/src-tauri/target/` entries: якщо секція `GITIGNORE_TARGET_HEADER`
+ * вже є — вставляє в кінець її блоку (поруч з наявними entries); інакше додає
+ * новий блок (заголовок + entries) у кінець файла.
+ * @param {string} content вміст `.gitignore`
+ * @param {string[]} missingEntries відсутні ignore-рядки (`<ws>/src-tauri/target/`)
+ * @returns {string|null} новий вміст або null, якщо нічого не змінилось
+ */
+export function insertMissingTargetEntries(content, missingEntries) {
+  if (missingEntries.length === 0) return null
+
+  const lines = content.split('\n')
+  const headerIdx = lines.findIndex(l => l.trim() === GITIGNORE_TARGET_HEADER)
+
+  if (headerIdx !== -1) {
+    const blockEnd = findBlockEnd(lines, headerIdx)
+    lines.splice(blockEnd, 0, ...missingEntries)
+    return lines.join('\n')
+  }
+
+  const trailingBlank = lines.length > 0 && lines.at(-1) === ''
+  const body = trailingBlank ? lines.slice(0, -1) : lines
+  const needsBlankSep = body.length > 0 && body.at(-1).trim() !== ''
+
+  const next = [...body]
+  if (needsBlankSep) next.push('')
+  next.push(GITIGNORE_TARGET_HEADER, ...missingEntries, '')
+  return next.join('\n')
+}
+
+/** @type {import('../../../scripts/lib/lint-surface/types.mjs').T0Pattern[]} */
+export const patterns = [
+  {
+    id: 'tauri-gitignore-target-insert',
+    test: violations => violations.some(v => v.data?.kind === MISSING_GITIGNORE_TARGET_ENTRIES && v.file),
+    apply: (violations, ctx) => {
+      const targets = violations.filter(v => v.data?.kind === MISSING_GITIGNORE_TARGET_ENTRIES && v.file)
+      const touchedFiles = applyToFiles(targets, ctx, rel => content => {
+        const v = targets.find(x => x.file === rel)
+        return insertMissingTargetEntries(content, v?.data?.missing ?? [])
+      })
+      return touchedFiles.length > 0
+        ? { touchedFiles, message: `Tauri build-артефакти → .gitignore (${touchedFiles.length} file(s))` }
+        : { touchedFiles: [] }
+    }
+  }
+]

package/rules/tauri/gitignore_target/gitignore_target.mdc

@@ -0,0 +1,24 @@
+## `.gitignore`: ignore build-артефактів `<ws>/src-tauri/target/`
+
+Кожен `<ws>/src-tauri/` (Rust-крейт Tauri) компілюється в `<ws>/src-tauri/target/` — build-артефакти Cargo (сотні MB, десятки тисяч файлів). Корінний `.gitignore` монорепо повинен містити точний ignore-запис для кожного такого воркспейсу:
+
+```gitignore
+# Tauri — Rust build artifacts (tauri.mdc)
+<ws>/src-tauri/target/
+```
+
+### Чому точний шлях, а не голий `target/`
+
+Реальний інцидент: у `nitra/task` корінний `.gitignore` мав `owner/target/` замість `owner/src-tauri/target/` — воркспейс скопійований з іншого проєкту без заміни шляху (typo). `target/` там ігнорувався не там, де компілятор його реально створює, тож ~600MB / ~28k файлів build-артефактів не потрапляли під жоден ignore-патерн і мало не потрапили в коміт через `git add -A`.
+
+Тому перевірка звіряє **точний рядок** `<ws>/src-tauri/target/` для кожного знайденого `src-tauri/`, а не факт наявності підрядка `target/` десь у файлі — голий `target/` (чи вже наявний, але помилковий `owner/target/`) не закриває violation.
+
+### Область дії
+
+- Обхід усіх `<ws>/src-tauri/` — спільний з `tauri/cargo_mutants_config` (`findSrcTauriDirs`, без дублювання обходу монорепо).
+- Ціль фіксу — **один** корінний `.gitignore` монорепо (не по workspace).
+- Детектор лише **додає** відсутнє: сторонні/застарілі ignore-записи (на кшталт помилкового `owner/target/` з інциденту вище) не видаляються — вони можуть бути навмисними чи потребувати ручного review.
+
+### Автофікс (T0)
+
+Дописує відсутні записи в кінець секції `# Tauri — Rust build artifacts (tauri.mdc)`: якщо секція вже є — поруч із наявними entries (мінімальний diff, без переписування файла); якщо нема — створює новий блок у кінці `.gitignore`. Ідемпотентно: повторний прогін на вже виправленому файлі нічого не змінює.

package/rules/tauri/gitignore_target/main.mjs

@@ -0,0 +1,84 @@
+/**
+ * @see ./docs/main.md
+ *
+ * Read-only detector: для кожного знайденого `<ws>/src-tauri/` у монорепо
+ * корінний `.gitignore` повинен містити точний ignore-запис
+ * `<ws>/src-tauri/target/` (tauri.mdc).
+ *
+ * Реальний інцидент: у `nitra/task` `.gitignore` мав `owner/target/` замість
+ * `owner/src-tauri/target/` (typo — воркспейс скопійований без заміни шляху),
+ * тому build-артефакти (~600MB, ~28k файлів) не ігнорувались і мало не
+ * потрапили в коміт через `git add -A`. Тому перевірка — точний match рядка
+ * повного шляху, не пошук голого `target/` десь у файлі: голий `target/`
+ * (чи `owner/target/`) дав би false negative саме на цьому кейсі.
+ *
+ * Обхід `<ws>/src-tauri/` — спільний з `tauri/cargo_mutants_config`
+ * (`findSrcTauriDirs`), без дублювання.
+ */
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { join, relative } from 'node:path'
+
+import { createViolationReporter } from '../../../scripts/lib/lint-surface/violation-reporter.mjs'
+import { findSrcTauriDirs } from '../cargo_mutants_config/main.mjs'
+
+/** Стабільний reason: у корінному `.gitignore` бракує ignore-запису(ів) для `src-tauri/target/`. */
+export const MISSING_GITIGNORE_TARGET_ENTRIES = 'missing-gitignore-target-entries'
+
+/** Корінний `.gitignore` — один на монорепо, не по workspace. */
+export const ROOT_GITIGNORE = '.gitignore'
+
+/**
+ * Очікуваний ignore-запис для build-артефактів одного `<ws>/src-tauri/`.
+ * @param {string} cwd корінь монорепо
+ * @param {string} srcTauriDir абсолютний шлях до `src-tauri/`
+ * @returns {string} очікуваний рядок у корінному `.gitignore` (`<ws>/src-tauri/target/`)
+ */
+export function expectedTargetEntry(cwd, srcTauriDir) {
+  return `${relative(cwd, srcTauriDir)}/target/`
+}
+
+/**
+ * Знаходить очікувані entries, яких бракує у вмісті кореневого `.gitignore`.
+ * Точний match рядка (після trim) — голий `target/` чи typo на кшталт
+ * `owner/target/` не рахуються присутністю очікуваного запису.
+ * @param {string} content вміст `.gitignore`
+ * @param {string[]} expectedEntries очікувані ignore-рядки
+ * @returns {string[]} відсутні entries (зі збереженням порядку expectedEntries)
+ */
+export function findMissingEntries(content, expectedEntries) {
+  const present = new Set(content.split('\n').map(l => l.trim()))
+  return expectedEntries.filter(e => !present.has(e))
+}
+
+/**
+ * @param {import('../../../scripts/lib/lint-surface/types.mjs').LintContext} ctx контекст лінт-прогону
+ * @returns {Promise<import('../../../scripts/lib/lint-surface/types.mjs').LintResult>} результат перевірки
+ */
+export async function lint(ctx) {
+  const cwd = ctx.cwd
+  const reporter = createViolationReporter(ctx)
+
+  const srcTauriDirs = await findSrcTauriDirs(cwd)
+  if (srcTauriDirs.length === 0) return reporter.result()
+
+  const expectedEntries = srcTauriDirs.map(dir => expectedTargetEntry(cwd, dir))
+  const abs = join(cwd, ROOT_GITIGNORE)
+  const content = existsSync(abs) ? await readFile(abs, 'utf8') : ''
+
+  const missing = findMissingEntries(content, expectedEntries)
+  if (missing.length === 0) {
+    reporter.pass(`${ROOT_GITIGNORE}: build-артефакти всіх src-tauri/ ігноруються`)
+    return reporter.result()
+  }
+
+  reporter.fail(
+    `${ROOT_GITIGNORE}: бракує ignore-запису(ів) для Tauri build-артефактів [${missing.join(', ')}] — build-артефакти можуть потрапити в коміт (tauri.mdc)`,
+    {
+      reason: MISSING_GITIGNORE_TARGET_ENTRIES,
+      file: ROOT_GITIGNORE,
+      data: { kind: MISSING_GITIGNORE_TARGET_ENTRIES, missing }
+    }
+  )
+  return reporter.result()
+}

package/rules/text/run-v8r/docs/main.md

@@ -3,7 +3,7 @@ type: JS Module
 title: main.mjs
 resource: npm/rules/text/run-v8r/main.mjs
 docgen:
-  crc: 7abeb17f
+  crc: 91a9608d
   model: manual
 ---
 

package/rules/text/run-v8r/main.mjs

@@ -116,6 +116,55 @@ const PROCESSING_LINE_RE = /^ℹ Processing (.+)$/u
 const FOUND_REMOTE_SCHEMA_RE = /^ℹ Found schema in (https?:\/\/\S+)/u
 const NOISE_LINE_RE = /^(?:ℹ .*|Resolving dependencies|Resolved, downloaded and extracted.*|Saved lockfile)$/u
 
+/**
+ * Рядок ajv-помилки компіляції самої схеми (не документа). v8r ловить це в `try/catch` навколо
+ * `ajv.compileAsync(schema)` (`validateDocument` у v8r/src/cli.js) і друкує голий
+ * `SyntaxError.message` без файлового контексту чи "is invalid"-заголовка — на відміну від
+ * genuine validation-помилки, де ajv повертає `errors[]` з прив'язкою до документа. Найчастіша
+ * причина: ajv за замовчуванням компілює `pattern` з прапорцем `/u` (`unicodeRegExp: true`), а
+ * реальні опубліковані схеми (напр. офіційна `azure-pipelines-vscode/service-schema.json`) містять
+ * legacy over-escaped regex, валідний поза Unicode-режимом, але `SyntaxError` у ньому. Це несправна
+ * схема, а не невалідний файл користувача — v8r не дає способу це відрізнити нативно (немає опції
+ * `unicodeRegExp` у config-schema.json), тому розрізняємо тут за форматом самого повідомлення.
+ * `logger.error` у v8r (src/logger.js) додає префікс `✖ ` перед `e.message` — опційний у regex,
+ * бо `extractFailureLines` не чіпає цей префікс (лише прибирає `ℹ`-шум).
+ */
+const AJV_SCHEMA_COMPILE_ERROR_RE = /^(?:✖ )?Invalid regular expression:.*$/mu
+
+/**
+ * Чи складається `detail` ВИКЛЮЧНО з рядків ajv-помилки компіляції схеми (без жодної genuine
+ * validation-помилки). Навмисно консервативно: якщо серед рядків `detail` є хоч один, що НЕ
+ * збігається з `AJV_SCHEMA_COMPILE_ERROR_RE` (напр. "file.yml is invalid" чи ajv `errors[]`-деталь
+ * genuine порушення в тому ж batch-виклику v8r по glob-у) — не втручаємось, викликач лишає
+ * оригінальний `code`/`detail` без змін, щоб не замаскувати реальну проблему.
+ * @param {string} detail рядки `✖ …` з `extractFailureLines`
+ * @returns {boolean} true — усі непорожні рядки `detail` є ajv schema-compile-помилками
+ */
+function isOnlyAjvSchemaCompileErrors(detail) {
+  const lines = detail
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line.length > 0)
+  if (lines.length === 0) return false
+  return lines.every(line => AJV_SCHEMA_COMPILE_ERROR_RE.test(line))
+}
+
+/**
+ * Друкує інформаційне попередження (не violation) для кожного `detail`-рядка ajv schema-compile-
+ * помилки — пояснює, що причина у несправній зовнішній схемі, не в нашому файлі.
+ * @param {string} detail рядки `✖ …`, для яких `isOnlyAjvSchemaCompileErrors` вже повернув true
+ * @returns {void}
+ */
+function reportAjvSchemaCompileFailures(detail) {
+  for (const line of detail.split('\n')) {
+    const trimmed = line.trim()
+    if (trimmed.length === 0) continue
+    process.stdout.write(
+      `⚠ run-v8r: зовнішня схема не компілюється в ajv (не файл) — ${trimmed} Ймовірно, ajv unicodeRegExp-несумісність зі старим стилем escape у чужій схемі; помилка не рахується як порушення.\n`
+    )
+  }
+}
+
 /**
  * Прибирає v8r/bunx noise-рядки (весь `ℹ`-статус: Loaded config file, Patterns and relative
  * paths, Pre-warming the cache, Processing <file>, Found schema in …, Validating …; і службовий
@@ -190,7 +239,11 @@ export function stripBunNodeShimDirs(pathValue) {
  * @param {boolean} [verbose] друкувати повний raw stdout/stderr v8r при помилці; інакше — лише
  *   рядки `✖ …` без `ℹ`-шуму (Pre-warming the cache, Processing <file>, Found schema in …)
  * @returns {Promise<{ exitError: true } | { exitError: false, code: number, detail: string }>}
- *   помилка spawn або код v8r (0/98 — трактує викликач) + деталь `✖ …`-рядків
+ *   помилка spawn або код v8r (0/98 — трактує викликач) + деталь `✖ …`-рядків. Якщо ВЕСЬ `detail`
+ *   складається лише з ajv schema-compile-помилок (несправна зовнішня схема, не наш файл —
+ *   `isOnlyAjvSchemaCompileErrors`) — `code` примусово 0, а причина друкується окремим `⚠`-попередженням
+ *   (`reportAjvSchemaCompileFailures`), а не як `✖`-порушення; мішаний випадок (є хоч один
+ *   genuine validation-рядок) лишається без змін навмисно, щоб не замаскувати реальну проблему.
  */
 async function runOneV8rInvocation(targets, configPath, verbose = false) {
   const bunPath = resolveCmd('bun') ?? process.execPath
@@ -206,16 +259,24 @@ async function runOneV8rInvocation(targets, configPath, verbose = false) {
 
   warnAboutRemoteSchemaFallback(result.stderr ?? '')
 
-  const exitCode = result.exitCode ?? 1
+  let exitCode = result.exitCode ?? 1
   let detail = ''
   if (exitCode !== 0 && exitCode !== 98) {
     detail = extractFailureLines(`${result.stdout ?? ''}\n${result.stderr ?? ''}`)
+    const onlySchemaCompileErrors = isOnlyAjvSchemaCompileErrors(detail)
     if (verbose) {
       if (result.stdout?.length) process.stdout.write(result.stdout)
       if (result.stderr?.length) process.stderr.write(result.stderr)
+    } else if (onlySchemaCompileErrors) {
+      reportAjvSchemaCompileFailures(detail)
     } else if (detail.length) {
       process.stdout.write(`${detail}\n`)
     }
+    if (onlySchemaCompileErrors) {
+      if (verbose) reportAjvSchemaCompileFailures(detail)
+      exitCode = 0
+      detail = ''
+    }
   }
   return { exitError: false, code: exitCode, detail }
 }

package/scripts/lib/acp-runner.mjs

@@ -16,6 +16,7 @@
  */
 
 import { spawn } from 'node:child_process'
+import { once } from 'node:events'
 import { readFileSync, writeFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { dirname, join } from 'node:path'
@@ -118,6 +119,47 @@ class AcpSkillClient {
   }
 }
 
+/**
+ * @param {import('node:child_process').ChildProcess} child дочірній процес
+ * @returns {Promise<{ event: 'error', error: Error }>} подія спавн-помилки
+ */
+async function watchSpawnError(child) {
+  const [error] = await once(child, 'error')
+  return { event: 'error', error }
+}
+
+/**
+ * @param {import('node:child_process').ChildProcess} child дочірній процес
+ * @returns {Promise<{ event: 'exit', code: number|null, signal: string|null }>} подія завершення процесу
+ */
+async function watchExit(child) {
+  const [code, signal] = await once(child, 'exit')
+  return { event: 'exit', code, signal }
+}
+
+/**
+ * Watchdog дочірнього процесу: провалюється швидко, якщо ACP-агент не запустився чи
+ * вийшов до кінця ходу — без цього мертвий процес вішає `connection.prompt` назавжди
+ * (`Connection#receive` у `@zed-industries/agent-client-protocol` тихо завершує читання
+ * на закритому stdout, не відхиляючи pending-запити).
+ * @param {import('node:child_process').ChildProcess} child дочірній процес ACP-агента
+ * @param {string} kind провайдер (для тексту помилки)
+ * @returns {Promise<never>} ніколи не резолвиться успішно — лише провалюється
+ * @throws {Error} на спавн-помилку чи будь-який вихід процесу до завершення ходу
+ */
+async function waitForChildFailure(child, kind) {
+  const result = await Promise.race([watchSpawnError(child), watchExit(child)])
+
+  if (result.event === 'error') {
+    throw new Error(`acp ${kind}: не вдалося запустити процес: ${result.error.message}`)
+  }
+  throw new Error(
+    result.signal
+      ? `acp ${kind}: процес вбитий сигналом ${result.signal} до завершення ходу`
+      : `acp ${kind}: процес завершився з кодом ${result.code} до завершення ходу`
+  )
+}
+
 /**
  * Виконує скіл через зовнішнього ACP-агента. Єдиний лишений провайдер —
  * deprecated `claude` (`cursor`/`codex` — див. `@7n/llm-lib/acp`).
@@ -139,6 +181,7 @@ export async function runAcpRunner(kind, prompt, projectDir, logError, deps = {}
 
   const acp = deps.acp ?? (await import('@zed-industries/agent-client-protocol'))
   const child = spawnFn(bin, args, { cwd: projectDir, stdio: ['pipe', 'pipe', 'inherit'], env: process.env })
+  const failure = waitForChildFailure(child, kind)
 
   try {
     const input = Writable.toWeb(child.stdin)
@@ -147,15 +190,19 @@ export async function runAcpRunner(kind, prompt, projectDir, logError, deps = {}
     const stream = acp.ndJsonStream(input, output)
     const connection = new acp.ClientSideConnection(() => client, stream)
 
-    await connection.initialize({
-      protocolVersion: acp.PROTOCOL_VERSION,
-      clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } }
-    })
-    const session = await connection.newSession({ cwd: projectDir, mcpServers: [] })
-    const result = await connection.prompt({
-      sessionId: session.sessionId,
-      prompt: [{ type: 'text', text: prompt }]
-    })
+    const turn = (async () => {
+      await connection.initialize({
+        protocolVersion: acp.PROTOCOL_VERSION,
+        clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } }
+      })
+      const session = await connection.newSession({ cwd: projectDir, mcpServers: [] })
+      return connection.prompt({
+        sessionId: session.sessionId,
+        prompt: [{ type: 'text', text: prompt }]
+      })
+    })()
+
+    const result = await Promise.race([turn, failure])
 
     if (result.stopReason !== 'end_turn') {
       logError(`acp ${kind}: stopReason=${result.stopReason}`)