778 lines
46 KiB
Markdown
778 lines
46 KiB
Markdown
# bridge-reliability — хаб: план реализации
|
||
|
||
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
|
||
|
||
**Goal:** хаб довыдаёт команду, оставшуюся без отчёта (с пределом 3 выдачи), мигрирует живую базу на схему v2, отвергает
|
||
отчёт по невыданной команде и пакет с дублем темы, сохраняет ключ из позднего отчёта по отменённой `ensure_issue`,
|
||
показывает связи «в обратную сторону» в отчёте импорта отдельно.
|
||
|
||
**Architecture:** вся логика выдачи и отчётов — в `src/jira_hub/queue.py` (одна транзакция на `claim`/`report_result`);
|
||
миграция — в `db.migrate` по `setting.schema_version`; валидация пакета — `commands.validate`; отчёт импорта —
|
||
`importer._import`. HTTP-слой (`api.py`) только переводит исключения в коды.
|
||
|
||
**Tech Stack:** Python 3.13, uv, pytest, SQLite (stdlib), stdlib `http.server`.
|
||
|
||
**Spec:** `openspec/changes/bridge-reliability/` (proposal.md, design.md, specs/{hub-api,data-model,commands,mcp,migration,agent}).
|
||
|
||
## Global Constraints
|
||
|
||
- Комментарии, docstring, сообщения ошибок и коммитов — по-русски; идентификаторы — английские.
|
||
- `uv run pytest -q` — зелёным считается только весь набор (до начала: 159 passed).
|
||
- Новых зависимостей нет. Контракт тел запросов агента не меняется.
|
||
- Предел выдач — константа `MAX_DELIVERIES = 3`; текст ошибки ровно `агент не отчитался после 3 выдач`.
|
||
- `SCHEMA_VERSION = 2`; копия базы перед миграцией — `<каталог базы>/backups/<дата-время>-schema-v1.sqlite`, без ротации.
|
||
- Каждая задача заканчивается коммитом `git -C /Users/andrey.epifancev/projects/awp-ca/jira-hub/.wt/reliability …`
|
||
с сообщением на русском и строкой `Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>`; суффикс `(#9)` в заголовке.
|
||
- Решения, принятые исполнителем без обсуждения, — в `openspec/changes/bridge-reliability/design.md`, раздел
|
||
`## Decisions made without discussion`, с маркером `R-n`.
|
||
|
||
## Review Focus
|
||
|
||
1. Живая база v1 с командой в `claimed`: после старта нового хаба команда довыдаётся (`deliveries` 1 → 2), а не теряется и
|
||
не падает миграция — тест в Task 1 (миграция) и Task 2 (довыдача команды, мигрированной с `deliveries = 1`).
|
||
2. Два параллельных `claim` (старый долгий запрос реле и новый): одна строка в `claimed`, `deliveries` = числу выдач,
|
||
обе выдачи — один и тот же `id` — тест `test_claim_is_exclusive` в Task 2.
|
||
3. Довыдача `refresh`: второй `sync_run` не создаётся (иначе счётчики синхронизаций двоятся) — тест в Task 2.
|
||
4. Довыдача команды из отменённого пакета (`cancel_batch` оставляет `claimed`): выдаётся снова, не теряется — тест в Task 2.
|
||
5. Поздний отчёт по отменённой `ensure_issue` приходит дважды или после того, как результат уже записан: второй раз
|
||
ничего не меняет (идемпотентность) — тест в Task 3.
|
||
|
||
---
|
||
|
||
### Task 1: Миграция схемы v1 → v2 (`command.deliveries`)
|
||
|
||
**Files:**
|
||
- Modify: `src/jira_hub/db.py` (`SCHEMA_VERSION`, таблица `command` в `SCHEMA`, `connect`, `migrate`)
|
||
- Test: `tests/test_db.py`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `backup.make_backup(conn, backups_dir, label, keep)` из `src/jira_hub/backup.py` (без изменений; `keep=0` —
|
||
без ротации).
|
||
- Produces: колонка `command.deliveries INTEGER NOT NULL DEFAULT 0`; `db.SCHEMA_VERSION == 2`;
|
||
`db.migrate(conn, path=None)`.
|
||
|
||
- [ ] **Step 1: Write the failing tests** — в `tests/test_db.py` заменить проверку версии и добавить тесты миграции:
|
||
|
||
```python
|
||
import sqlite3
|
||
|
||
from jira_hub import db
|
||
|
||
|
||
def test_connect_creates_schema():
|
||
conn = db.connect(":memory:")
|
||
names = {r["name"] for r in conn.execute("SELECT name FROM sqlite_master WHERE type = 'table'")}
|
||
assert {"setting", "issue", "issue_link", "issue_note", "batch", "command", "sync_run", "agent_status"} <= names
|
||
assert conn.execute("SELECT value FROM setting WHERE key = 'schema_version'").fetchone()["value"] == "2"
|
||
assert conn.execute("SELECT COUNT(*) AS n FROM agent_status").fetchone()["n"] == 1
|
||
cols = {r["name"] for r in conn.execute("PRAGMA table_info(command)")}
|
||
assert "deliveries" in cols
|
||
|
||
|
||
def _v1_database(path):
|
||
"""База в состоянии схемы v1: без command.deliveries, schema_version = 1, с живыми данными."""
|
||
conn = db.connect(path)
|
||
conn.execute("INSERT INTO batch(title, author, created_at) VALUES ('x', 'claude', '2026-10-13T00:00:00+00:00')")
|
||
for status in ("claimed", "done", "queued"):
|
||
conn.execute("INSERT INTO command(batch_id, seq, type, params, status, claimed_at) VALUES (1, 1, 'refresh', '{}', ?, ?)",
|
||
(status, "2026-10-13T00:00:00+00:00" if status == "claimed" else None))
|
||
conn.execute("INSERT INTO issue_note(key, fact_status) VALUES ('A-1', 'В работе')")
|
||
conn.execute("ALTER TABLE command DROP COLUMN deliveries")
|
||
conn.execute("UPDATE setting SET value = '1' WHERE key = 'schema_version'")
|
||
conn.close()
|
||
|
||
|
||
def test_migrates_v1_with_backup(tmp_path):
|
||
path = tmp_path / "hub.sqlite"
|
||
_v1_database(path)
|
||
conn = db.connect(path)
|
||
assert conn.execute("SELECT value FROM setting WHERE key = 'schema_version'").fetchone()["value"] == "2"
|
||
rows = conn.execute("SELECT status, deliveries FROM command ORDER BY id").fetchall()
|
||
assert [(r["status"], r["deliveries"]) for r in rows] == [("claimed", 1), ("done", 0), ("queued", 0)]
|
||
assert conn.execute("SELECT fact_status FROM issue_note WHERE key = 'A-1'").fetchone()["fact_status"] == "В работе"
|
||
copies = list((tmp_path / "backups").glob("*-schema-v1.sqlite"))
|
||
assert len(copies) == 1
|
||
old = sqlite3.connect(copies[0]) # не db.connect — он бы мигрировал копию
|
||
assert "deliveries" not in {r[1] for r in old.execute("PRAGMA table_info(command)")}
|
||
assert old.execute("SELECT value FROM setting WHERE key = 'schema_version'").fetchone()[0] == "1"
|
||
old.close()
|
||
conn.close()
|
||
db.connect(path).close() # повторный connect не мигрирует и не копирует
|
||
assert len(list((tmp_path / "backups").glob("*.sqlite"))) == 1
|
||
|
||
|
||
def test_new_database_makes_no_backup(tmp_path):
|
||
db.connect(tmp_path / "hub.sqlite").close()
|
||
assert not (tmp_path / "backups").exists()
|
||
```
|
||
|
||
- [ ] **Step 2: Run tests to verify they fail**
|
||
|
||
Run: `uv run pytest tests/test_db.py -q`
|
||
Expected: FAIL — `schema_version` равен `"1"`, колонки `deliveries` нет.
|
||
|
||
- [ ] **Step 3: Implement** — в `src/jira_hub/db.py`:
|
||
|
||
1. Импорт рядом с остальными: `from . import backup` (модуль `backup` не импортирует `db`, цикла нет).
|
||
2. `SCHEMA_VERSION = 2`.
|
||
3. В `CREATE TABLE IF NOT EXISTS command` после строки `claimed_at TEXT,` добавить
|
||
` deliveries INTEGER NOT NULL DEFAULT 0,`.
|
||
4. После `SCHEMA` добавить шаги миграций:
|
||
|
||
```python
|
||
# Шаги миграции: версия → SQL, переводящий схему в версию + 1 (design.md bridge-reliability, решение 5)
|
||
MIGRATIONS = {
|
||
1: ["ALTER TABLE command ADD COLUMN deliveries INTEGER NOT NULL DEFAULT 0",
|
||
"UPDATE command SET deliveries = 1 WHERE status = 'claimed'"], # уже выданные — одна выдача
|
||
}
|
||
```
|
||
|
||
5. В `connect` заменить `migrate(conn)` на `migrate(conn, None if is_memory else path)`.
|
||
6. Заменить `migrate`:
|
||
|
||
```python
|
||
def _schema_version(conn) -> int | None:
|
||
row = conn.execute("SELECT value FROM setting WHERE key = 'schema_version'").fetchone()
|
||
return None if row is None else int(json.loads(row["value"]))
|
||
|
||
|
||
def migrate(conn: sqlite3.Connection, path=None) -> None:
|
||
"""Создать недостающие таблицы и поднять схему существующей базы до SCHEMA_VERSION. Перед миграцией файловой базы —
|
||
копия в <каталог базы>/backups (без ротации). Параллельный connect безопасен: версия перечитывается в транзакции."""
|
||
conn.executescript(SCHEMA)
|
||
version = _schema_version(conn)
|
||
if version is None:
|
||
conn.execute("INSERT INTO setting(key, value) VALUES ('schema_version', ?)", (json.dumps(SCHEMA_VERSION),))
|
||
elif version < SCHEMA_VERSION:
|
||
if path is not None:
|
||
backup.make_backup(conn, Path(path).parent / "backups", f"schema-v{version}", keep=0)
|
||
with transaction(conn):
|
||
current = _schema_version(conn)
|
||
while current < SCHEMA_VERSION:
|
||
for sql in MIGRATIONS[current]:
|
||
conn.execute(sql)
|
||
current += 1
|
||
conn.execute("UPDATE setting SET value = ? WHERE key = 'schema_version'", (json.dumps(current),))
|
||
conn.execute("INSERT OR IGNORE INTO agent_status(id) VALUES (1)")
|
||
```
|
||
|
||
Функция `transaction` определена в том же модуле ниже `migrate` — вызов во время выполнения, порядок определения не
|
||
важен.
|
||
|
||
- [ ] **Step 4: Run tests**
|
||
|
||
Run: `uv run pytest tests/test_db.py -q` — PASS. Затем `uv run pytest -q` — весь набор зелёный (другие тесты колонку
|
||
не используют).
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git -C /Users/andrey.epifancev/projects/awp-ca/jira-hub/.wt/reliability add src/jira_hub/db.py tests/test_db.py
|
||
git -C /Users/andrey.epifancev/projects/awp-ca/jira-hub/.wt/reliability commit -m "feat(db): миграция схемы v1→v2 — command.deliveries, копия базы перед миграцией (#9)
|
||
|
||
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 2: Повторная выдача команды без отчёта, предел 3 выдачи
|
||
|
||
**Files:**
|
||
- Modify: `src/jira_hub/queue.py` (docstring модуля, константы, `_definer_stale`, `_next`, `_fresh_claimed_exists`,
|
||
`claim`, `agent_view`, `maybe_auto_refresh`)
|
||
- Modify: `src/jira_hub/mcp_server.py` (`fmt_agent`)
|
||
- Modify: `CLAUDE.md` (строка «Хаб не повторяет команды сам»), `ARCHITECTURE.md` (строка про `queue` в «Границы»),
|
||
`README.md` (раздел «Эксплуатация», пункт про «нет ответа от агента»)
|
||
- Test: `tests/test_queue.py`, `tests/test_api.py`, `tests/test_e2e_hub.py`, `tests/test_mcp.py`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `command.deliveries` (Task 1).
|
||
- Produces: `queue.MAX_DELIVERIES = 3`; `queue.claim(...)` с прежней сигнатурой и формой ответа
|
||
`{id, type, params, pause_seconds, batch_id}`; `queue.agent_view(conn)["redelivered"]` — список
|
||
`{id, type, claimed_at, deliveries}` (ключа `stuck` больше нет).
|
||
|
||
- [ ] **Step 1: Write the failing tests** — в `tests/test_queue.py`:
|
||
|
||
1. В `test_claim_order_pause_and_report` заменить строку
|
||
`assert queue.claim(conn) is None # одна команда в полёте` на
|
||
|
||
```python
|
||
again = queue.claim(conn) # ответ потерян — та же команда снова
|
||
assert again["id"] == c["id"] and again["pause_seconds"] == 120
|
||
assert queue.get_command(conn, c["id"])["deliveries"] == 2
|
||
```
|
||
|
||
2. В `test_claim_is_exclusive` заменить последние две проверки на
|
||
|
||
```python
|
||
got = [r for r in results if r is not None]
|
||
assert got and len({r["id"] for r in got}) == 1 # один и тот же id при любом порядке потоков
|
||
row = setup.execute("SELECT COUNT(*) AS n, MAX(deliveries) AS d FROM command WHERE status = 'claimed'").fetchone()
|
||
assert row["n"] == 1 and row["d"] == len(got)
|
||
```
|
||
|
||
3. Удалить `test_stale_claimed_does_not_block` и `test_stale_definer_does_not_block_other_batches`.
|
||
4. В `test_cancel_and_retry` заменить `assert queue.claim(conn) is None` на
|
||
`assert queue.claim(conn)["id"] == c["id"] # взятая из отменённого пакета довыдаётся`.
|
||
5. В `test_fresh_definer_still_blocks_queue` заменить `assert queue.claim(conn) is None # одна в полёте`
|
||
на `assert queue.claim(conn)["id"] == first["id"] # довыдача определителя, зависимые ждут`.
|
||
6. `test_reconcile_confirms_by_state` переписать (две `claimed` одновременно бывают только в старых данных — моделируем SQL):
|
||
|
||
```python
|
||
def test_reconcile_confirms_by_state():
|
||
conn = fresh()
|
||
queue.create_batch(conn, "x", "claude", [{"type": "ensure_sprint", "params": {"key": "A-1", "sprint": "Спринт 2"}}])
|
||
c = queue.claim(conn)
|
||
b = queue.create_batch(conn, "обновить", "claude", [{"type": "refresh", "params": {"keys": ["A-1"]}}])
|
||
r = queue.batch_view(conn, b["id"])["commands"][0]
|
||
conn.execute("UPDATE command SET status = 'claimed', claimed_at = ?, deliveries = 1 WHERE id = ?", (db.now(), r["id"]))
|
||
mirror.apply_state(conn, [{"key": "A-1", "summary": "т", "sprint": "Спринт 2", "labels": []}], [])
|
||
queue.report_result(conn, r["id"], "done")
|
||
assert queue.get_command(conn, c["id"])["status"] == "confirmed_by_state"
|
||
assert queue.batch_view(conn, b["id"])["status"] == "done"
|
||
```
|
||
|
||
7. В `test_auto_refresh_conditions` в конец добавить:
|
||
|
||
```python
|
||
conn.execute("UPDATE sync_run SET started_at = '2020-01-01T00:00:00+00:00'") # интервал прошёл
|
||
queue.create_batch(conn, "y", "claude", [fields("A-3")])
|
||
queue.claim(conn) # выдана, отчёта нет, queued нет
|
||
conn.execute("DELETE FROM command WHERE status = 'queued'") # хвостовой refresh не мешает проверке
|
||
conn.execute("UPDATE command SET claimed_at = '2020-01-01T00:00:00+00:00' WHERE status = 'claimed'") # давно без отчёта
|
||
assert queue.maybe_auto_refresh(conn) is None # claimed без отчёта — очередь занята
|
||
```
|
||
|
||
8. Добавить новые тесты:
|
||
|
||
```python
|
||
def test_redelivery_of_lost_claim_before_queue():
|
||
conn = fresh()
|
||
queue.create_batch(conn, "x", "claude", [fields("A-1"), fields("A-2")])
|
||
c = queue.claim(conn)
|
||
again = queue.claim(conn)
|
||
assert again["id"] == c["id"] and again["params"] == c["params"]
|
||
assert queue.agent_view(conn)["current_command_id"] == c["id"]
|
||
view = queue.agent_view(conn)["redelivered"]
|
||
assert [(x["id"], x["deliveries"]) for x in view] == [(c["id"], 2)]
|
||
queue.report_result(conn, c["id"], "done")
|
||
assert queue.claim(conn)["params"]["key"] == "A-2"
|
||
assert queue.agent_view(conn)["redelivered"] == []
|
||
|
||
|
||
def test_redelivery_limit_fails_command():
|
||
conn = fresh()
|
||
queue.create_batch(conn, "x", "claude", [fields("A-1"), fields("A-2")])
|
||
c = queue.claim(conn)
|
||
queue.claim(conn)
|
||
queue.claim(conn) # третья выдача
|
||
nxt = queue.claim(conn) # четвёртой нет — failed и дальше по очереди
|
||
assert nxt["params"]["key"] == "A-2"
|
||
failed = queue.get_command(conn, c["id"])
|
||
assert failed["status"] == "failed" and failed["error"] == "агент не отчитался после 3 выдач" and failed["finished_at"]
|
||
assert queue.MAX_DELIVERIES == 3
|
||
|
||
|
||
def test_redelivery_oldest_first():
|
||
conn = fresh()
|
||
queue.create_batch(conn, "x", "claude", [fields("A-1")])
|
||
queue.create_batch(conn, "y", "claude", [fields("A-2")])
|
||
rows = conn.execute("SELECT id FROM command WHERE type = 'ensure_fields' ORDER BY id").fetchall()
|
||
conn.execute("UPDATE command SET status = 'claimed', claimed_at = '2026-10-13T10:00:00+00:00', deliveries = 1 WHERE id = ?", (rows[1]["id"],))
|
||
conn.execute("UPDATE command SET status = 'claimed', claimed_at = '2026-10-13T11:00:00+00:00', deliveries = 1 WHERE id = ?", (rows[0]["id"],))
|
||
assert queue.claim(conn)["id"] == rows[1]["id"]
|
||
|
||
|
||
def test_redelivered_refresh_keeps_one_sync_run():
|
||
conn = fresh()
|
||
queue.create_batch(conn, "обновить", "claude", [{"type": "refresh", "params": {"keys": ["A-1"]}}])
|
||
r = queue.claim(conn)
|
||
assert queue.claim(conn)["id"] == r["id"]
|
||
assert conn.execute("SELECT COUNT(*) AS n FROM sync_run WHERE command_id = ?", (r["id"],)).fetchone()["n"] == 1
|
||
|
||
|
||
def test_redelivery_does_not_repeat_backup():
|
||
conn = fresh()
|
||
queue.create_batch(conn, "x", "claude", [fields("A-1")])
|
||
labels = []
|
||
queue.claim(conn, backup=labels.append)
|
||
queue.claim(conn, backup=labels.append)
|
||
assert len(labels) == 1
|
||
|
||
|
||
def test_migrated_claimed_is_redelivered():
|
||
"""Команда, взятая до миграции (deliveries = 1 после неё), довыдаётся со счётчиком 2."""
|
||
conn = fresh()
|
||
queue.create_batch(conn, "x", "claude", [fields("A-1")])
|
||
cid = conn.execute("SELECT id FROM command WHERE type = 'ensure_fields'").fetchone()["id"]
|
||
conn.execute("UPDATE command SET status = 'claimed', claimed_at = '2026-10-12T00:00:00+00:00', deliveries = 1 WHERE id = ?", (cid,))
|
||
assert queue.claim(conn)["id"] == cid
|
||
assert queue.get_command(conn, cid)["deliveries"] == 2
|
||
```
|
||
|
||
9. В `tests/test_api.py::test_agent_flow` заменить
|
||
`assert a.post("/agent/claim", {})["command"] is None # одна в полёте, долгий запрос выключен` на
|
||
`assert a.post("/agent/claim", {})["command"]["id"] == cmd["id"] # ответ потерян — довыдача той же команды`.
|
||
10. В `tests/test_e2e_hub.py` заменить
|
||
`assert agent.post("/agent/claim", {"agent_version": 1, "settings_version": 1})["command"] is None` на
|
||
`assert agent.post("/agent/claim", {"agent_version": 1, "settings_version": 1})["command"]["id"] == cmd["id"]`
|
||
и комментарий над ней — на `# одна команда в полёте: повторный claim довыдаёт ensure_issue, зависимая ensure_link не выдаётся`.
|
||
11. В `tests/test_mcp.py::test_formatters` заменить `"stuck": []` на `"redelivered": []` и добавить:
|
||
|
||
```python
|
||
text = mcp_server.fmt_agent({"online": True, "agent_version": "2", "current_command_id": 40, "rate_limited_24h": 0,
|
||
"redelivered": [{"id": 40, "type": "ensure_fields", "claimed_at": "2026-10-13T10:00:00+00:00",
|
||
"deliveries": 2}],
|
||
"warning": None, "last_seen_at": "2026-10-13T10:00:00+00:00", "settings_version": 3})
|
||
assert "онлайн" in text and "#40" in text and "выдач 2" in text
|
||
```
|
||
|
||
- [ ] **Step 2: Run tests to verify they fail**
|
||
|
||
Run: `uv run pytest tests/test_queue.py tests/test_api.py tests/test_e2e_hub.py tests/test_mcp.py -q`
|
||
Expected: FAIL — повторный `claim` даёт `None`, нет `MAX_DELIVERIES`, нет `redelivered`.
|
||
|
||
- [ ] **Step 3: Implement** — `src/jira_hub/queue.py`:
|
||
|
||
1. Docstring модуля:
|
||
|
||
```python
|
||
"""Очередь команд: пакеты, выдача агенту по одной, отчёты, отмена, повтор, сверка с зеркалом, автообновление.
|
||
Новых команд хаб сам не создаёт: повтор после failed — новый пакет по запросу человека. Команду, выданную агенту и
|
||
оставшуюся без отчёта, хаб довыдаёт при следующем claim — это доставка той же выдачи (bridge-reliability, решение 1)."""
|
||
```
|
||
|
||
2. Константы: удалить `STALE_MINUTES`; добавить
|
||
`MAX_DELIVERIES = 3 # выдач без отчёта, после которых команда — failed (bridge-reliability, решение 2)`.
|
||
3. Удалить функции `_definer_stale` и `_fresh_claimed_exists`.
|
||
4. В `_next` удалить `blocked_batches` и обход зависшего определителя; блок `if pending:` становится
|
||
`return None # создание ещё не завершено — ждём (одна в полёте)`:
|
||
|
||
```python
|
||
def _next(conn) -> dict | None:
|
||
rows = conn.execute("SELECT c.* FROM command c JOIN batch b ON b.id = c.batch_id "
|
||
"WHERE c.status = 'queued' AND b.cancelled_at IS NULL ORDER BY b.created_at, b.id, c.seq").fetchall()
|
||
for row in rows:
|
||
cmd = _cmd(row)
|
||
needed = C.temp_keys_used(cmd)
|
||
if needed:
|
||
mapping = _mapping(conn, cmd["batch_id"])
|
||
unresolved = [k for k in needed if k not in mapping]
|
||
if any(_definer_status(conn, cmd["batch_id"], k) not in TERMINAL for k in unresolved):
|
||
return None # создание ещё не завершено — ждём (одна в полёте)
|
||
cmd["params"] = C.substitute(cmd["type"], cmd["params"], mapping)
|
||
if cmd["type"] == "refresh":
|
||
cmd["params"]["keys"] = [k for k in cmd["params"].get("keys", []) if not C.is_temp(k)]
|
||
unresolved = [] if cmd["params"]["keys"] else unresolved
|
||
if unresolved:
|
||
conn.execute("UPDATE command SET status = 'skipped', finished_at = ?, error = ? WHERE id = ?",
|
||
(db.now(), f"задача {unresolved[0]} не создана", cmd["id"]))
|
||
continue
|
||
return cmd
|
||
return None
|
||
```
|
||
|
||
5. Новая функция перед `claim`:
|
||
|
||
```python
|
||
def _redeliver(conn, now) -> dict | None:
|
||
"""Самая старая взятая команда без отчёта — выдать снова. Агент приходит за новой командой, только когда своей
|
||
незавершённой нет, значит выданную он не получил или потерял. После MAX_DELIVERIES выдач — failed."""
|
||
while True:
|
||
row = conn.execute("SELECT * FROM command WHERE status = 'claimed' ORDER BY claimed_at, id LIMIT 1").fetchone()
|
||
if row is None:
|
||
return None
|
||
cmd = _cmd(row)
|
||
if cmd["deliveries"] < MAX_DELIVERIES:
|
||
return cmd
|
||
conn.execute("UPDATE command SET status = 'failed', finished_at = ?, error = ? WHERE id = ?",
|
||
(now, f"агент не отчитался после {MAX_DELIVERIES} выдач", cmd["id"]))
|
||
conn.execute("UPDATE agent_status SET current_command_id = NULL WHERE id = 1 AND current_command_id = ?", (cmd["id"],))
|
||
log.warning("команда %s: агент не отчитался после %s выдач — failed", cmd["id"], MAX_DELIVERIES)
|
||
```
|
||
|
||
6. `claim` — тело транзакции:
|
||
|
||
```python
|
||
def claim(conn, agent_version=None, settings_version=None, last_jira_call_at=None, backup=None) -> dict | None:
|
||
now = db.now()
|
||
to_backup = None
|
||
with db.transaction(conn):
|
||
conn.execute("UPDATE agent_status SET last_seen_at = ?, agent_version = COALESCE(?, agent_version), "
|
||
"settings_version = COALESCE(?, settings_version), last_jira_call_at = COALESCE(?, last_jira_call_at) WHERE id = 1",
|
||
(now, None if agent_version is None else str(agent_version), settings_version, last_jira_call_at))
|
||
cmd = _redeliver(conn, now)
|
||
if cmd is not None:
|
||
pause = int(settings.pacing(conn).get(cmd["type"], 0))
|
||
conn.execute("UPDATE command SET claimed_at = ?, pause_seconds = ?, deliveries = deliveries + 1 WHERE id = ?",
|
||
(now, pause, cmd["id"]))
|
||
conn.execute("UPDATE agent_status SET current_command_id = ? WHERE id = 1", (cmd["id"],))
|
||
log.info("команда %s выдана снова (выдача %s)", cmd["id"], cmd["deliveries"] + 1)
|
||
else:
|
||
cmd = _next(conn)
|
||
if cmd is None:
|
||
conn.execute("UPDATE agent_status SET current_command_id = NULL WHERE id = 1")
|
||
return None
|
||
pause = int(settings.pacing(conn).get(cmd["type"], 0))
|
||
first = conn.execute("SELECT COUNT(*) AS n FROM command WHERE batch_id = ? AND status != 'queued'",
|
||
(cmd["batch_id"],)).fetchone()["n"] == 0
|
||
has_writes = conn.execute("SELECT 1 FROM command WHERE batch_id = ? AND type != 'refresh' LIMIT 1",
|
||
(cmd["batch_id"],)).fetchone() is not None
|
||
conn.execute("UPDATE command SET status = 'claimed', claimed_at = ?, pause_seconds = ?, params = ?, deliveries = 1 "
|
||
"WHERE id = ?", (now, pause, _dump(cmd["params"]), cmd["id"]))
|
||
conn.execute("UPDATE agent_status SET current_command_id = ? WHERE id = 1", (cmd["id"],))
|
||
if cmd["type"] == "refresh":
|
||
p = cmd["params"]
|
||
conn.execute("INSERT INTO sync_run(started_at, kind, query, command_id) VALUES (?, ?, ?, ?)",
|
||
(now, "jql" if p.get("jql") else "keys", p.get("jql") or ",".join(p.get("keys", [])), cmd["id"]))
|
||
if first and has_writes:
|
||
to_backup = f"batch-{cmd['batch_id']}"
|
||
# дальше без изменений: резервная копия вне транзакции и return
|
||
```
|
||
|
||
Хвост функции (`if to_backup and backup: …` и `return {...}`) оставить как есть.
|
||
7. `agent_view` — вместо блока `cutoff`/`stuck`:
|
||
|
||
```python
|
||
d["redelivered"] = [dict(r) for r in conn.execute(
|
||
"SELECT id, type, claimed_at, deliveries FROM command WHERE status = 'claimed' AND deliveries > 1 ORDER BY id")]
|
||
```
|
||
|
||
8. `maybe_auto_refresh` — условие занятой очереди:
|
||
|
||
```python
|
||
if conn.execute("SELECT 1 FROM command WHERE status IN ('queued', 'claimed') LIMIT 1").fetchone():
|
||
return None
|
||
```
|
||
|
||
9. `src/jira_hub/mcp_server.py::fmt_agent` — цикл по `stuck` заменить на
|
||
|
||
```python
|
||
for s in a.get("redelivered", []):
|
||
out.append(f"выдана повторно: #{s['id']} {s['type']}, выдач {s['deliveries']}, последняя {s['claimed_at']}")
|
||
```
|
||
|
||
10. Документы:
|
||
- `CLAUDE.md`, строка «Хаб не повторяет команды сам…» → `- Хаб не создаёт команды сам: повтор после failed — новая
|
||
команда по запросу человека/интерфейса. Команду, выданную агенту и оставшуюся без отчёта, хаб довыдаёт при
|
||
следующем claim (до 3 выдач, затем failed).`
|
||
- `ARCHITECTURE.md`, строка «`queue` не повторяет команды…» → `- \`queue\` не создаёт команд сам: повтор после
|
||
failed — новый пакет. Выданная без отчёта команда довыдаётся при следующем \`claim\` (до 3 выдач, затем failed).`
|
||
- `README.md`, раздел «Эксплуатация», пункт «Команда «нет ответа от агента»…» заменить на:
|
||
`- Довыдача: если агент пришёл за новой командой, а выданная ему осталась без отчёта (ответ потерян, агент
|
||
перезапущен), хаб выдаёт её снова; \`agent_status\` показывает такие команды с числом выдач. После 3 выдач без
|
||
отчёта команда становится \`failed\` («агент не отчитался после 3 выдач»), очередь идёт дальше; повтор —
|
||
\`command_retry\`. Отменить взятую команду: \`POST /commands/{id}/cancel\` с \`{"force": true}\`.`
|
||
|
||
- [ ] **Step 4: Run tests**
|
||
|
||
Run: `uv run pytest -q` — весь набор зелёный.
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git -C /Users/andrey.epifancev/projects/awp-ca/jira-hub/.wt/reliability add -A src tests CLAUDE.md ARCHITECTURE.md README.md
|
||
git -C /Users/andrey.epifancev/projects/awp-ca/jira-hub/.wt/reliability commit -m "feat(queue): довыдача команды без отчёта, предел 3 выдачи; R-13 и «свежая claimed» удалены (#9)
|
||
|
||
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 3: Отчёты и пакеты — 409 по невыданной, ключ из позднего отчёта, дубль темы
|
||
|
||
**Files:**
|
||
- Modify: `src/jira_hub/queue.py` (`NotClaimedError`, `report_result`)
|
||
- Modify: `src/jira_hub/api.py` (`h_agent_result`)
|
||
- Modify: `src/jira_hub/commands.py` (`validate`)
|
||
- Test: `tests/test_queue.py`, `tests/test_api.py`, `tests/test_commands.py`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `queue.claim` (Task 2).
|
||
- Produces: `queue.NotClaimedError(Exception)`; API `POST /agent/commands/{id}/result` → 409 `{"error": "not_claimed"}`
|
||
для `queued`; `CommandError` с текстом `повторяется тема ensure_issue: «…»`.
|
||
|
||
- [ ] **Step 1: Write the failing tests**
|
||
|
||
`tests/test_queue.py`:
|
||
|
||
```python
|
||
def test_report_for_queued_command_rejected():
|
||
conn = fresh()
|
||
queue.create_batch(conn, "x", "claude", [fields("A-1")])
|
||
cid = conn.execute("SELECT id FROM command WHERE type = 'ensure_fields'").fetchone()["id"]
|
||
with pytest.raises(queue.NotClaimedError):
|
||
queue.report_result(conn, cid, "done")
|
||
assert queue.get_command(conn, cid)["status"] == "queued"
|
||
|
||
|
||
def test_late_report_after_force_cancel_keeps_issue_key():
|
||
conn = fresh()
|
||
mirror.set_note(conn, "new:7", {"fact_status": "В работе"}, "import")
|
||
queue.create_batch(conn, "x", "claude", [
|
||
{"type": "ensure_issue", "params": {"temp_key": "new:7", "issue_type": "task", "summary": "Тема"}}])
|
||
c = queue.claim(conn)
|
||
cancelled = queue.cancel_command(conn, c["id"], force=True)
|
||
late = queue.report_result(conn, c["id"], "done", result={"key": "A-20", "created": True}, jira_calls=3)
|
||
assert late["status"] == "cancelled" and late["result"] == {"key": "A-20", "created": True} and late["jira_calls"] == 3
|
||
assert late["finished_at"] == cancelled["finished_at"]
|
||
assert mirror.get_note(conn, "A-20")["fact_status"] == "В работе" and mirror.get_note(conn, "new:7") is None
|
||
again = queue.report_result(conn, c["id"], "done", result={"key": "A-21"})
|
||
assert again["result"] == {"key": "A-20", "created": True} # второй поздний отчёт ничего не меняет
|
||
|
||
|
||
def test_late_failed_report_after_force_cancel_changes_nothing():
|
||
conn = fresh()
|
||
queue.create_batch(conn, "x", "claude", [
|
||
{"type": "ensure_issue", "params": {"temp_key": "new:7", "issue_type": "task", "summary": "Тема"}}])
|
||
c = queue.claim(conn)
|
||
queue.cancel_command(conn, c["id"], force=True)
|
||
late = queue.report_result(conn, c["id"], "failed", error="HTTP 400")
|
||
assert late["status"] == "cancelled" and late["result"] is None and late["error"] is None
|
||
```
|
||
|
||
`tests/test_commands.py` — в параметры `test_validate_errors` (список `bad, msg`) добавить случай; если тест
|
||
параметризован другим способом, добавить отдельный тест:
|
||
|
||
```python
|
||
def test_validate_rejects_duplicate_issue_summary():
|
||
cmds = [{"type": "ensure_issue", "params": {"temp_key": "new:1", "issue_type": "task", "summary": "Отчёт"}},
|
||
{"type": "ensure_issue", "params": {"temp_key": "new:2", "issue_type": "task", "summary": " Отчёт "}},
|
||
{"type": "ensure_issue", "params": {"temp_key": "new:3", "issue_type": "task", "summary": "отчёт"}}]
|
||
with pytest.raises(commands.CommandError) as e:
|
||
commands.validate(cmds)
|
||
assert "повторяется тема ensure_issue: «Отчёт»" in str(e.value)
|
||
commands.validate([cmds[0], cmds[2]]) # регистр различается — пакет допустим
|
||
```
|
||
|
||
(`import pytest` и `from jira_hub import commands` в файле уже есть; если нет — добавить.)
|
||
|
||
`tests/test_api.py`:
|
||
|
||
```python
|
||
def test_result_for_queued_command_is_409(hub):
|
||
b = hub["client"].post("/batches", {"title": "x", "commands": [{"type": "ensure_fields", "params": {"key": "A-1", "duedate": "2026-10-23"}}]})
|
||
cid = hub["client"].get(f"/batches/{b['id']}")["commands"][0]["id"]
|
||
with pytest.raises(HubError) as e:
|
||
hub["agent"].post(f"/agent/commands/{cid}/result", {"status": "done"})
|
||
assert e.value.status == 409 and e.value.error == "not_claimed"
|
||
|
||
|
||
def test_duplicate_summary_batch_is_422(hub):
|
||
with pytest.raises(HubError) as e:
|
||
hub["client"].post("/batches", {"title": "x", "commands": [
|
||
{"type": "ensure_issue", "params": {"temp_key": "new:1", "issue_type": "task", "summary": "Шахматка: комментарии"}},
|
||
{"type": "ensure_issue", "params": {"temp_key": "new:2", "issue_type": "task", "summary": "Шахматка: комментарии"}}]})
|
||
assert e.value.status == 422 and "Шахматка: комментарии" in e.value.detail
|
||
```
|
||
|
||
- [ ] **Step 2: Run tests to verify they fail**
|
||
|
||
Run: `uv run pytest tests/test_queue.py tests/test_commands.py tests/test_api.py -q`
|
||
Expected: FAIL — нет `NotClaimedError`, отчёт по `queued` принят, поздний ключ потерян, дубль темы проходит.
|
||
|
||
- [ ] **Step 3: Implement**
|
||
|
||
`src/jira_hub/queue.py` — рядом с `ClaimedError`:
|
||
|
||
```python
|
||
class NotClaimedError(Exception):
|
||
"""Отчёт по команде, которую агенту не выдавали (status = queued) — API отвечает 409."""
|
||
```
|
||
|
||
В `report_result` после `if cmd is None: raise KeyError(command_id)`:
|
||
|
||
```python
|
||
if cmd["status"] == "queued":
|
||
raise NotClaimedError(f"команда {command_id} не выдана")
|
||
if cmd["status"] in TERMINAL:
|
||
# поздний отчёт о созданной задаче по отменённой команде: ключ не теряем, статус не трогаем (M-5)
|
||
if (cmd["status"] == "cancelled" and cmd["type"] == "ensure_issue" and status == "done"
|
||
and result and result.get("key") and not cmd["result"]):
|
||
conn.execute("UPDATE command SET result = ?, jira_calls = ?, rate_limited = ? WHERE id = ?",
|
||
(_dump(result), int(jira_calls or 0), int(rate_limited or 0), command_id))
|
||
mirror.rename_note(conn, cmd["params"]["temp_key"], result["key"])
|
||
log.warning("команда %s отменена, но агент создал %s — ключ записан в результат", command_id, result["key"])
|
||
return get_command(conn, command_id)
|
||
return cmd # идемпотентно; cancelled не затирается
|
||
```
|
||
|
||
(прежняя строка `if cmd["status"] in TERMINAL: return cmd` заменяется этим блоком.)
|
||
|
||
`src/jira_hub/api.py::h_agent_result` — добавить ветку до `except ValueError`:
|
||
|
||
```python
|
||
except queue.NotClaimedError as e:
|
||
raise ApiError(409, "not_claimed", str(e))
|
||
```
|
||
|
||
`src/jira_hub/commands.py::validate` — перед `return out`:
|
||
|
||
```python
|
||
summaries = [c["params"]["summary"].strip() for c in out if c["type"] == "ensure_issue"]
|
||
repeated = sorted({s for s in summaries if summaries.count(s) > 1})
|
||
if repeated:
|
||
raise CommandError("повторяется тема ensure_issue: " + ", ".join(f"«{s}»" for s in repeated)
|
||
+ " — в Jira получится одна задача на два временных ключа")
|
||
```
|
||
|
||
- [ ] **Step 4: Run tests**
|
||
|
||
Run: `uv run pytest -q` — весь набор зелёный.
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git -C /Users/andrey.epifancev/projects/awp-ca/jira-hub/.wt/reliability add -A src tests
|
||
git -C /Users/andrey.epifancev/projects/awp-ca/jira-hub/.wt/reliability commit -m "feat(queue): 409 на отчёт по невыданной команде, ключ из позднего отчёта по отменённой ensure_issue, 422 на дубль темы (#9)
|
||
|
||
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 4: `ensure_issue` не подтверждается по состоянию; `reversed_links` в отчёте импорта
|
||
|
||
**Files:**
|
||
- Modify: `src/jira_hub/commands.py` (`check_confirmed`)
|
||
- Modify: `src/jira_hub/queue.py` (`reconcile`)
|
||
- Modify: `src/jira_hub/importer.py` (`_import`, docstring модуля при необходимости)
|
||
- Modify: `README.md` (описание отчёта `import`)
|
||
- Test: `tests/test_commands.py`, `tests/test_queue.py`, `tests/test_importer.py`
|
||
|
||
**Interfaces:**
|
||
- Produces: `commands.check_confirmed(conn, cmd, link_types) -> tuple[bool, dict | None]` (без `reporter`); отчёт
|
||
импорта `{notes, expected_links, missing_keys, missing_links, reversed_links}`.
|
||
|
||
- [ ] **Step 1: Write the failing tests**
|
||
|
||
`tests/test_commands.py`: удалить `test_check_confirmed_issue_by_summary`, `test_ensure_issue_without_reporter_never_confirmed`,
|
||
`test_ensure_issue_older_than_7_days_not_confirmed`, `test_ensure_issue_reporter_filter`,
|
||
`test_ensure_issue_two_matches_takes_newest`; добавить:
|
||
|
||
```python
|
||
def test_ensure_issue_never_confirmed_by_state():
|
||
"""bridge-reliability, решение 4: потерянный отчёт ensure_issue закрывается довыдачей, не сверкой с зеркалом."""
|
||
conn = _mirror()
|
||
conn.execute(f"UPDATE issue SET created = {NOW} WHERE key = 'A-1'")
|
||
assert commands.check_confirmed(conn, _ensure_issue("Тема"), LT) == (False, None)
|
||
```
|
||
|
||
Проверить, что в параметрах `test_check_confirmed` нет случаев `ensure_issue` с ожиданием `True`; если есть — поменять
|
||
ожидание на `False`.
|
||
|
||
`tests/test_queue.py`: удалить `test_reconcile_respects_reporter_setting`; в
|
||
`test_reconcile_does_not_confirm_ensure_issue_without_reporter` убрать из docstring упоминание настройки (`"""ensure_issue
|
||
по состоянию не подтверждается: совпадение темы не закрывает команду, заметка new:N не переезжает."""`);
|
||
`test_reconcile_does_not_overwrite_finished_command` переписать на `ensure_sprint`:
|
||
|
||
```python
|
||
def test_reconcile_does_not_overwrite_finished_command(monkeypatch):
|
||
"""M-1: отчёт агента/отмена между check_confirmed и UPDATE не перезаписываются."""
|
||
conn = fresh()
|
||
queue.create_batch(conn, "x", "claude", [{"type": "ensure_sprint", "params": {"key": "A-1", "sprint": "Спринт 2"}}])
|
||
c = queue.claim(conn)
|
||
mirror.apply_state(conn, [{"key": "A-1", "summary": "т", "sprint": "Спринт 2", "labels": []}], [])
|
||
real = queue.C.check_confirmed
|
||
|
||
def racing(*a, **kw):
|
||
out = real(*a, **kw)
|
||
queue.cancel_command(conn, c["id"], force=True) # гонка: отмена после проверки
|
||
return out
|
||
|
||
monkeypatch.setattr(queue.C, "check_confirmed", racing)
|
||
assert queue.reconcile(conn) == []
|
||
assert queue.get_command(conn, c["id"])["status"] == "cancelled"
|
||
```
|
||
|
||
`tests/test_importer.py`:
|
||
|
||
```python
|
||
def test_reversed_link_reported_separately(tmp_path):
|
||
make_package(tmp_path)
|
||
write_csv(tmp_path / "links.csv", ["Откуда", "Тип", "Куда", "Пояснение (внутр.)"],
|
||
[["AURORA-1533", "связанные", "AURORA-1586", "в Jira стоит наоборот"],
|
||
["AURORA-1533", "блокирует начало", "AURORA-1416", "нет совсем"]])
|
||
conn = db.connect(":memory:")
|
||
settings.ensure_defaults(conn)
|
||
settings.set_(conn, "link_types", {"блокирует начало": "ASUPR_Блокер_Начала", "связанные": "ASUPR_Связанные"})
|
||
mirror.apply_state(conn, [{"key": "AURORA-1533", "summary": "т", "labels": []}, {"key": "AURORA-1586", "summary": "т", "labels": []}],
|
||
[{"source_key": "AURORA-1586", "target_key": "AURORA-1533", "link_type": "ASUPR_Связанные"}])
|
||
rep = importer.import_package(conn, tmp_path)
|
||
assert rep["reversed_links"] == [{"source": "AURORA-1533", "target": "AURORA-1586", "link_type": "ASUPR_Связанные"}]
|
||
assert rep["missing_links"] == [{"source": "AURORA-1533", "target": "AURORA-1416", "link_type": "ASUPR_Блокер_Начала"}]
|
||
```
|
||
|
||
В `test_import_notes_and_report` добавить `assert rep["reversed_links"] == []`; в `test_missing_csv_files_give_empty_report`
|
||
ожидаемый словарь дополнить `"reversed_links": []`.
|
||
|
||
- [ ] **Step 2: Run tests to verify they fail**
|
||
|
||
Run: `uv run pytest tests/test_commands.py tests/test_queue.py tests/test_importer.py -q`
|
||
Expected: FAIL в `test_reversed_link_reported_separately` и проверках `reversed_links` (ключа нет).
|
||
`test_ensure_issue_never_confirmed_by_state` может пройти уже сейчас (без `reporter` подтверждения и так нет) — это
|
||
закрепляющий тест, он должен остаться зелёным после удаления ветки.
|
||
|
||
- [ ] **Step 3: Implement**
|
||
|
||
`src/jira_hub/commands.py::check_confirmed`:
|
||
|
||
```python
|
||
def check_confirmed(conn, cmd, link_types: dict) -> tuple[bool, dict | None]:
|
||
"""Виден ли желаемый результат в зеркале. ensure_issue, ensure_comment и refresh по состоянию не подтверждаются:
|
||
потерянный отчёт ensure_issue закрывается довыдачей — агент находит свою задачу поиском дубля (bridge-reliability,
|
||
решение 4); совпадение темы с задачей неизвестного автора не доказательство."""
|
||
ctype, p = cmd["type"], cmd["params"]
|
||
if ctype in ("ensure_issue", "ensure_comment", "refresh"):
|
||
return False, None
|
||
issue = mirror.get_issue(conn, p.get("key") or p.get("source"))
|
||
# дальше без изменений
|
||
```
|
||
|
||
(ветка `if ctype == "ensure_issue": …` удаляется целиком.)
|
||
|
||
`src/jira_hub/queue.py::reconcile` — удалить строки с `reporter = settings.get(conn, "reporter")` и комментарием-продолжением;
|
||
вызов: `ok, result = C.check_confirmed(conn, cmd, link_types)`. Ветку `if cmd["type"] == "ensure_issue" and result:
|
||
mirror.rename_note(...)` удалить (ensure_issue больше не подтверждается).
|
||
|
||
`src/jira_hub/importer.py` — в `_import` блок связей:
|
||
|
||
```python
|
||
link_types = settings.get(conn, "link_types") or {}
|
||
expected, missing_links, reversed_links = [], [], []
|
||
for r in _rows(folder / "links.csv"):
|
||
src = new_keys.get(_clean(r.get("Откуда")) or "", _clean(r.get("Откуда")))
|
||
dst = new_keys.get(_clean(r.get("Куда")) or "", _clean(r.get("Куда")))
|
||
kind = (_clean(r.get("Тип")) or "").lower()
|
||
if not src or not dst or src.startswith("new:") or dst.startswith("new:"):
|
||
continue
|
||
link = {"source": src, "target": dst, "link_type": link_types.get(kind, kind)}
|
||
expected.append(link)
|
||
issue = mirror.get_issue(conn, src)
|
||
if issue and any(l["target_key"] == dst and l["link_type"] == link["link_type"] for l in issue["links_out"]):
|
||
continue
|
||
if issue and any(l["source_key"] == dst and l["link_type"] == link["link_type"] for l in issue["links_in"]):
|
||
reversed_links.append(link) # связь есть, но в Jira стоит в обратную сторону (O-3)
|
||
else:
|
||
missing_links.append(link)
|
||
```
|
||
|
||
и в `return` добавить `"reversed_links": reversed_links`.
|
||
|
||
`README.md` — в абзаце про `jira-hub import` после «`missing_links` (ожидаемые связи, которых нет)» дописать:
|
||
`, \`reversed_links\` (ожидаемые связи, которые в Jira стоят в обратную сторону — для «Связанных» это та же связь)`.
|
||
|
||
- [ ] **Step 4: Run tests**
|
||
|
||
Run: `uv run pytest -q` — весь набор зелёный. Затем `grep -rn "reporter" src/jira_hub/queue.py src/jira_hub/commands.py` —
|
||
пусто.
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git -C /Users/andrey.epifancev/projects/awp-ca/jira-hub/.wt/reliability add -A src tests README.md
|
||
git -C /Users/andrey.epifancev/projects/awp-ca/jira-hub/.wt/reliability commit -m "feat: ensure_issue закрывается довыдачей, не сверкой; reversed_links в отчёте импорта (R-11, O-3, #9)
|
||
|
||
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|