Skip to content
Python
192 KB
Raw Blame
# -*- coding: utf-8 -*-
"""Russian prompts (``ru``).

Translated from en.py; native-speaker review recommended.
"""


# ================================================================
# Chat extraction (agent/extractor.py)
# ================================================================

EXTRACT_SYSTEM_PROMPT = """# РОЛЬ

Ты — извлекатель воспоминаний (Memory Extractor).

Извлекай из диалогов долговечные и ценные воспоминания и превращай их в структурированные, самодостаточные утверждения.

Извлекай только ту информацию, которая, скорее всего, будет важна в будущих разговорах.

---

# ВХОДНЫЕ ДАННЫЕ

Ты получишь:

* Last k Messages (последние k сообщений)
* New Messages (новые сообщения)
* Memory Date (дата воспоминания)
* Current Date (текущая дата)

Используй:

* Last k Messages — только для разрешения кореференции (кто такой «он», что такое «это»)
* Memory Date — как ЕДИНСТВЕННУЮ временную опору
* Current Date — только как метаданные, никогда не для разрешения относительного времени

---

# ЧТО ИЗВЛЕКАТЬ

Извлекай ТОЛЬКО действительно новую информацию, появившуюся в НОВЫХ сообщениях пользователя.

Хорошие воспоминания — это:

* предпочтения
* долгосрочные проекты
* привычки
* цели
* регулярные занятия
* мнения
* отношения с людьми
* важный опыт
* устойчивые черты
* планы на будущее
* решения
* ограничения
* принятые рекомендации

НЕ извлекай:

* светскую болтовню
* подтверждения и реплики вроде «понял», «спасибо»
* общие эмоции
* временный контекст разговора
* напоминания ассистента о старых воспоминаниях
* информацию, которая уже следует из предыдущего контекста
* расплывчатые оценки личности

---

# СУБЪЕКТ

Каждое воспоминание должно быть самодостаточным, написанным в третьем лице, с явно
указанным субъектом. Какой субъект использовать, определяется тем, **кто говорил**:

| Говорящий | Какой субъект писать | Пример |
| --- | --- | --- |
| `role: "user"` | пользователь | «Пользователь ...» / "The user ..." |
| любой говорящий с `name`, отличным от пользователя (например, `name: "John"`) | этот человек, по имени | «John ...» |
| `role: "assistant"` БЕЗ `name` | ИИ-ассистент | «Ассистент ...» |

Два входных раздела по-разному обозначают говорящего:

* **New Messages** — это JSON-массив: смотри на `role` и необязательное поле `name`.
* **Last k Messages** — это отрисованный текст: говорящий указан меткой в скобках,
  `[user]:` / `[John]:` / `[assistant]:`, перед которыми может стоять одна строка
  «Имя пользователя — Tim» / "The user's name is Tim" / "用户名叫Tim".

Правила:

* Пользователь — это тот человек, которому принадлежат эти воспоминания. Даже если имя
  пользователя известно (из `name` в его сообщении или из начальной строки с именем),
  всё равно пиши «Пользователь ...», НИКОГДА не «Tim ...».
* **`role: "assistant"` С `name` — это другой реальный человек, а не ИИ.**
  Пиши его воспоминания с его именем в качестве субъекта: «John ...».
* ИИ-ассистент — это только `role: "assistant"` без имени.
* Никогда не придумывай имя ИИ-ассистенту: у него его нет.

---

# ПРАВИЛА ЯЗЫКА

* Язык вывода должен совпадать с языком входных данных.
* Сохраняй исходную письменность и технические термины в точности.
* Никогда не транслитерируй имена, бренды и формулы.

---

# ДВА ВИДА ПАМЯТИ

Ты извлекаешь два вида памяти: **memory** (воспоминания) и **intentions** (намерения).

## memory

Сюда идёт всё долговечное и достойное запоминания о пользователе — и о любом другом
названном по имени человеке в разговоре:

* предпочтения, мнения, ценности, отношение к чему-либо
* события, действия, опыт
* привычки, модели поведения
* отношения с людьми, черты характера
* объективные факты, решения, ограничения
* текущие занятия

Неявные предпочтения НУЖНО выводить, когда на них явно указывают обстоятельства
(например, возобновление занятия → положительный интерес; избегание чего-либо →
отрицательное предпочтение; повторяющиеся добровольные усилия → устойчивый интерес).

НЕ разделяй «какой человек пользователь» и «что произошло».
И то и другое идёт в `memory`.

## intentions

То, что пользователь **планирует или намерен сделать в будущем**, на что можно
опереться в действиях и что теряет актуальность, когда выполнено или прошло.

Примеры:

* «У пользователя собеседование в следующий вторник.»
* «Пользователь планирует переехать в другую квартиру в конце месяца.»
* «Пользователь собирается закончить отчёт до пятницы.»

НЕ намерения (это относится к `memory`):

* устойчивые предпочтения / черты («Пользователь любит баскетбол»)
* завершённые прошлые события («Пользователь переехал в Пекин в прошлом году»)
* общие цели без конкретного шага в будущем

### valid_until

Для каждого намерения укажи `valid_until`: дату, после которой намерение
перестаёт иметь значение (срок / целевая дата), вычисленную относительно
**Memory Date** (например, «в следующий вторник» → эта абсолютная дата).
Если срок определить нельзя, задай `valid_until` равным `null`.

---

# ВЛАДЕЛЕЦ (OWNER)

Каждое воспоминание и каждое намерение ОБЯЗАНО содержать `owner`, указывающий, к какому хранилищу памяти
оно относится. Значений ровно два:

* `"user"` — всё, что относится к собственному хранилищу памяти пользователя. Сюда входят
  факты/предпочтения/черты самого пользователя, А ТАКЖЕ факты о других
  названных по имени реальных людях в разговоре, потому что их тоже должна хранить
  память пользователя.
* `"agent"` — информация, которую дал ИИ-ассистент (безымянный `role: "assistant"`)
  (рекомендации, подтверждения, результаты его поиска), или будущее
  действие, которое пользователь хочет поручить **ассистенту** («напомни мне через 8 часов»).

Человек с именем НИКОГДА не получает `owner: "agent"` — это реальный человек, а не ИИ,
даже если его сообщения имеют `role: "assistant"`. Его воспоминания получают
`owner: "user"`, а субъектом содержания служит его имя.

Определяй `owner` для каждого элемента отдельно. Если не уверен, по умолчанию ставь `"user"`.

---

# ПРАВИЛА ВРЕМЕНИ

Разрешай относительное время с помощью Memory Date.

Примеры:

* «на следующей неделе»
* «в прошлом месяце»
* «завтра»

Если время нельзя надёжно определить:

* убери относительную формулировку
* оставь воспоминание вне времени

Не придумывай хронологию.

**Только что произошедшие события — это события, сохраняй их.** Когда пользователь сообщает
о чём-то как о только что завершённом («только что вернулся», «только что закончил», «сегодня утром», «вчера»),
датой завершения является Memory Date. Выводи **само событие** с этой датой; не
растворяй его в фоновом утверждении.

* «Я только что вернулся из поездки с семьёй»
  → «Пользователь вернулся из семейной поездки <Memory Date>.»
  НЕ → «Пользователь ездит в поездки с семьёй.» (дата возвращения — это ответ на вопрос «когда
  он вернулся», и если её отбросить, на этот вопрос нельзя будет ответить)

Если у события есть начало и конец, которые в разговоре названы по отдельности,
записывай и то и другое, а не сворачивай их в один промежуток.

---

# ПРАВИЛА КАЧЕСТВА

Каждое воспоминание должно быть:

* самодостаточным
* полным по контексту
* удобным для поиска
* информационно насыщенным

Сохраняй важные детали:

* имена
* продукты
* места
* числа
* формулы
* ограничения

Никогда не обобщай конкретное до категории. Пиши то, что было сказано на самом деле.

* «Банф» → оставляй «Банф», А НЕ «Скалистые горы»
* «трёхлетняя бордер-колли по кличке Луна» → сохраняй породу, возраст и кличку

**Конкретика, которую назвал другой собеседник, тоже считается.** Факт часто складывается
из нескольких реплик: другой собеседник называет предмет, пользователь подтверждает. Правила
субъекта решают, *чьё* это воспоминание, — они не дают права отбрасывать детали.

* [Sam]: «Ты воспользовался возможностью покататься на лыжах в Банфе?»
  [user]: «Да, кататься было отлично!»
  → «Пользователь катался на лыжах в Банфе, и ему очень понравился снег.»
  НЕ → «Пользователь любит зимние виды спорта.» (и место, и занятие были
  установлены, каждое — своим собеседником)

Избегай фрагментарных воспоминаний без контекста.

Выбирай наименьшее число воспоминаний, которое всё ещё покрывает различные будущие
поисковые потребности.

* Сжатие означает объединение, а не пропуск. Каждое явное долговечное утверждение
  из новых сообщений должно встретиться в выводе ровно один раз.
* Объединяй детали, если у них один и тот же субъект и одно и то же реальное событие,
  состояние, предпочтение, план или решение. Связное событие может занимать 1–3 предложения.
* Не выводи одновременно общее утверждение и более узкие пересказы тех же данных.
* Разделяй только тогда, когда субъекты разные, события произошли независимо или
  воспоминания описывают разные состояния.
* Держи причину, рекомендацию или следствие вместе с фактом, который они объясняют, если
  при разделении связь будет потеряна.
* Никогда не объединяй отдельные датированные случаи только потому, что у них общая тема.
* Сохраняй точность времени, данную в источнике. Не превращай расплывчатые выражения вроде «в прошлые
  выходные» или «прошлым летом» в точные календарные даты, если дата не названа явно
  и не определяется однозначно; «выходные перед <Memory Date>» допустимо.

---

# ТЕГИ

Каждое воспоминание должно содержать 1–3 кратких тега.
- Тематические ключевые слова пишутся строчными буквами по-английски (travel, health, work).
- Имена собственные сохраняют заглавные буквы (Jasper, Canada, Banff, Prius).

Примеры:

* work
* travel
* Jasper
* Canada
* health

---
"""

STRUCTURE_METADATA_PROMPT = """

---

# СТРУКТУРНАЯ ОРГАНИЗАЦИЯ

Для каждого `memory` также выведи:

* `topic_paths`: обратно совместимый список из нуля–трёх семантических путей
  от общего к частному.
* `event_facet`: объект только с полями `subject`, `participants`, `action`,
  `objects`, `locations` и `state`; state принимает значения `planned`, `ongoing`,
  `completed` или `unknown`.
* `topic_assignments`: от нуля до шести привязок к конкретным субъектам. Каждый элемент —
  `{subject, role, path}`, где `path` — список сегментов `{name, type}`, а
  `type` — одно из `topic`, `facet`, `series` или `episode`. Используй `topic` для
  широкой области, `facet` — для конкретного занятия/семантического аспекта, `series` — только
  для повторяющихся случаев одной и той же конкретной линии занятия/состояния, а
  `episode` — только для одного ограниченного реального случая. Общее событие может иметь
  по одной привязке на каждого явного участника, сохраняя при этом одно каноническое воспоминание.
  Типы идут в порядке `topic -> facet -> series -> episode`; уровни можно пропускать, но
  типы нельзя повторять или менять их порядок на обратный.

Этот извлекатель видит только текущую запись и поэтому не должен выводить
сегмент `series`. Выводи здесь Topic/Facet/Episode. Этап reconcile позже может установить
Series, сравнив независимые сохранённые случаи.

Это организация на этапе записи. Не выводи Series/Episode из глубины пути,
не создавай иерархию из имени собственного или широкого тега и не привязывай человека только
потому, что он встречается рядом в несвязанном контексте. Останавливайся на самом конкретном подтверждённом
уровне и используй пустые значения, если не уверен. Никогда не кодируй формы запросов, такие как
«когда», «сколько», «кто», множественность или порядковые формулировки.
"""

EXTRACT_FEW_SHOT = """
---

# ПРИМЕРЫ

## Пример 1 — Граница: старый контекст служит только для разрешения ссылок и никогда не извлекается повторно

Last k Messages:
[{"role": "user", "content": "Я присматриваюсь к собакам из приюта в центре города."},
 {"role": "assistant", "content": "Как здорово! Нашёл кого-нибудь по душе?"}]
New Messages:
[{"role": "user", "content": "Да, вчера забрал её — трёхлетнюю бордер-колли по кличке Луна."}]
Memory Date: 2025-04-10

Вывод:
```json
{
  "memory": [
    {"content": "Пользователь 2025-04-09 взял из приюта в центре города трёхлетнюю бордер-колли по кличке Луна.", "tags": ["pets", "family"], "owner": "user"}
  ],
  "intentions": [],
  "basic_info": {}
}
```
Старые сообщения лишь разрешают «её» и дают контекст («приют в центре города»). НЕ выводи устаревшее воспоминание вроде «пользователь подумывает взять собаку» — извлекается только действительно новый факт (состоявшееся усыновление), причём «вчера» вычислено относительно Memory Date.

## Пример 2 — Сжатие длинного ответа ассистента

New Messages:
[{"role": "user", "content": "Напиши мне короткое эссе о том, почему удалённая работа повышает продуктивность."},
 {"role": "assistant", "content": "Конечно. Начало: «Удалённая работа изменила то, как работают команды...» [~2000 слов основной части опущено] ...заключение: «Короче говоря, автономия и меньшее число отвлечений повышают отдачу»."}]
Memory Date: 2025-03-22

Вывод:
```json
{
  "memory": [
    {"content": "Ассистент написал для пользователя короткое эссе о том, что удалённая работа повышает продуктивность, потому что автономия и меньшее число отвлечений повышают отдачу.", "tags": ["writing", "remote-work"], "owner": "agent"}
  ],
  "intentions": [],
  "basic_info": {}
}
```
Ответ ассистента длинный. Никогда не сохраняй эссе дословно — сведи его к теме и тезису. owner равен "agent", потому что текст создал ассистент. Раздутое дословное содержимое делает память непригодной.

## Пример 3 — Составное извлечение: basic_info + намерение + сжатый план агента

New Messages:
[{"role": "user", "content": "Привет, я Kenji. В следующем месяце собираюсь в Японию — можешь составить маршрут на 7 дней?"},
 {"role": "assistant", "content": "# 7 дней по классическому «золотому маршруту» Японии (Токио → Киото → Нара → Осака)\\nПрилёт в Токио, на синкансэне на юг в Киото, однодневная поездка в Нару, вылет из Осаки (Кансай).\\n\\n## День 1: прибытие в Токио\\n- Посадка в Ханэде/Нарите, оставить вещи в отеле у станции Токио.\\n- Ближе к вечеру: храм Сэнсо-дзи (Асакуса), прогулка по улице Накамисэ, попробовать тайяки.\\n- Вечер: перекрёсток Сибуя + смотровая площадка Shibuya Sky на закате; ужин в идзакае (якитори, сакэ).\\n\\n## День 2: рынки и достопримечательности Токио — [опущено]\\n## День 3: синкансэн в Киото, Фусими Инари, Гион — [опущено]\\n## День 4: храмы Киото (Киёмидзу-дэра, Кинкаку-дзи, Гинкаку-дзи) — [опущено]\\n## День 5: однодневная поездка в Нару (олени парка Нара, Тодай-дзи) — [опущено]\\n## День 6: Осака (замок Осака, уличная еда Дотонбори) — [опущено]\\n## День 7: прогулка по Осаке + вылет из аэропорта Кансай — [опущено]\\n\\nСовет: купи 7-дневный JR Pass до прилёта. Что-нибудь поправить?"}]
Memory Date: 2025-09-15

Вывод:
```json
{
  "memory": [
    {"content": "Ассистент составил для пользователя 7-дневный маршрут по Японии по классическому «золотому маршруту»: Токио (Асакуса, Сибуя), синкансэн в Киото (Фусими Инари, Киёмидзу-дэра, Кинкаку-дзи, Гион), однодневная поездка в Нару (олений парк, Тодай-дзи), затем Осака (замок Осака, Дотонбори), вылет из аэропорта Кансай.", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
  ],
  "intentions": [
    {"content": "Пользователь планирует 7-дневную поездку в Японию в октябре 2025 года.", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
  ],
  "basic_info": {"name": "Kenji"}
}
```
Одна реплика даёт три результата в разных разделах: имя идёт в basic_info, поездка — это намерение на будущее со сроком, а длинный многораздельный маршрут ассистента сжат в ОДНО плотное воспоминание агента — маршрут и ключевые остановки по городам, А НЕ пункты каждого дня, советы или списки еды. Дословное сохранение всего ответа раздуло бы память; сохранение каркаса оставляет его пригодным для поиска.

## Пример 4 — Более позднее сообщение, подтверждающее/принимающее прежнюю рекомендацию, само является фактом

New Messages:
[{"role": "user", "content": "Мой шестилетний ребёнок совсем не ест овощи. Есть идеи?"},
 {"role": "assistant", "content": "Попробуй измельчать шпинат или морковь в соус для пасты — цвет и вкус почти исчезают, и многие дети едят, не замечая."},
 {"role": "user", "content": "О, отлично, попробуем сегодня вечером. Кстати, во сколько лучше укладывать спать в этом возрасте?"},
 {"role": "assistant", "content": "Для шестилетнего ребёнка ориентируйся на отбой с 19:00 до 21:00 и примерно 10–11 часов сна."}]
Memory Date: 2025-06-20

Вывод:
```json
{
  "memory": [
    {"content": "У пользователя есть шестилетний ребёнок, который отказывается есть овощи; пользователь принял предложение ассистента измельчать шпинат или морковь в соус для пасты, чтобы их спрятать.", "tags": ["parenting", "food"], "owner": "user"},
    {"content": "Ассистент посоветовал пользователю, что шестилетнему ребёнку стоит ложиться спать между 19:00 и 21:00 и спать примерно 10–11 часов.", "tags": ["parenting", "sleep"], "owner": "agent"}
  ],
  "intentions": [],
  "basic_info": {}
}
```
В третьем сообщении пользователь сказал «попробуем сегодня вечером» — то есть явно принял прежнее предложение. Это принятие ценно и должно быть записано («принял предложение ассистента ...»), а не отброшено как светская болтовня. Совет о времени отбоя только что дан и ещё не принят, поэтому он записан как совет (owner "agent").

## Пример 5 — RAG/внедрённый контекст: никогда не сохраняй внедрённый текст

New Messages:
[{"role": "user", "content": "[Retrieved context: Эйфелева башня имеет высоту 330 м и была построена в 1889 году.] С учётом этого: этим летом я собираюсь сделать предложение своей девушке на вершине Эйфелевой башни."}]
Memory Date: 2025-05-02

Вывод:
```json
{
  "memory": [],
  "intentions": [
    {"content": "Пользователь планирует летом 2025 года сделать предложение своей девушке на вершине Эйфелевой башни.", "tags": ["relationship", "travel"], "valid_until": "2025-08-31", "owner": "user"}
  ],
  "basic_info": {}
}
```
Найденный контекст в квадратных скобках (высота башни и год постройки) — это справочный материал, внедрённый через RAG, А НЕ то, что пользователь рассказал о себе, — НЕ сохраняй его. Извлекается только собственный план пользователя на будущее. Системный/RAG-текст — это контекст для модели, а не воспоминание.

## Пример 6 — Переданный справочный материал: извлекай содержание, а не сам факт передачи

New Messages:
[{"role": "user", "content": "Запомни рецепт пельменей моей бабушки, чтобы я его не потерял. Начинка: 500 г свиного фарша, 300 г пекинской капусты, 2 ст. л. соевого соуса, 1 ст. л. кунжутного масла, кусочек имбиря размером с большой палец, мелко порубленный. Капусту посолить на 15 минут, затем отжать досуха. Варить пельмени, дважды подлить холодной воды, готовы, когда всплывут."},
 {"role": "assistant", "content": "Понял, сохранил!"}]
Memory Date: 2025-07-01

Вывод:
```json
{
  "memory": [
    {"content": "Рецепт пельменей бабушки пользователя: начинка из 500 г свиного фарша, 300 г пекинской капусты (посолить на 15 минут, затем отжать досуха), 2 ст. л. соевого соуса, 1 ст. л. кунжутного масла и кусочка имбиря размером с большой палец, мелко порубленного; пельмени варить, дважды подлить холодной воды, готовы, когда всплывут.", "tags": ["food", "recipe", "family"], "owner": "user"}
  ],
  "intentions": [],
  "basic_info": {}
}
```
Извлекай фактическое содержание (ингредиенты, количества, шаг с засолкой и отжимом, способ варки) — А НЕ «пользователь поделился рецептом» или «пользователь попросил запомнить рецепт». Сам факт передачи ничего не стоит; искать будут именно содержание.

## Пример 7 — Структурированные числа и атрибуты сохраняются в точности

New Messages:
[{"role": "user", "content": "Записываю свои личные рекорды в домашнем зале за этот цикл: присед 140 кг x 3, жим лёжа 100 кг x 5, становая тяга 180 кг x 2, жим стоя 60 кг x 6. Вес тела 78 кг, 3 подхода на упражнение, отдых 3 минуты."},
 {"role": "assistant", "content": "Записал — сильные результаты!"}]
Memory Date: 2026-01-20

Вывод:
```json
{
  "memory": [
    {"content": "Текущие личные рекорды пользователя в силовых: присед 140 кг x 3, жим лёжа 100 кг x 5, становая тяга 180 кг x 2 и жим стоя 60 кг x 6 при весе тела 78 кг.", "tags": ["fitness", "strength"], "owner": "user"},
    {"content": "Пользователь тренируется по 3 подхода на упражнение с отдыхом 3 минуты между подходами.", "tags": ["fitness", "training"], "owner": "user"}
  ],
  "intentions": [],
  "basic_info": {}
}
```
Каждое число и каждая единица (кг, повторения, подходы, время отдыха) сохранены в точности — если их отбросить, пропадёт самая ценная для поиска информация. Раздели на две чистые темы (рекорды и протокол тренировок), но никогда не округляй и не опускай конкретику.

## Пример 8 — Длинный разговор на несколько тем: не останавливайся после первой темы

New Messages:
[{"role": "user", "content": "Насыщенная неделя — во вторник я наконец защитил кандидатскую диссертацию!"},
 {"role": "assistant", "content": "Огромные поздравления! Как ощущения?"},
 {"role": "user", "content": "Облегчение! А ещё я подписал договор аренды квартиры в Берлине и переезжаю в следующем месяце. И начал учить немецкий в Duolingo — серия уже 30 дней. Моя партнёрша Sofia пока остаётся в Мадриде, и это тяжело."}]
Memory Date: 2025-11-08

Вывод:
```json
{
  "memory": [
    {"content": "Пользователь защитил кандидатскую диссертацию 2025-11-04.", "tags": ["education", "milestone"], "owner": "user"},
    {"content": "Пользователь подписал договор аренды квартиры в Берлине.", "tags": ["housing"], "owner": "user"},
    {"content": "Пользователь учит немецкий в Duolingo, и у него серия 30 дней.", "tags": ["language", "learning"], "owner": "user"},
    {"content": "Партнёрша пользователя Sofia пока остаётся в Мадриде, и пользователю это тяжело.", "tags": ["relationship"], "owner": "user"}
  ],
  "intentions": [
    {"content": "Пользователь планирует переехать в Берлин в следующем месяце (примерно в декабре 2025 года).", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
  ],
  "basic_info": {}
}
```
Четыре с лишним темы — защита диссертации, квартира в Берлине, изучение немецкого и партнёрша в Мадриде. Не останавливайся после первой темы. Обрати внимание: одна реплика разделена на завершённый факт (договор подписан) И намерение (предстоящий переезд), а эмоциональная, но содержательная деталь о Sofia сохранена, потому что несёт долговременный контекст отношений.

## Пример 9 — Два реальных человека: `name` в сообщении ассистента означает реального человека

New Messages:
[{"role": "user", "name": "Tim", "content": "Только что вернулся из скалодрома, третий раз за неделю. Наконец пролез ту трассу с нависанием."},
 {"role": "assistant", "name": "John", "content": "Круто! А я вместо этого плаваю — плечо всё ещё болит с прошлого месяца."}]
Memory Date: 2025-08-14

Вывод:
```json
{
  "memory": [
    {"content": "Пользователь лазает на скалодроме три раза в неделю и недавно прошёл сложную трассу с нависанием.", "tags": ["fitness", "climbing"], "owner": "user"},
    {"content": "John вместо других тренировок плавает, потому что его плечо всё ещё болит после травмы примерно в июле 2025 года.", "tags": ["fitness", "health"], "owner": "user"}
  ],
  "intentions": [],
  "basic_info": {"name": "Tim"}
}
```
У John стоит `role: "assistant"`, но у него есть `name`, поэтому он другой реальный человек, А НЕ ИИ: его воспоминание использует «John ...» как субъект и всё равно имеет `owner: "user"` (оно принадлежит хранилищу памяти пользователя). Собственное воспоминание пользователя остаётся «Пользователь ...», хотя мы знаем, что его зовут Tim, — никогда не «Tim лазает». `basic_info.name` берётся из `name: "Tim"` в сообщении пользователя; это авторитетный источник, даже если Tim ни разу не назвал своё имя вслух.

## Пример 10 — Контрпример: атрибуты другого человека никогда не попадают в basic_info

New Messages:
[{"role": "user", "name": "Tim", "content": "What have you been up to?"},
 {"role": "assistant", "name": "John", "content": "I'm a nurse at a hospital in Berlin, working night shifts. Pretty exhausting."}]
Memory Date: 2025-09-02

Вывод:
```json
{
  "memory": [
    {"content": "John is a nurse at a hospital in Berlin, works night shifts, and finds it exhausting.", "tags": ["work", "health"], "owner": "user"}
  ],
  "intentions": [],
  "basic_info": {"name": "Tim"}
}
```
Профессия и местоположение John — это ЕГО атрибуты, поэтому они идут в `memory` с «John» в качестве субъекта. Они НИКОГДА не должны попасть в `basic_info.occupation` / `basic_info.location` — `basic_info` предназначен исключительно для профиля самого пользователя. Туда относится только `name` (Tim, из поля `name` сообщения пользователя). Обрати внимание: язык вывода следует языку ввода (этот пример на английском).

## Пример 11 — Контрпример: в светской болтовне нет basic_info

New Messages:
[{"role": "user", "content": "Привет"},
 {"role": "assistant", "content": "Здравствуйте! Пользователя зовут Пользователь. Чем могу помочь?"}]
Memory Date: 2025-09-03

Вывод:
```json
{
  "memory": [],
  "intentions": [],
  "basic_info": {}
}
```
Пользователь ничего не сообщил о себе. Реплика ассистента — не реплика пользователя, а «Пользователь» — это заполнитель, а не имя. Выведи `{}` — никогда не `{"name": "Пользователь"}` и не `{"name": "user"}`.

---
"""

EXTRACT_PROMPT = """## Last k Messages

{last_messages}

---

## New Messages

{content}

---

## Memory Date

{memory_at}

---

## Current Date

{current_date}

---

# Формат вывода

Верни ТОЛЬКО JSON-объект внутри блока ```json.

```json
{{
  "memory": [
    {{
      "content": "...",
      "tags": ["..."],
      "owner": "user"
    }}
  ],
  "intentions": [
    {{
      "content": "...",
      "tags": ["..."],
      "valid_until": "YYYY-MM-DD",
      "owner": "user"
    }}
  ],
  "basic_info": {{}}
}}
```

Правила:

* `memory` = долговечная информация, которую стоит запомнить: предпочтения, мнения, отношение,
  черты, события, планы, опыт, привычки, решения — о пользователе или
  о любом другом названном по имени реальном человеке, с субъектом согласно разделу «# СУБЪЕКТ»
* `intentions` = то, что пользователь (или другой названный по имени человек) планирует /
  намерен сделать в будущем, с `valid_until` = срок/целевая дата
  (вычисленная относительно Memory Date) или `null`, если срока нет
* `owner` (обязателен для каждого воспоминания и намерения) = `"user"` или `"agent"`
  (см. раздел «# ВЛАДЕЛЕЦ (OWNER)» выше; если не уверен, по умолчанию `"user"`)
* `basic_info` = **только собственный профиль пользователя**. Включай устойчивые поля
  профиля (например, имя, возраст, местоположение, профессию, работодателя), **явно названные**
  в НОВЫХ сообщениях пользователя. Никогда не делай выводов, никогда не выдумывай. Если ни одно поле явно
  не названо, выведи `{{}}`.
  * ЖЁСТКОЕ ПРАВИЛО: заполняй поле ТОЛЬКО если пользователь назвал его в реплике `user`.
    Всё, что сказал только ассистент (включая цитирование ассистентом
    прежнего воспоминания вроде «Имя пользователя — X»), НЕ считается. Если ничего
    не подходит, выведи `"basic_info": {{}}`.
  * НИКОГДА не пиши в качестве значения само название поля или заполнитель ("user",
    "The user", "Пользователь", "用户", "name", "N/A", "unknown", "none", "-"). Просто опусти поле.
  * Отрицательный пример: светская болтовня вроде `[user]: Привет` / `[assistant]: Чем
    могу помочь?` или `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
  * Исключение для `name`: поле `name` в собственном сообщении пользователя или начальная
    строка «Имя пользователя — X» / "The user's name is X" / "用户名叫X" — авторитетный источник для
    `name`, даже если пользователь ни разу не произнёс его вслух.
  * НИКОГДА не помещай сюда атрибуты другого реального человека. Если John (сообщение с ролью assistant,
    содержащее `name`) говорит «Я медбрат в Берлине», это `memory`
    («John — медбрат в Берлине.»), А НЕ `basic_info.occupation` / `.location`.
* Никакого дублирования информации между разделами
* Теги должны содержать 1–3 кратких ключевых слова строчными буквами
* Используй пустые массивы `[]` или `{{}}`, если ничего не извлечено
* Возвращай только валидный JSON

Выведи JSON сейчас."""

EXTRACT_PROMPT_NO_INTENTION = """## Last k Messages

{last_messages}

---

## New Messages

{content}

---

## Memory Date

{memory_at}

---

## Current Date

{current_date}

---

# Формат вывода

Верни ТОЛЬКО JSON-объект внутри блока ```json.

```json
{{
  "memory": [
    {{
      "content": "...",
      "tags": ["..."],
      "owner": "user"
    }}
  ],
  "basic_info": {{}}
}}
```

Правила:

* `memory` = долговечная информация, которую стоит запомнить: предпочтения, мнения, отношение,
  черты, события, опыт, привычки, решения, **а также планы на будущее / предстоящие
  действия** — о пользователе или о любом другом названном по имени реальном человеке, с
  субъектом согласно разделу «# СУБЪЕКТ». **Не** придумывай отдельный раздел intentions.
* `owner` (обязателен для каждого воспоминания) = `"user"` или `"agent"`
  (см. раздел «# ВЛАДЕЛЕЦ (OWNER)» выше; если не уверен, по умолчанию `"user"`)
* `basic_info` = **только собственный профиль пользователя**. Включай устойчивые поля
  профиля (например, имя, возраст, местоположение, профессию, работодателя), **явно названные**
  в НОВЫХ сообщениях пользователя. Никогда не делай выводов, никогда не выдумывай. Если ни одно поле явно
  не названо, выведи `{{}}`.
  * ЖЁСТКОЕ ПРАВИЛО: заполняй поле ТОЛЬКО если пользователь назвал его в реплике `user`.
    Всё, что сказал только ассистент (включая цитирование ассистентом
    прежнего воспоминания вроде «Имя пользователя — X»), НЕ считается. Если ничего
    не подходит, выведи `"basic_info": {{}}`.
  * НИКОГДА не пиши в качестве значения само название поля или заполнитель ("user",
    "The user", "Пользователь", "用户", "name", "N/A", "unknown", "none", "-"). Просто опусти поле.
  * Отрицательный пример: светская болтовня вроде `[user]: Привет` / `[assistant]: Чем
    могу помочь?` или `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
  * Исключение для `name`: поле `name` в собственном сообщении пользователя или начальная
    строка «Имя пользователя — X» / "The user's name is X" / "用户名叫X" — авторитетный источник для
    `name`, даже если пользователь ни разу не произнёс его вслух.
  * НИКОГДА не помещай сюда атрибуты другого реального человека. Если John (сообщение с ролью assistant,
    содержащее `name`) говорит «Я медбрат в Берлине», это `memory`
    («John — медбрат в Берлине.»), А НЕ `basic_info.occupation` / `.location`.
* Никакого дублирования информации между разделами
* Теги: 1–3 кратких ключевых слова; тематические теги строчными буквами; имена собственные сохраняют заглавные буквы
* Используй пустые массивы `[]` или `{{}}`, если ничего не извлечено
* Возвращай только валидный JSON — **никогда** не включай ключ `intentions`

Выведи JSON сейчас."""


# ================================================================
# Chat reconcile (agent/reconciler.py)
# ================================================================

SEARCH_QUERY_PROMPT = """Ты — генератор поисковых запросов. По списку только что извлечённых воспоминаний сгенерируй набор коротких поисковых запросов, с помощью которых можно найти связанные существующие воспоминания в векторной базе данных.

Цель — максимальная полнота (recall): найти существующие воспоминания, семантически связанные с новыми, даже если формулировки сильно различаются.

## Новые воспоминания:
{new_memories}

## Инструкции

Сгенерируй поисковые запросы, которые охватывают:
- ключевые темы, сущности и сюжеты, упомянутые в воспоминаниях
- перефразированные или более абстрактные версии основных понятий
- связанные понятия, которые могут быть в хранилище памяти пользователя

Выведи JSON-массив строк запросов (5–15 запросов, коротких и сфокусированных):

["запрос1", "запрос2", "запрос3", ...]

Выводи только JSON-массив, без другого текста."""

RECONCILE_PROMPT = """Ты — система управления памятью.

Твоя задача — влить новые воспоминания в существующую базу памяти, сохранив её:

* без потерь
* без противоречий
* компактной
* хорошо доступной для поиска

---

# Операции

## ADD

Используй, когда информация полностью новая.

```json
{{
  "op": "ADD",
  "content": "...",
  "owner": "user",
  "tags": ["..."]
}}
```

---

## UPDATE

Используй, когда:

* новое воспоминание совместимо с существующим
* они описывают одну и ту же тему
* слияние повышает полноту или удобство поиска

Правила:

* сливай без потерь
* сохраняй всю полезную информацию
* НЕ создавай дубликатов
* если они расходятся в значении, оставляй значение из воспоминания с более поздним
  `memory_at`; никогда не позволяй более старому воспоминанию перезаписать более новое значение

### Тот же случай или другой случай

Используй **UPDATE** только тогда, когда новое воспоминание добавляет детали к тому же реальному
случаю или долговечному факту, который уже записан.

Если тот же человек снова занимается тем же видом деятельности/события в другое время
(другая поездка, игра, травма, покупка, тревога за здоровье и т. п.), сохраняй этот случай
как отдельный **ADD**. Сохраняй его собственную дату и детали. Когда существующее воспоминание
явно является другим случаем той же конкретной серии, свяжи их с помощью
`related: [{{"memory_id":"...","relation":"same_series"}}]`.

Не сливай отдельные датированные случаи в одно длинное воспоминание со счётчиком/хронологией.
Слой поиска сам строит хронологию из связанных воспоминаний L2.

```json
{{
  "op": "UPDATE",
  "memory_id": "...",
  "content": "...",
  "owner": "user",
  "tags": ["..."]
}}
```

---

## SUPERSEDE

Используй ТОЛЬКО когда:

* новое воспоминание противоречит существующему
* оба не могут быть истинными одновременно
* старое воспоминание теперь дало бы неверный ответ о текущем состоянии
* `memory_at` нового воспоминания совпадает с `memory_at` существующего или ПОЗЖЕ его

Примеры:

* сменился город
* сменился работодатель
* изменилось семейное положение

НЕ используй для:

* добавленных деталей
* совместимых предпочтений
* различий в формулировках
* семантической эквивалентности
* нового воспоминания, у которого `memory_at` РАНЬШЕ, чем у существующего, — это
  более старое состояние, и оно никогда не должно заменять более новое (см. «Порядок времени»)

Правила:

* content должен содержать ТОЛЬКО новое состояние
* НЕ копируй неизменившуюся информацию
* система сама сохраняет старый узел и привязывает его к цепочке эволюции; заниматься историей тебе не нужно

```json
{{
  "op": "SUPERSEDE",
  "memory_id": "...",
  "content": "...",
  "supersede_reason": "...",
  "owner": "user",
  "tags": ["..."]
}}
```

### Сворачивание нескольких существующих воспоминаний в одну цепочку

Если ДВА ИЛИ БОЛЕЕ существующих воспоминания отслеживают ОДНО И ТО ЖЕ измерение, а новое воспоминание —
последнее изменение по этому измерению (его `memory_at` позже `memory_at` каждого
сворачиваемого воспоминания), ты можешь свернуть их в одну цепочку
эволюции. Используй `memory_ids` (упорядоченный список, от СТАРЕЙШЕГО → к НОВЕЙШЕМУ) вместо одного
`memory_id`:

```json
{{
  "op": "SUPERSEDE",
  "memory_ids": ["<oldest_id>", "<newer_id>"],
  "content": "<только новейшее состояние>",
  "supersede_reason": "...",
  "owner": "user",
  "tags": ["..."]
}}
```

Перечисленные воспоминания выстраиваются в цепочку от старейшего к новейшему, и новое воспоминание становится
головой цепочки. `content` по-прежнему описывает ТОЛЬКО новейшее состояние — никогда не копируй в него
текст старых воспоминаний; они остаются доступными для поиска в истории цепочки.

---

# Правила

* Сохраняй всю значимую информацию.
* Пропускай точные дубликаты.
* Предпочитай сливать связанные фрагменты.
* Отдельные датированные случаи остаются отдельными ADD; используй `same_series` только для
  одного и того же субъекта и одного и того же конкретного типа занятия/события.
* Каждое воспоминание должно быть сосредоточено на одной связной теме.
* Следуй разделу «Порядок времени» ниже.
* **НИКОГДА не сливай и не заменяй (SUPERSEDE) воспоминания с разными субъектами.** Субъект — это тот, о ком
  содержание: «Пользователь ...», «John ...» или «Mary ...». Воспоминания о
  разных людях — независимые факты, даже если в остальном предложение
  идентично: «Пользователь любит кофе» и «John любит кофе» — два отдельных
  воспоминания, никогда не UPDATE и не SUPERSEDE друг друга.
* `owner` (`user`/`agent`): копируй его из записываемого воспоминания. НИКОГДА не сливай и не заменяй (SUPERSEDE) воспоминания с разными владельцами — факт пользователя и факт ассистента различны, даже если тема одна.
* SUPERSEDE либо нацелен на ОДНО воспоминание (`memory_id`), либо сворачивает несколько воспоминаний одного измерения в одну цепочку (`memory_ids`, от старейшего к новейшему). UPDATE нацелен ровно на ОДНО воспоминание.
* Никогда не затрагивай одно и то же существующее воспоминание более чем одной операцией.
* Язык вывода совпадает с языком входных воспоминаний.

---

# Порядок времени

У каждого воспоминания, нового или существующего, есть `memory_at`: когда это произошло. Воспоминания
НЕ всегда записываются в том порядке, в каком происходили события: историю могут импортировать с опозданием,
а воспоминание может добавляться, пока более старая история ещё обрабатывается. Поэтому новое
воспоминание может быть СТАРШЕ существующего.

* Определяй, какое воспоминание новее, ТОЛЬКО по `memory_at`. «Новые воспоминания» означает «записываемые
  сейчас», а не «более свежие».
* Более старое воспоминание никогда не должно заменять более новое: никакого SUPERSEDE более нового
  воспоминания и никакого UPDATE, перезаписывающего более новое значение более старым.
* Если новое воспоминание старше существующего, с которым оно конфликтует, оставь
  существующее воспоминание как текущее состояние. Добавь (ADD) новое как прошлое состояние, сформулированное
  в прошедшем времени и с указанием времени (например, «В 2023 году пользователь жил в Шанхае»),
  или не выводи ничего, если оно не добавляет информации.
* `memory_at: null` означает неизвестное время. Неизвестное НЕ новее: никогда не заменяй (SUPERSEDE)
  воспоминание с известным `memory_at` воспоминанием, у которого `memory_at` равен null.
* Не придумывай хронологию.

---

# Необязательное поле: `related`

В любую операцию ты МОЖЕШЬ добавить массив `related`, фиксирующий, как записываемое воспоминание
связано с СУЩЕСТВУЮЩИМ воспоминанием. Это не меняет того, что сохраняется, — лишь
записывает связь.

```json
{{
  "op": "ADD",
  "content": "...",
  "owner": "user",
  "tags": ["..."],
  "related": [{{"memory_id": "<existing_id>", "relation": "causes"}}]
}}
```

Допустимы только эти четыре связи:

* `causes` — два воспоминания связаны отношением причины и следствия
  (например, «начал бегать каждый день» → «начало болеть колено»)
* `elaborates` — добавляет детали к существующему воспоминанию или является его более поздним развитием
* `contrasts` — они в напряжении, но ОБА по-прежнему истинны (если одно делает другое
  ложным, это SUPERSEDE, а не связь `contrasts`)
* `same_series` — отдельные датированные случаи одного и того же конкретного занятия или
  типа события для одного и того же субъекта (например, две разные лыжные поездки)

Правила:

* Связывай только с воспоминаниями, которые есть в «Existing memories», — никогда не выдумывай id.
* Выводи связь только тогда, когда отношение **явное и конкретное**. То, что два воспоминания
  просто относятся к одной широкой теме, НЕ является связью — тогда не указывай `related`.
* `same_series` требует одного и того же субъекта и конкретного повторяющегося действия/события;
  общих широких тегов вроде health, travel, sport, food или work недостаточно.
* Полностью опускай поле, если связывать нечего. Ноль связей — обычный случай.
* Никогда не используй `related` как замену UPDATE / SUPERSEDE.

---
{few_shot_section}
###################
Входные данные
###################

Текущая дата: {current_date}

## Existing memories

{existing_memories}

## New memories

{new_memories}

---

# Вывод

Верни ТОЛЬКО JSON-массив внутри блока кода ```json.

Если изменения не нужны:

```json
[]
```

Теперь выведи JSON-массив."""

RECONCILE_STRUCTURE_METADATA_PROMPT = """

Дополнительный контракт структурного вывода:

Для каждого результата ADD, UPDATE или SUPERSEDE сохраняй или уточняй `topic_paths`,
`event_facet` и `topic_assignments`. `event_facet` содержит только `subject`,
`participants`, `action`, `objects`, `locations` и `state`.
`topic_assignments` содержит записи `{subject, role, path}`, привязанные к конкретному субъекту;
каждый сегмент пути — `{name, type}`, а type — `topic|facet|series|episode`.
Типы идут в порядке `topic -> facet -> series -> episode`; уровни можно пропускать, но
типы нельзя повторять или менять их порядок на обратный.
Используй Series только для повторяющихся случаев одной конкретной линии занятия/состояния, а
Episode — только для одного ограниченного реального случая. Никогда не выводи эти типы из
глубины, широкого общего тега или несвязанного совместного упоминания. Если у воспоминания из Existing memories
уже есть семантически эквивалентный путь для того же субъекта, переиспользуй в точности его названия узлов
и типы, вместо того чтобы создавать ответвление-синоним. Чтобы запросить точное переиспользование, выведи
`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
"through":"topic|facet|series|episode"}]`. Указанный ID должен присутствовать в
Existing memories. `through` означает: скопировать префикс существующего пути вплоть до
названного структурного типа; явно заданный более глубокий суффикс остаётся новым. Переиспользование
запрещено, если различаются субъект, конкретная линия занятия/состояния или граница Episode.
Эти поля описывают воспоминание, а не будущую форму запроса вроде
«когда», «сколько» или «кто».

Series — это отношение этапа reconcile: устанавливай его, только если новое воспоминание и
хотя бы одно независимое воспоминание из Existing memories — разные случаи одной и той же
конкретной линии занятия/состояния. Несколько утверждений из текущей записи
не доказывают повторяемость.
"""

RECONCILE_FEW_SHOT = """
###################
Примеры
###################

## Пример 1 — Одно новое воспоминание: часть конфликтует с существующей цепочкой, часть не связана с ней

Existing memories:
[
  {"memory_id": "m1", "content": "Пользователь работает продакт-менеджером в Stripe.", "owner": "user", "history_versions": [{"content": "Пользователь работает продакт-менеджером в финтех-стартапе."}]}
]
New memories:
[
  {"content": "Пользователь ушёл из Stripe и теперь руководит продуктом в Notion, а также недавно начал заниматься гончарным делом по выходным.", "owner": "user"}
]

Вывод:
```json
[
  {"op": "SUPERSEDE", "memory_id": "m1", "content": "Пользователь работает руководителем продукта в Notion.", "supersede_reason": "работодатель сменился со Stripe на Notion", "owner": "user", "tags": ["work"]},
  {"op": "ADD", "content": "Пользователь недавно начал заниматься гончарным делом по выходным.", "owner": "user", "tags": ["hobby"]}
]
```
ОДНО новое воспоминание несёт две вещи: смену работы (то же измерение, что и существующая цепочка о работе m1, у которой уже есть история → SUPERSEDE, становится новой головой цепочки) и несвязанную деталь (гончарное дело → ADD). Раздели одно воспоминание на части и выбери для каждой нужную операцию — новая голова описывает ТОЛЬКО состояние занятости, никогда не гончарное дело.

## Пример 2 — Свернуть два несвязанных существующих воспоминания + новое изменение в одну цепочку из 3 узлов

Existing memories:
[
  {"memory_id": "a1", "content": "Пользователь учится играть на гитаре.", "owner": "user", "memory_at": "2024-02-10 09:00"},
  {"memory_id": "a2", "content": "Пользователь уже может сыграть на гитаре несколько песен целиком.", "owner": "user", "memory_at": "2024-09-05 09:00"}
]
New memories:
[
  {"content": "Пользователь теперь выступает с гитарой на местных open-mic вечерах.", "owner": "user"}
]

Вывод:
```json
[
  {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "Пользователь выступает с гитарой на местных open-mic вечерах.", "supersede_reason": "навык игры на гитаре вырос: обучение → исполнение песен → живые выступления", "owner": "user", "tags": ["music", "hobby"]}
]
```
a1 и a2 никогда не были связаны, но они отслеживают одно и то же измерение (прогресс в игре на гитаре), а новое воспоминание — последний шаг. Сверни их через `memory_ids`, упорядоченные от старейшего к новейшему; они становятся цепочкой из 3 узлов (a1 ← a2 ← новая голова). `content` головы описывает ТОЛЬКО текущее состояние — он не повторяет «учится» или «несколько песен».

## Пример 3 — Новая голова НЕ должна копировать содержимое старого воспоминания

Existing memories:
[
  {"memory_id": "c1", "content": "Пользователь снимает однокомнатную квартиру в Сибуе (Токио), платит ¥180 000 в месяц, ему нравится, что до станции 5 минут пешком, но он жалуется, что ночью там шумно и нет парковки.", "owner": "user"}
]
New memories:
[
  {"content": "Пользователь только что купил дом с тремя спальнями в пригороде Иокогамы, с садом и гаражом на две машины, и переехал туда.", "owner": "user"}
]

Вывод:
```json
[
  {"op": "SUPERSEDE", "memory_id": "c1", "content": "Пользователь купил дом с тремя спальнями в пригороде Иокогамы, с садом и гаражом на две машины, и переехал туда.", "supersede_reason": "место жительства сменилось с арендованной квартиры в Сибуе на собственный дом в Иокогаме", "owner": "user", "tags": ["housing"]}
]
```
Новое воспоминание заменяет (SUPERSEDE) c1 и становится головой цепочки. `content` головы описывает ТОЛЬКО новый дом в Иокогаме. НЕ тащи в новый узел характерные детали старой квартиры (Сибуя, аренда ¥180 000, путь до станции, жалобы на шум и парковку) — они явно относятся к старому жилью, а не к новому. Они остаются в истории цепочки и доступны для поиска; если их скопировать, голова станет противоречивой (одновременно аренда в Сибуе И собственный дом в Иокогаме).

## Пример 4 — Разные субъекты никогда не сливаются, как бы похожи ни были формулировки

Existing memories:
[
  {"memory_id": "d1", "content": "Пользователь каждое утро пьёт чёрный кофе.", "owner": "user"}
]
New memories:
[
  {"content": "John каждое утро пьёт чёрный кофе.", "owner": "user"},
  {"content": "Пользователь теперь пьёт чёрный кофе дважды в день — утром и после обеда.", "owner": "user"}
]

Вывод:
```json
[
  {"op": "ADD", "content": "John каждое утро пьёт чёрный кофе.", "owner": "user", "tags": ["food"]},
  {"op": "UPDATE", "memory_id": "d1", "content": "Пользователь пьёт чёрный кофе дважды в день — утром и после обеда.", "owner": "user", "tags": ["food"]}
]
```
Два новых воспоминания почти одинаковы по формулировке, но у них РАЗНЫЕ субъекты. «John ...» — о другом человеке, поэтому это простой ADD — никогда не UPDATE и не SUPERSEDE для d1, хотя d1 говорит почти то же самое о пользователе. Слиться с d1 может только воспоминание, субъект которого тоже «Пользователь».

## Пример 5 — Повторяющееся событие: увеличь счётчик и веди хронологию (UPDATE, а не ADD)

Existing memories:
[
  {"memory_id": "i1", "content": "John повредил лодыжку в прошлом сезоне, и ему понадобились перерыв и физиотерапия.", "owner": "user", "memory_at": "2023-05-21 19:48"}
]
New memories:
[
  {"content": "John снова подвернул лодыжку во время недавней игры.", "owner": "user", "memory_at": "2023-10-13 13:50"}
]

Вывод:
```json
[
  {"op": "UPDATE", "memory_id": "i1", "content": "John травмировал лодыжку два раза: впервые в прошлом сезоне (примерно сезон 2022–2023), что потребовало перерыва и физиотерапии; второй раз — во время игры около 2023-10-13.", "owner": "user", "tags": ["health", "basketball", "injury"]}
]
```
Событие того же типа повторилось → UPDATE старого воспоминания. Укажи **количество** и перечисли случаи со временем, если оно известно. НЕ добавляй (ADD) второй факт «John травмировал лодыжку» и НЕ используй SUPERSEDE (первая травма не перестала быть правдой).
"""


# ================================================================
# Working / coding memory (coding/)
# ================================================================

CODING_EXTRACT_PROMPT = """\
Ты извлекаешь долговечные WORKING-воспоминания (рабочую память) из фрагмента сессии выполнения задачи.
«Рабочая» сессия — это любая практическая задача, в которой пользователь управляет компьютером /
системой через инструменты. Сюда входит И работа с ПО/кодом (написание, отладка,
рефакторинг, сборка, деплой, использование API/библиотек), И системная и эксплуатационная
работа (выполнение команд shell/PowerShell, анализ или очистка дисков/хранилища, операции с файлами
и папками, установка/настройка ПО, настройка окружения/устройств,
проверка состояния оборудования/дисков, резервное копирование, планирование/автоматизация, обработка данных).

Из ОДНОГО И ТОГО ЖЕ фрагмента ты создаёшь ДВА слоя:

  EXPERIENCES (процедурный слой, «как это сделать») — переиспользуемый метод; извлекается, только
  если он проходит ПОРОГ ЦЕННОСТИ (VALUE BAR) ниже. Это связка (task, search_keys, solution,
  boundary_envs).

  FACT (эпизодический слой, «что произошло на этот раз») — РОВНО ОДНА запись об ЭТОЙ
  сессии: чего хотел пользователь, как к этому подошли, чем всё закончилось. Порога
  ценности нет, но запись никогда не бывает больше одной.

Эти два слоя отвечают на разные вопросы и хранятся отдельно. Метод,
который обобщается, идёт в EXPERIENCES; история именно этой сессии —
верная только для этой системы / этого проекта / этого момента — идёт в FACT.

═══════════════════════════════════════════════════════════════════
ПОРОГ ЦЕННОСТИ (VALUE BAR, ТОЛЬКО ДЛЯ EXPERIENCES) — НЕ преодолевай его легкомысленно.
═══════════════════════════════════════════════════════════════════
Воспоминание ОБЯЗАНО удовлетворять ВСЕМ условиям:
  (a) Решает проблему, которая, скорее всего, повторится у того же пользователя
  (b) Решение нетривиально: объединяет несколько единиц информации / шагов, ИЛИ
      содержит обоснование решения, ИЛИ фиксирует с трудом найденный обходной путь, ИЛИ является
      переиспользуемой процедурой/рецептом для эксплуатационной задачи (например, как проанализировать
      и очистить занятое место на диске, как пакетно упорядочить файлы, как проверить состояние
      оборудования, как настроить задание по расписанию)
  (c) Будущий агент / пользователь предпочтёт найти это, а не открывать заново

ВАЖНО — задачи анализа / диагностики / расследования ТОЖЕ СЧИТАЮТСЯ:
Задача НЕ обязана что-то менять или «чинить», чтобы её стоило запомнить.
Работа только на чтение / аналитическая / по поиску неисправностей ценна, когда её ПРОЦЕДУРА или
ВЫВОД можно переиспользовать. Явно извлекай:
  - Рецепты анализа / диагностики: переиспользуемую процедуру + то, что она выявила
    (например, «как проанализировать, какие папки занимают место на диске C» — команды сканирования,
    встреченные подводные камни и результат). «Получился только отчёт, без изменений» —
    это НЕ причина пропускать: переиспользуемый МЕТОД и есть воспоминание.
  - Результаты расследования, ВКЛЮЧАЯ отрицательные / «не найдено»
    (например, «искали папку X на C: и D: с помощью rg / fs_search / SQL index —
    нигде не найдена»). Записанный тупик избавляет следующего агента от повторения
    того же бесплодного поиска, поэтому он проходит порог.
НЕ отвергай воспоминание только потому, что «ассистент мог бы заново сгенерировать
команды» или «на самом деле ничего не изменилось». Если процедура или вывод
сэкономят усилия в будущем, сохраняй.

НЕ извлекай:
  - По-настоящему тривиальные одношаговые операции без переиспользуемой процедуры («переименовать один файл»,
    «git status», «один раз запустить ls»)
  - Разовые проблемы, уже решённые и не дающие переносимого урока
  - Информацию, которая уже есть в репозитории/системе (не дублируй package.json)
  - Одноразовые задачи отдельного PR / отдельной сессии, если они не кодируют переиспользуемый шаблон
  - Сам акт ЗАПРОСА У ПОЛЬЗОВАТЕЛЯ недостающей информации. Запрос параметра,
    перечисление неизвестного или выяснение обязательных полей — это поведение в разговоре,
    а не метод: любой агент и так умеет задавать вопросы, поэтому
    искать потом нечего. Никогда не выводи experience, у которого task или
    search_keys имеют вид «как спросить X», «собрать недостающий Y»,
    «выяснение обязательных полей», «что уточнить перед началом». Учти, что это
    исключается только из EXPERIENCES: то, что сессия закончилась ожиданием пользователя, —
    реальное состояние, и оно относится к FACT.

Если фрагмент не дал существенного продвижения, потому что застрял в ожидании
пользователя — ассистент только запрашивал параметры или был заблокирован до какой-либо
реальной работы, — выведи "experiences": [] и запиши только FACT. Пока ничему
не научились, поэтому сохранять как метод нечего. Это важнее, чем кажется:
experience, выжатый из застоя, при поиске выглядит как полноценный навык,
и более поздний фрагмент той же задачи совпадёт с ним и снова спросит пользователя
вместо того, чтобы продолжить, так что застой будет воспроизводиться до конца
сессии. Суди о содержательности по тому, что на самом деле сделали инструменты, а не по тому,
получился ли у реплики гладкий текст.

Эвристика: если пользователь (или будущий агент, выполняющий такую же задачу) хотел бы,
чтобы это было записано, а не выяснять всё заново, — сохраняй. Многошаговая
эксплуатационная процедура (даже системная/ops или аналитическая/поисковая только на чтение, а не
только кодовая) обычно подходит. Отбрасывай её, только если это одна команда, которую любой пользователь
найдёт через `--help` за 30 секунд, И в ней нет решения/подводного камня, достойного
запоминания.

═══════════════════════════════════════════════════════════════════
ПОЛЯ EXPERIENCE
═══════════════════════════════════════════════════════════════════

task          — Название в форме запроса; формулируй так, как пользователь позже СПРОСИТ.
                «опубликовать релиз на платформе xx», а не
                «publish_release_internal»
                Самодостаточно (без «это», «тот файл», «мы»).

search_keys   — от 0 до 5 альтернативных формулировок, охватывающих важные аспекты
                solution, которые одно поле `task` не покроет. Формулируй как вопросы
                или темы, о которых будущие пользователи СПРОСЯТ. Отличаются от task.
                Опусти, если task уже всё покрывает.

solution      — Полное, самодостаточное содержание, которое действительно нужно пользователю:
                команды, местонахождение учётных данных (НЕ ЗНАЧЕНИЯ учётных данных),
                пути к файлам, упорядоченные шаги, подводные камни, обоснование решений.
                Объединяй многоходовую сквозную работу в ОДНО solution, если она
                образует связную задачу; разбивай на несколько воспоминаний, только когда
                пользователь выполнял несвязанные задачи.

boundary_envs — Конкретные привязки, от которых зависит solution, многострочно в виде «key: value»:
                  среда выполнения / SDK / библиотека + версия
                  API endpoint или сигнатура метода
                  версия внешнего сервиса / middleware
                  ИМЯ переменной окружения (не значение)
                  путь к файлу конфигурации
                  идентификатор хоста / кластера / региона
                Если solution не зависит от окружения, оставь "" (пусто).
                Назначение: когда базовый SDK/middleware обновится, будущие
                потребители смогут проверить это поле и решить, применимо ли solution до сих пор.

confidence  — от 0.0 до 1.0
  1.0   пользователь явно сформулировал это как правило / инструкцию
  0.7   выведено с хорошими доказательствами из действий инструментов
  0.5   выведено слабо; одно наблюдение; неуверенно

═══════════════════════════════════════════════════════════════════
ПОЛЕ FACT — РОВНО ОДНО на фрагмент, без порога ценности
═══════════════════════════════════════════════════════════════════

Ты пишешь ОДИН fact на весь фрагмент — восстановимую запись состояния этой
сессии, а не отшлифованный ретроспективный обзор и никогда не список отдельных находок.
Будущий агент должен иметь возможность продолжить с неё, не принимая предложение,
вывод или частичный поиск за что-то проверенное.

subject    — КТО или ЧТО является предметом этой сессии: единственная сущность, над которой
             или для которой выполнялась работа. Одна короткая именная группа, без предложения, без глагола.
             Выбирай самую конкретную сущность, о которой *эта* сессия, а не
             инструмент, который она использовала:
               имя человека, если сессия обслуживает одного названного человека
                 («Dylan», «Matthew»)
               файл / модуль / символ, если работа нацелена на код
                 («auth/middleware.ts», «parse_plan_text»)
               сервис / хост / устройство / диск для эксплуатационной работы
                 («D:\\WXWork», «redis-cache-prod», «ci.yml»)
             Это ЖЁСТКИЙ КЛЮЧ, а не проза: две сессии о разных людях
             или разных файлах ОБЯЗАНЫ получить разные subject, а две сессии
             об одном и том же ОБЯЗАНЫ получить одну и ту же строку, написанную идентично.
             Предпочитай точный идентификатор в том виде, в каком он встречается в трейсе, а не
             его описание. Если у фрагмента действительно нет единственного субъекта,
             выведи "".

             Почему это важно: subject — это шлюз, который решает, может ли более поздняя
             сессия перезаписать эту как «ту же задачу,
             продолженную». Ошибёшься — и состояние одного человека незаметно заменит
             состояние другого.

statement  — Компактная запись ЭТОЙ сессии. Две части, и теряется обычно
             вторая.
             Сохраняй заданные в рамках задачи исходные данные и конкретные ограничения, а не
             заменяй их общей оценкой результата. Формулируй
             каждое правило один раз: повторяющийся текст инструкций конкурирует с данными,
             которые воспоминание должно сохранить.

             ЧАСТЬ 1 — что произошло, около 300 латинских символов (~150 символов CJK).
             Начни с конкретной цели и объекта («освободить место на диске, занятое
             D:\\WXWork», «найти папку new_file_search»), а не с общего
             «исправить ошибку» / «найти файл». Затем — примерно, что было осмотрено, опробовано
             или изменено. Затем — чем всё закончилось, со смыслом ровно одного из вариантов:
             завершено, частично завершено, не удалось, заблокировано или
             всё ещё ожидает проверки. Включай отрицательные результаты и тупики,
             не преувеличивая их.

             ЧАСТЬ 2 — ИСХОДНЫЕ ДАННЫЕ В РАМКАХ ЗАДАЧИ: всё, на чём работает ВСЯ задача,
             даже если этот фрагмент этого не установил и даже если это кажется
             слишком элементарным, чтобы упоминать. Привязки (что обозначает каждое имя/символ/метка),
             фиксированные значения, которые задача задаёт, а не выводит, принятые
             соглашения (база индексации, единицы, часовой пояс, значения по умолчанию) и
             собственный результат этого фрагмента ВМЕСТЕ с его значением («x = 7», а не «значение
             было вычислено»).

             Пиши ЧАСТЬ 2 как данные, по одному пункту на строку, значения — как заданы:
               retry budget = 5; timeout 30s; index starts at 0
               step 3 input: n=64, tolerance 1e-6
               slot B: type=private, cost 688.7-721.3 per unit
             Строка должна почти целиком состоять из значений. Сохраняй нотацию трейса —
             символы, единицы, числа, написание — и отбрасывай его предложения: убирай
             фразы, которые объявляют исходное значение, а не являются им («я бы
             предпочёл», «должно быть где-то между … и …»). Они повторяются для
             каждого пункта, так что в списке из 15 пунктов за них платишь 15 раз.
             Переноси их в КАЖДЫЙ fact; никогда не пиши «как выше» или «то же, что
             в предыдущей сессии» — поиск возвращает несколько фактов по
             сходству, и того, на что ссылаешься, среди них может не оказаться.
             Стремись уложиться в 1200 символов всего. Если ЧАСТЬ 2 не помещается, исправляй
             нотацию, но никогда не охват: statement — это поисковый вектор И
             единственное поле, которое может прочитать более поздний фрагмент (details не
             эмбеддится и не подставляется), так что всё вырезанное из него потеряно. Сжимай формулировки
             вокруг исходного значения; никогда не само значение.

             Проверка: если следующий фрагмент не видит исходного материала, сможет ли
             он продолжить только по этой записи? Засчитывается только «да». Отсутствующая
             привязка не проявляется громкой ошибкой — имя по-прежнему выглядит осмысленным, поэтому
             его читают в общеупотребительном значении, и следующий за этим ответ
             гладкий, но о другом вопросе.

             ЯЗЫК — тот же, что и у трейса сессии: statement — это
             поисковый вектор, а запросы приходят на рабочем языке пользователя,
             так что другой язык платит штраф за межъязыковой поиск при каждом обращении.

             ТОЧНОСТЬ ДОКАЗАТЕЛЬСТВ — записывай только действительно выполненные действия и
             доказательства, явно присутствующие в трейсе. Сохраняй существенные
             команды, флаги, аргументы, ошибки и числа дословно.
             НИКОГДА не дополняй команду привычными флагами и никогда не превращай
             советы или планы в действия:
               «ran Get-ChildItem -Force» → «ran Get-ChildItem»
                 (в трейсе не было `-Force`; не выдумывай его)
             Ограничивай каждый отрицательный вывод тем, что действительно искали, и
             перечисляй КАЖДОЕ явное ограничение охвата, которое может его опровергнуть,
             особенно отказы в доступе и ограничения глубины: сохраняй корни,
             фильтры и глубину, которые действовали («не найдено в C:\\ и
             D:\\ на глубине 3; некоторые каталоги не охвачены из-за Access
             denied»), никогда не расширяй до «не существует». Не опускай ни одно ограничение
             ради того, чтобы запись выглядела красивее.
             Никогда не превращай частичный поиск в глобальное отсутствие.
             Заблокированная попытка сохраняет свою причину блокировки.
             Сохраняй различие между «попытались», «наблюдали», «проверили»,
             «предположили» и «не решено» — выражай его естественно («попытались …, но
             упёрлись в Access denied», «предполагается …, пока не проверено»), а не
             метками. Без вывода инструмента или явного подтверждения НИКОГДА не утверждай, что
             исправление сработало, причина установлена или путь не существует.

             НЕ записывай приветствия и чистую болтовню — это единственный случай,
             когда ставится "fact": null. Фрагмент, который лишь изложил требования или
             застрял до начала работы, всё равно что-то установил.

details    — Конкретный РЕЗУЛЬТАТ сессии, перенесённый дословно. `statement` —
             это сводка, а сводка неизбежно теряет отдельные значения;
             более позднему поиску почти всегда нужно одно конкретное значение, а не общий смысл.
             Поэтому какой бы адресуемый результат ни дала эта сессия, воспроизведи
             его здесь в исходной форме и структуре:
               план / расписание / маршрут → сохраняй каждую строку, каждый день, каждый
                 слот и каждую цену в точности как написано
               блок конфигурации или кода → сохраняй блок
               существенный вывод команды → сохраняй строки, в которых содержатся
                 находки (размеры, количества, версии, текст ошибок)
               структурированный результат (таблица, список записей) → сохраняй строки
             Сохраняй исходную вёрстку — переносы строк, префиксы `Day 1:` / key: value,
             единицы, символы валют, id. Не пересказывай заново, не
             переупорядочивай, не округляй числа, не переводи.

             Копируй ТОЛЬКО то, что есть в трейсе. Никогда не заполняй пробелы: если слот
             остался незаполненным, оставь его незаполненным или так и скажи — выдуманное значение
             хуже отсутствующего, потому что его найдут и используют.
             Предел — около 4000 символов; если результат длиннее, оставь части,
             содержащие конкретные значения, и отбрось декоративную прозу, отметив, что
             было отброшено.

             "", если сессия не дала такого артефакта (чистое расследование
             пока без находок или застой в ожидании пользователя).

             Это поле НЕ входит в поисковый вектор: находят по `statement` и
             `subject`, а `details` даёт значение, когда запись уже найдена.
             Поэтому не пиши здесь приманку для поиска и не дублируй
             сводку; пиши сам сырой материал.

files      — 0..N абсолютных или относительных к репозиторию путей к ФАЙЛАМ ИЛИ КАТАЛОГАМ, с которыми действительно
             работали или которые исследовали в этой сессии. Сохраняй исследованные
             корни, такие как `C:\\` и `D:\\`. Включай только пути, к которым действительно
             обращались/в которых искали, а не пути, которые лишь предлагались или планировались;
             [], если таких нет.
═══════════════════════════════════════════════════════════════════
КОНТЕКСТ ХОСТА (передаётся SDK)
═══════════════════════════════════════════════════════════════════
- workspace_id present: {workspace_present}
- branch present: {branch_present}

Когда workspace_id отсутствует, solution не может опираться на невысказанный
локальный контекст проекта — явно укажи любой нужный репозиторий / путь / сервис внутри
`solution` или `boundary_envs`, чтобы воспоминание оставалось пригодным само по себе.

═══════════════════════════════════════════════════════════════════
РАЗГОВОР
═══════════════════════════════════════════════════════════════════
{conversation_block}

═══════════════════════════════════════════════════════════════════
ВЫВОД (только строгий JSON, без markdown)
═══════════════════════════════════════════════════════════════════
{{
  "experiences": [
    {{
      "task": "...",
      "search_keys": ["...", "..."],
      "solution": "...",
      "boundary_envs": "...",
      "confidence": 0.9
    }}
  ],
  "fact": {{
    "subject": "...",
    "statement": "...",
    "files": ["..."],
    "details": "..."
  }}
}}

ПО УМОЛЧАНИЮ — ИЗВЛЕКАЙ. Если фрагмент выполнил реальную работу, ты ОБЯЗАН вывести хотя бы
один experience — даже если задача выглядит простой или была решена с первого раза, всё равно
зафиксируй переиспользуемую суть сделанного (метод / команду / инструкцию).
Если сессия скудная, достаточно одного, самого ценного experience.

ЕДИНСТВЕННОЕ исключение — описанный выше случай застоя: если фрагмент не выполнил реальной работы,
потому что был заблокирован запросом недостающей информации у пользователя, выведи
"experiences": [] и запиши только fact. Не сочиняй experience, чтобы
выполнить эту инструкцию: выдуманный («как спросить город
отправления») хуже, чем никакого, потому что его потом найдут и будут ему следовать. Пустой список
допустим ТОЛЬКО по этой причине и никогда как способ срезать путь, когда работа действительно была выполнена.

"fact" — это ОДИН объект, никогда не список: одна запись на сессию.

ВСЕГДА записывай fact. Критерий для fact — не «было ли это ценно», а «произошло ли
хоть что-нибудь», и фрагмент, дошедший до тебя, уже прошёл этот критерий.
Сюда относятся фрагменты, которые выглядят как подготовка, а не работа: одно
сообщение пользователя с требованиями, параметрами или начальным состоянием, без
запуска инструментов, — это именно тот материал, который более поздняя сессия не сможет восстановить сама,
— запиши требования, параметры и начальное состояние вместе с ситуацией в `statement` (компактной записью, не копируя дословно фразы диалога),
а не перекладывай их в `details` (`details` не входит в поисковый вектор, и сторона чтения его больше не подставляет). Используй
"fact": null ТОЛЬКО для приветствий и чистой болтовни без какого-либо содержания.
Если сомневаешься, запиши fact: ненужная запись стоит одну строку, а пропущенная
стоит каждой последующей сессии, которой она была нужна и которая никак не может узнать о её существовании.
"""

CODING_EXTRACT_PROMPT_CODING = """\
╔═══════════════════════════════════════════════════════════════════════════╗
║ ЖЁСТКОЕ ОГРАНИЧЕНИЕ — прочитай это раньше всего остального; оно отменяет  ║
║ любые формулировки ниже в этом промпте, которые звучат как просьба        ║
║ о повествовании.                                                          ║
║                                                                           ║
║ Ты НЕ пишешь отчёт о том, что сделал человек. Ты пишешь то, что           ║
║ БУДУЩЕМУ АГЕНТУ нужно, чтобы действовать. У этого агента уже есть своя    ║
║ задача; ему безразлично, чего хотел этот пользователь. Ему нужно знать:   ║
║ что здесь решили, в каких координатах кода, что попробовали и отвергли    ║
║ и было ли это проверено.                                                  ║
║                                                                           ║
║ Конкретно, в каждом `statement` и каждом `solution`:                      ║
║   · Грамматический субъект — КОД или РЕШЕНИЕ, никогда не «пользователь»   ║
║     и никогда не «агент». Не пиши «Пользователь попытался…»,              ║
║     «Пользователь хотел…», «Затем агент проверил…».                       ║
║   · Никогда не заканчивай канцелярской фразой вроде «сессия завершена»,   ║
║     «ошибка зафиксирована», «решение пока не найдено». Заканчивай         ║
║     решением и статусом его проверки. Если ничего не решено, заканчивай   ║
║     тем, что ИСКЛЮЧЕНО, и следующей неисследованной зацепкой — это и есть ║
║     переиспользуемая часть.                                               ║
║   · Сохраняй конкретный симптом (строку ошибки, падающую команду,         ║
║     неверный вывод) — именно по нему будущий поиск найдёт запись.         ║
║                                                                           ║
║ плохо:   «Пользователь попытался записать QTable в RST с header_rows и    ║
║           получил TypeError. Сессия завершена, ошибка зафиксирована.»     ║
║ хорошо:  «RST-writer в ascii.rst отвергает header_rows:                   ║
║   `tbl.write(..., format='ascii.rst', header_rows=['name','unit'])`       ║
║           выбрасывает TypeError, потому что RST.__init__ не пробрасывает  ║
║           его, в отличие от ascii.fixed_width, который его принимает.     ║
║           Исправление не написано — writer нужна та же передача           ║
║           header_rows, что и у fixed_width.»                              ║
╚═══════════════════════════════════════════════════════════════════════════╝

Ты извлекаешь долговечные WORKING-воспоминания (рабочую память) из фрагмента сессии выполнения задачи.
«Рабочая» сессия — это любая практическая задача, в которой пользователь управляет компьютером /
системой через инструменты. Сюда входит И работа с ПО/кодом (написание, отладка,
рефакторинг, сборка, деплой, использование API/библиотек), И системная и эксплуатационная
работа (выполнение команд shell/PowerShell, анализ или очистка дисков/хранилища, операции с файлами
и папками, установка/настройка ПО, настройка окружения/устройств,
проверка состояния оборудования/дисков, резервное копирование, планирование/автоматизация, обработка данных).

Из ОДНОГО И ТОГО ЖЕ фрагмента ты создаёшь ДВА слоя:

  EXPERIENCES (процедурный слой, «как это сделать») — переиспользуемый метод; извлекается, только
  если он проходит ПОРОГ ЦЕННОСТИ (VALUE BAR) ниже. Это связка (task, search_keys, solution,
  boundary_envs).

  FACT (эпизодический слой, «что было установлено на этот раз») — РОВНО ОДНА запись об ЭТОЙ
  сессии. Это НЕ повествование о том, что сделал пользователь. В ней записывается, в таком порядке:
  задача и её конкретный симптом (именно это делает запись находимой в будущем),
  координаты кода, НА ЧЁМ ОСТАНОВИЛИСЬ и что было отвергнуто, и насколько это было
  проверено. Порога ценности нет, но запись никогда не бывает больше одной.

Эти два слоя отвечают на разные вопросы и хранятся отдельно. Метод,
который обобщается, идёт в EXPERIENCES; история именно этой сессии —
верная только для этой системы / этого проекта / этого момента — идёт в FACT.

═══════════════════════════════════════════════════════════════════
ПОРОГ ЦЕННОСТИ (VALUE BAR, ТОЛЬКО ДЛЯ EXPERIENCES) — НЕ преодолевай его легкомысленно.
═══════════════════════════════════════════════════════════════════
Воспоминание ОБЯЗАНО удовлетворять ВСЕМ условиям:
  (a) Решает проблему, которая, скорее всего, повторится у того же пользователя
  (b) Решение нетривиально: объединяет несколько единиц информации / шагов, ИЛИ
      содержит обоснование решения, ИЛИ фиксирует с трудом найденный обходной путь, ИЛИ является
      переиспользуемой процедурой/рецептом для эксплуатационной задачи (например, как проанализировать
      и очистить занятое место на диске, как пакетно упорядочить файлы, как проверить состояние
      оборудования, как настроить задание по расписанию)
  (c) Будущий агент / пользователь предпочтёт найти это, а не открывать заново

ВАЖНО — задачи анализа / диагностики / расследования ТОЖЕ СЧИТАЮТСЯ:
Задача НЕ обязана что-то менять или «чинить», чтобы её стоило запомнить.
Работа только на чтение / аналитическая / по поиску неисправностей ценна, когда её ПРОЦЕДУРА или
ВЫВОД можно переиспользовать. Явно извлекай:
  - Рецепты анализа / диагностики: переиспользуемую процедуру + то, что она выявила
    (например, «как проанализировать, какие папки занимают место на диске C» — команды сканирования,
    встреченные подводные камни и результат). «Получился только отчёт, без изменений» —
    это НЕ причина пропускать: переиспользуемый МЕТОД и есть воспоминание.
  - Результаты расследования, ВКЛЮЧАЯ отрицательные / «не найдено»
    (например, «искали папку X на C: и D: с помощью rg / fs_search / SQL index —
    нигде не найдена»). Записанный тупик избавляет следующего агента от повторения
    того же бесплодного поиска, поэтому он проходит порог.
НЕ отвергай воспоминание только потому, что «ассистент мог бы заново сгенерировать
команды» или «на самом деле ничего не изменилось». Если процедура или вывод
сэкономят усилия в будущем, сохраняй.

НЕ извлекай:
  - По-настоящему тривиальные одношаговые операции без переиспользуемой процедуры («переименовать один файл»,
    «git status», «один раз запустить ls»)
  - Разовые проблемы, уже решённые и не дающие переносимого урока
  - Информацию, которая уже есть в репозитории/системе (не дублируй package.json)
  - Одноразовые задачи отдельного PR / отдельной сессии, если они не кодируют переиспользуемый шаблон

Эвристика: если пользователь (или будущий агент, выполняющий такую же задачу) хотел бы,
чтобы это было записано, а не выяснять всё заново, — сохраняй. Многошаговая
эксплуатационная процедура (даже системная/ops или аналитическая/поисковая только на чтение, а не
только кодовая) обычно подходит. Отбрасывай её, только если это одна команда, которую любой пользователь
найдёт через `--help` за 30 секунд, И в ней нет решения/подводного камня, достойного
запоминания.

═══════════════════════════════════════════════════════════════════
РАБОТА С КОДОМ — то, что будущий агент не сможет вывести заново, поэтому это ОБЯЗАТЕЛЬНО фиксировать
═══════════════════════════════════════════════════════════════════
Когда фрагмент — это работа с ПО в репозитории, переиспользуемый метод — лишь
половина дела. Другая половина — ГДЕ находится работа и КАКАЯ ВЕРСИЯ победила. Это
нельзя восстановить, прочитав код позже: код показывает текущее состояние,
но не то, на какой он ветке, и не то, что уже было отвергнуто.

Этот раздел НЕ требует более длинной записи. Он просит ПОТРАТИТЬ ТОТ ЖЕ
БЮДЖЕТ на более ценные токены: выбрось пересказ целей, повествование о том, что
ассистент «затем решил», и вставленный код, который ты лишь повторяешь; потрать эти
символы на четыре пункта ниже. Запись, в которой нет ветки, но
процитировано 30 строк diff, — плохой обмен.

1. ВЕТКА / МЕСТО РАБОТЫ — дословно, в `statement` факта. Если во фрагменте
   упоминается или делается checkout `feat/x` / `fix/y`, этот токен ОБЯЗАН присутствовать. Агент,
   который продолжит работу не на той ветке, создаст изменения, которые молча выбросят,
   поэтому этот один токен важнее любой другой детали.

2. КАКАЯ ВЕРСИЯ ПОБЕДИЛА — когда пользователь передумал, назови победителя и отметь
   проигравшего одним придаточным: «остановились на A; промежуточный вариант B отброшен». Не оба
   целиком — одним придаточным. Хранить только последний вариант неправильно: агент, который встретит
   отвергнутый код, должен его узнать, иначе он «починит» всё обратно до отброшенного
   варианта. Фразы вроде `scratch that / go back to / actually, let's / no, not that`
   (а также «забудь это / вернись к / вообще-то давай / нет, не то») отмечают это: то, что следует за ними, — окончательно, то, что до них, — заменено.

3. ТОЧНЫЕ КООРДИНАТЫ, А НЕ ВСТАВЛЕННЫЙ КОД — путь относительно репозитория
   (`qutebrowser/utils/debug.py`, никогда не просто `debug.py`) плюс затронутая функция /
   класс. Если изменилась сигнатура, приведи новую сигнатуру. Если было выбрано значение константы,
   регулярного выражения или литерала, процитируй ИМЕННО ЕГО дословно — но только его, а не
   окружающий блок. Одна точная строка лучше абзаца приблизительного описания.

4. ПРОВЕРЕНО или ЛИШЬ НАПИСАНО — хватит нескольких слов («тесты запущены и проходят» /
   «подтверждено только git diff, тесты не запускались»). «правка внесена» и «правка внесена
   и протестирована» ведут будущего агента к совершенно разным следующим шагам.

Антипаттерн — пересказать цель и потерять координаты:
  плохо:   «переработали логику разбора цвета, чтобы она стала чище.»
  хорошо:  «на feat/q4, в qutebrowser/config/configtypes.py QtColor._parse_value:
            остановились на `mult = 360.0 if kind == 'h' else 255.0`; промежуточная версия,
            использовавшая 255.0 для всего, отброшена. Тесты не запускались.»
  (хорошая запись КОРОЧЕ большинства плохих — она просто тратит каждый символ
   на то, что нельзя вывести заново)

═══════════════════════════════════════════════════════════════════
ПОЛЯ EXPERIENCE
═══════════════════════════════════════════════════════════════════

task          — Название в форме запроса; формулируй так, как пользователь позже СПРОСИТ.
                «опубликовать релиз на платформе xx», а не «publish_release_internal»
                Самодостаточно (без «это», «тот файл», «мы»).

search_keys   — от 0 до 5 альтернативных формулировок, охватывающих важные аспекты
                solution, которые одно поле `task` не покроет. Формулируй как вопросы
                или темы, о которых будущие пользователи СПРОСЯТ. Отличаются от task.
                Опусти, если task уже всё покрывает.

solution      — Полное, самодостаточное содержание, которое действительно нужно пользователю:
                команды, местонахождение учётных данных (НЕ ЗНАЧЕНИЯ учётных данных),
                пути к файлам, упорядоченные шаги, подводные камни, обоснование решений.
                Объединяй многоходовую сквозную работу в ОДНО solution, если она
                образует связную задачу; разбивай на несколько воспоминаний, только когда
                пользователь выполнял несвязанные задачи.

boundary_envs — Конкретные привязки, от которых зависит solution, многострочно в виде «key: value»:
                  среда выполнения / SDK / библиотека + версия
                  API endpoint или сигнатура метода
                  версия внешнего сервиса / middleware
                  ИМЯ переменной окружения (не значение)
                  путь к файлу конфигурации
                  идентификатор хоста / кластера / региона
                Если solution не зависит от окружения, оставь "" (пусто).
                Назначение: когда базовый SDK/middleware обновится, будущие
                потребители смогут проверить это поле и решить, применимо ли solution до сих пор.

confidence  — от 0.0 до 1.0
  1.0   пользователь явно сформулировал это как правило / инструкцию
  0.7   выведено с хорошими доказательствами из действий инструментов
  0.5   выведено слабо; одно наблюдение; неуверенно

═══════════════════════════════════════════════════════════════════
ПОЛЕ FACT — РОВНО ОДНО на фрагмент, без порога ценности
═══════════════════════════════════════════════════════════════════

Ты пишешь ОДИН fact на весь фрагмент — восстановимую запись состояния этой
сессии, а не отшлифованный ретроспективный обзор и никогда не список отдельных находок.
Будущий агент должен иметь возможность продолжить с неё, не принимая предложение,
вывод или частичный поиск за что-то проверенное.

statement  — Компактная сводка ЭТОЙ сессии. У неё сразу две задачи, и она
             обязана выполнять ОБЕ: это поисковый вектор (будущий агент находит её,
             выполняя поиск по свежему сообщению о проблеме, сформулированному так, как пользователь
             описывает проблему), и это полезная нагрузка, по которой этот агент затем действует. Поэтому:

             НАЧИНАЙ с задачи и симптома, словами, которыми воспользовался бы пользователь.
                Именно это делает запись находимой — держи поверхностную форму близкой к тому, как
                о проблеме сообщили бы. Назови конкретную цель и объект
                («освободить место на диске под D:\\WXWork», «скорректировать множитель оттенка
                в QtColor._parse_value на feat/q4», «найти папку
                new_file_search»), никогда не общее «исправить ошибку» / «поискать файл». Включи
                конкретный симптом: строку ошибки, падающую команду,
                неверный вывод.

             ЗАТЕМ приведи координаты и решение.
                путь относительно репозитория, символ и ветку для работы с кодом. Укажи, на чём
                ОСТАНОВИЛИСЬ, и в том же придаточном отметь, что было отброшено
                («остановились на X; промежуточный Y отброшен»). Это та часть, которую
                нельзя вывести заново, прочитав код: код показывает только
                победителя и никогда — то, что Y пробовали и отвергли. Агент, который позже встретит
                отвергнутый вариант, должен суметь его узнать, иначе он
                «починит» код обратно до отброшенной версии.

             ЗАКАНЧИВАЙ статусом доказательств.
                Ровно один из вариантов: завершено, частично завершено, не удалось, заблокировано или
                всё ещё ожидает проверки — плюс как это проверяли («тесты запущены и
                проходят» / «подтверждено только git diff, тесты не запускались»). Включай
                отрицательные результаты и тупики, не преувеличивая их.

             ⚠️ Никогда не останавливайся на повествовании. «Пользователь попробовал X и получил ошибку Y;
             решение пока не найдено» — бесполезная запись: она хорошо находится, но не даёт
             будущему агенту ничего, по чему можно действовать. Если сессия действительно не пришла
             ни к какому решению, скажи, что было исключено и какая следующая неисследованная зацепка, —
             это и есть переиспользуемая часть.

             Субъектом предложений должны быть код и решение, а не
             «пользователь». От 2 до 4 предложений, связная проза, без размеченных разделов.
             Жёсткий потолок — ~400 латинских символов (~200 символов CJK).

             ТОЧНОСТЬ ДОКАЗАТЕЛЬСТВ — обязательно:
             - Записывай только действительно выполненные действия и доказательства, явно
               присутствующие в трейсе. Сохраняй существенные команды, флаги,
               аргументы, ошибки и числа дословно. НИКОГДА не дополняй
               команду привычными флагами и не превращай советы/планы в действия.
             - Сохраняй различие между «попытались», «наблюдали», «проверили»,
               «предположили» и «не решено». Не добавляй эти метки в текст;
               выражай их смысл естественно, например: «попытались …, но упёрлись в
               Access denied» или «предполагается …, пока не проверено».
             - Без вывода инструмента или явного подтверждения НИКОГДА не утверждай, что исправление
               сработало, причина установлена, файл/папка не
               существует или тесты прошли.
             - Ограничивай каждый отрицательный вывод тем, что действительно искали, и
               перечисляй КАЖДОЕ явное ограничение охвата, которое может его
               опровергнуть, особенно отказы в доступе и максимальную глубину поиска:
               «не найдено в просмотренных частях C:\\ и D:\\; некоторые
               каталоги пропущены из-за Access denied, а поиск к тому же был
               ограничен по глубине». Не опускай ни одно ограничение ради того, чтобы
               сводка выглядела красивее. Никогда не превращай частичный поиск в глобальное
               отсутствие.
             - Утверждай причинность как достоверную, только если трейс напрямую её
               подтверждает. Иначе сохраняй оговорку («предположительно» / «выведено» / «пока не
               проверено»); не переписывай
               неверное допущение теста как первопричину в системе.

             КРИТИЧНО — этот текст И ЕСТЬ поисковый вектор, и это единственное,
             с чем сопоставляется будущий запрос. Общая сводка
             бесполезна, потому что КАЖДАЯ сессия выглядит как общая сводка: она
             совпала бы с каждым запросом и не ответила бы ни на один. Поэтому ты ОБЯЗАН назвать
             конкретные якоря, которые делают ЭТУ сессию находимой: реальные пути
             к файлам, имена функций / символов, названия веток, команды, строки
             ошибок, версии, ключи и значения конфигурации, имена хостов / сервисов.
             Если кто-то позже будет искать любую из этих конкретных деталей, эта
             сводка должна оказаться в результатах.
               хорошо: «исправление падающего `npm run build` в CI. Прочитаны
                      .github/workflows/ci.yml и package.json; причина сведена к webpack
                      5.74, который получает ERR_OSSL_EVP_UNSUPPORTED под node 18. Повышение
                      node в workflow до 20 привело к успешной сборке; на node 18 ошибка
                      по-прежнему воспроизводится локально.»
               хорошо: «на ветке feat/q0, в qutebrowser/utils/debug.py signal_name:
                      PyQt<5.11 отдаёт имя только через repr(sig), а repr бывает
                      как в форме с квадратными скобками, так и с круглыми. Остановились на двух шаблонах,
                      которые пробуются по очереди через fullmatch с выходом при первом совпадении;
                      версия с одним регулярным выражением отброшена. Подтверждено git diff, тесты не
                      запускались.»
               плохо:  «пользователь хотел исправить ошибку сборки, агент посмотрел какие-то
                      конфигурационные файлы, изменил какой-то код и всё исправил.»
                      (ни пути, ни команды, ни строки ошибки, ни версии — не за что
                       зацепиться поиску; каждая сессия читается в точности так же)
               плохо:  «исправлена проблема совместимости при разборе имени сигнала в функциональной
                      ветке.»
                      (какая ветка? какой файл? какая функция? какая из двух
                       конкурирующих версий победила? ничто здесь не переживёт того, что
                       запись найдут через неделю)
             Примеры точности (плохо → хорошо):
               «ran Get-ChildItem -Force» → «ran Get-ChildItem»
                 (в трейсе не было `-Force`; не выдумывай его)
               «подтверждено, что new_file_search не существует» →
                 «new_file_search не найден в просмотренных частях C:\\ и
                  D:\\; некоторые каталоги пропущены из-за Access denied или ограничения
                  глубины, поэтому расследование выполнено лишь частично»
               «одинаковые полезные нагрузки вызывают ложную ошибку блокировки» →
                 «проверочный скрипт предполагал, что последним пишущим всегда является фиксированный
                  rank; это допущение не выполняется, поэтому есть ли ошибка блокировки,
                  пока не проверено»

             НЕ записывай приветствия и чистую болтовню. Если фрагмент не установил
             вообще ничего, выведи "fact": null.

files      — 0..N абсолютных или относительных к репозиторию путей к ФАЙЛАМ ИЛИ КАТАЛОГАМ, с которыми действительно
             работали или которые исследовали в этой сессии. Сохраняй исследованные
             корни, такие как `C:\\` и `D:\\`. Включай только пути, к которым действительно
             обращались/в которых искали, а не пути, которые лишь предлагались или планировались;
             [], если таких нет.

═══════════════════════════════════════════════════════════════════
КОНТЕКСТ ХОСТА (передаётся SDK)
═══════════════════════════════════════════════════════════════════
- workspace_id present: {workspace_present}
- branch present: {branch_present}

Когда workspace_id отсутствует, solution не может опираться на невысказанный
локальный контекст проекта — явно укажи любой нужный репозиторий / путь / сервис внутри
`solution` или `boundary_envs`, чтобы воспоминание оставалось пригодным само по себе.

═══════════════════════════════════════════════════════════════════
РАЗГОВОР
═══════════════════════════════════════════════════════════════════
{conversation_block}

═══════════════════════════════════════════════════════════════════
ВЫВОД (только строгий JSON, без markdown)
═══════════════════════════════════════════════════════════════════
{{
  "experiences": [
    {{
      "task": "...",
      "search_keys": ["...", "..."],
      "solution": "...",
      "boundary_envs": "...",
      "confidence": 0.9
    }}
  ],
  "fact": {{
    "statement": "...",
    "files": ["..."]
  }}
}}

ОБЯЗАТЕЛЬНО: ты ОБЯЗАН вывести хотя бы ОДИН experience. НЕ возвращай пустой список.
Даже если задача выглядит простой или решена с первого раза, всё равно зафиксируй
переиспользуемую суть сделанного (метод / команду / инструкцию). Если сессия скудная,
требуется только один, самый ценный experience, — но никогда
не выводи пустой массив "experiences".

"fact" — это ОДИН объект, никогда не список: одна запись на сессию. Используй
"fact": null, только если фрагмент — чистая болтовня, которая ничего не установила.
"""

CODING_RECONCILE_PROMPT = """\
Ты решаешь, как слить новые черновики воспоминаний о работе с кодом с существующими воспоминаниями пользователя.

Для каждого нового черновика выбери одно из:
  ADD     — ни одно существующее воспоминание не описывает ту же задачу/аспект
  UPDATE  — существующее воспоминание описывает ту же задачу; новый черновик заменяет его
            (solution могло измениться, окружение могло обновиться и т. п.)
  SKIP    — дубликат существующего; ничего нового

Кроме того, ты можешь выдать операции DELETE для существующих кандидатов, если новое
содержание делает их устаревшими или недействительными:
  DELETE  — новый разговор ЯВНО заменяет/отменяет/делает недействительным
            существующее воспоминание, которое нельзя исправить через UPDATE. Примеры:
              * пользователь говорит «больше не используй X», а X присутствует только как
                отдельное воспоминание (не то, которое добавляется/обновляется)
              * boundary_envs кандидата (сервис / endpoint / SDK) больше не существует,
                и новый разговор подтверждает это прекращение поддержки

Правила:
- «Та же задача» означает, что существующее воспоминание и новый черновик были бы оба
  верными ответами на один и тот же будущий запрос пользователя.
- Если solution различается, предпочитай UPDATE (историю мы не храним).
- Если и task, и solution близко совпадают, выбирай SKIP.
- DELETE только при ЯВНЫХ доказательствах того, что кандидат недействителен/устарел.
  Никогда не делай DELETE лишь потому, что кандидат выглядит «несвежим».
- Операций в выводе может быть больше, чем черновиков, если есть DELETE.

═══════════════════════════════════════════════════════════════════
НОВЫЕ ЧЕРНОВИКИ
═══════════════════════════════════════════════════════════════════
{drafts_block}

═══════════════════════════════════════════════════════════════════
СУЩЕСТВУЮЩИЕ КАНДИДАТЫ (для каждого черновика, найдены по сходству task)
═══════════════════════════════════════════════════════════════════
{candidates_block}

═══════════════════════════════════════════════════════════════════
ВЫВОД (только строгий JSON, без markdown)
═══════════════════════════════════════════════════════════════════
{{
  "ops": [
    {{"draft_idx": 0, "action": "ADD"}},
    {{"draft_idx": 1, "action": "UPDATE", "target_experience_id": "exp_xxx", "reason": "..."}},
    {{"draft_idx": 1, "action": "DELETE", "target_experience_id": "exp_yyy", "reason": "пользователь явно отказался от Y"}},
    {{"draft_idx": 2, "action": "SKIP",   "reason": "дубликат"}}
  ]
}}

Если черновиков нет, выведи {{"ops": []}}.
"""

CODING_FACT_RECONCILE_PROMPT = """\
Ты ведёшь РАБОЧИЕ ФАКТЫ уровня сессии. Каждый statement обобщает один целый
трейс/сессию: задачу пользователя, общий подход и результат. Это не
атомарное утверждение.

Каждый новый факт сессии ниже БУДЕТ сохранён; это решаешь не ты. Твоя единственная
задача — обнаружить продолжение задачи: продолжает ли новая сессия продвигать
ТУ ЖЕ задачу пользователя, что и существующий факт сессии? Если да, замени (SUPERSEDE) более старый факт, чтобы
связи образовали межсессионную цепочку прогресса по этой задаче.

Помечай существующий факт как заменённый ТОЛЬКО при сильных доказательствах того, что:
  - Субъекты совпадают: обе записи об ОДНОЙ И ТОЙ ЖЕ сущности — том же
    человеке, том же файле/модуле, том же хосте/сервисе. Общий субъект
    необходим, но не достаточен; И
  - Цель пользователя по существу ТА ЖЕ, а не просто из той же темы/проекта;
    И
  - Новый трейс продолжает, повторяет, расширяет, проверяет или завершает работу,
    записанную в существующем трейсе.

НЕ заменяй, когда:
  - В двух записях названы разные субъекты. Два человека в одной группе, два файла
    в одном модуле, два хоста в одном кластере — это ПАРАЛЛЕЛЬНЫЕ, а не последовательные записи: состояние одного
    человека не является более новой версией состояния другого. Если субъект показан
    как (unspecified), суди только по statement.
  - Сессии лишь упоминают один и тот же файл, символ, компонент, репозиторий,
    ошибку или технологию, но преследуют разные цели пользователя.
  - Одна задача лишь даёт контекст или приём для другой задачи.
  - Связь неочевидна. Будь консервативен: INSERT — безопасный вариант по умолчанию;
    слияние несвязанных сессий уничтожает их отдельную историю задач.

Относись к каждому statement как к тексту, ограниченному доказательствами. Не переосмысливай вывод
внутри него как установленную причину и не используй общую догадку/ошибку как доказательство того, что
цели пользователя совпадают. Твоё решение касается только продолжения задачи; не
«исправляй», не дополняй и не приукрашивай ни одну из записей сессий.

Примеры:
  existing: «Пользователю нужно было починить npm run build в CI; причина сведена к
             ERR_OSSL_EVP_UNSUPPORTED под Node 18, workflow пока не изменён.»
  new:      «Пользователь продолжил чинить ту же сборку CI; повысил Node в
             .github/workflows/ci.yml до 20, и npm run build прошёл.»
                                                                 → SUPERSEDE

  existing: «Пользователю нужно было исправить обработку истечения JWT в
             auth/middleware.ts; добавлена логика обновления.»
  new:      «Пользователю нужно было добавить логирование производительности в
             auth/middleware.ts; введена метрика задержки.»
                                                                 → оставить оба
            (тот же файл/проект, другая цель пользователя)

═══════════════════════════════════════════════════════════════════
НОВЫЕ ФАКТЫ СЕССИЙ
═══════════════════════════════════════════════════════════════════
{drafts_block}

═══════════════════════════════════════════════════════════════════
СУЩЕСТВУЮЩИЕ ФАКТЫ СЕССИЙ (для каждого нового факта, найдены по сходству statement)
═══════════════════════════════════════════════════════════════════
{candidates_block}

═══════════════════════════════════════════════════════════════════
ВЫВОД (только строгий JSON, без markdown)
═══════════════════════════════════════════════════════════════════
{{
  "ops": [
    {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "продолжает ту же задачу по исправлению CI"}},
    {{"draft_idx": 1, "supersedes": []}}
  ]
}}

Используй только id фактов, которые есть в списке кандидатов для того же draft_idx.
Если нигде ничего не заменяется, выведи {{"ops": []}}.
"""

CODING_CHAIN_SUMMARY_PROMPT = """\
Задача пользователя в хранилище рабочей памяти продвигалась на протяжении нескольких сессий. Ниже —
сводки сессий в цепочке прогресса этой задачи, от старейшей к новейшей, последней идёт
текущая сессия.

Кратко изложи, как ОДНА И ТА ЖЕ задача продвигалась от сессии к сессии до текущего состояния.
Охвати каждый важный этап в хронологическом порядке. Для каждого этапа сохраняй,
где это есть: фактическое действие или изменение, его непосредственный результат и любую
нерешённую проблему или ограничивающее условие. Закончи явным текущим статусом.

Правила:
  - Это только сжатие. Сообщай ТОЛЬКО то, что сказано в записях; никогда не добавляй и не
    дополняй команду, причину, мотив, действие, результат теста, состояние успеха или
    глобальный отрицательный вывод.
  - Сохраняй статус доказательств в точности: «попытались» — не «завершено», «наблюдали» —
    не «проверено», «предположили» — не «установлено», а «не решено» остаётся нерешённым.
    Сохраняй слова неуверенности и ограничения поиска/доступа/охвата.
  - Точно указывай текущий итоговый статус (завершено, частично завершено,
    не удалось, заблокировано или всё ещё ожидает проверки). Никогда не повышай его на основании
    правдоподобной причинной истории или более поздней записи, которая его не проверила.
  - Когда в записях упоминаются предполагаемая причина и более поздний результат, связывай их
    причинно, только если в записи прямо сказано, что эта причина проверена.
  - Сохраняй конкретные якоря для поиска: пути к файлам, символы, команды, строки
    ошибок, версии, ключи/значения конфигурации и важные числовые значения, которые
    важны для прогресса.
  - Для цепочек из 2–3 поколений не сжимай развитие чрезмерно в одно
    предложение. Предпочитай 2–4 компактных абзаца, когда это полезно, или читаемую прозу с
    чёткой целью задачи, поэтапным развитием и текущим статусом.
  - Не копируй механически всю историю. Опускай повторы и малоценные
    детали, сохраняя важные действия, непосредственные результаты и остатки.
  - Не придумывай заголовки этапов или даты. Упоминай дату, только если записи
    делают её значимой; голые временные метки — это шум.
  - Если в записях сказано, что более старые ревизии опущены, явно укажи, что
    более ранняя история опущена; не создавай впечатления, что переданные записи полны.
  - Пиши на том же языке, на котором написаны записи.
  - Без вступления и без обрамляющих кавычек.

Пример
  записи:
    (2026-07-20) Пользователю нужно было починить npm run build в CI; причина сведена к
                 ERR_OSSL_EVP_UNSUPPORTED под Node 18, workflow пока не
                 изменён.
    (2026-07-24) Пользователь продолжил это исправление CI; повысил Node в
                 .github/workflows/ci.yml до 20, но кэш зависимостей
                 по-прежнему воспроизводил старую ошибку.
    (now)        Пользователь продолжил проверку того же исправления; после очистки
                 кэша npm команда npm run build прошла.
  вывод:
    Цель задачи — починить npm run build в CI. Сначала причина была сведена к
    ERR_OSSL_EVP_UNSUPPORTED под Node 18, а workflow ещё не был изменён;
    затем в .github/workflows/ci.yml версия была повышена до Node 20, но кэш
    зависимостей сохранял старую ошибку. Наконец, после очистки кэша npm
    npm run build прошёл, так что это исправление сборки сейчас проверено и завершено.

═══════════════════════════════════════════════════════════════════
ЗАПИСИ
═══════════════════════════════════════════════════════════════════
{chain_block}

═══════════════════════════════════════════════════════════════════
ВЫВОД (только сама сводка, больше ничего)
═══════════════════════════════════════════════════════════════════
"""


# ================================================================
# Episode / topic summaries
# ================================================================

EPISODE_SUMMARY_PROMPT = """Ты составляешь сводку ОДНОГО эпизода разговора с пользователем.

Эпизод — это один отрезок обсуждения: одна тема, о которой говорили,
возможно, на протяжении нескольких сессий записи.

## Воспоминания, зафиксированные в этом эпизоде (от старых → к новым)

{memories}

---

Напиши одну плотную сводку того, что произошло / что обсуждалось в этом эпизоде.

Правила:

* 2–4 предложения, в третьем лице, начиная с «Пользователь ...» (или с имени человека,
  если воспоминания о ком-то другом).
* Свяжи воспоминания в один связный рассказ — через эпизод обычно проходит
  общая нить (план, проблема, поездка, решение).
* Сохраняй конкретные детали: имена, места, числа, даты.
* НЕ выдумывай ничего, чего нет в воспоминаниях.
* НЕ перечисляй воспоминания по одному; синтезируй их.
* Язык вывода должен совпадать с языком воспоминаний.

Верни ТОЛЬКО текст сводки, без вступления, без JSON, без кавычек."""

TOPIC_SUMMARY_PROMPT = """Ты составляешь сводку всего, что известно об ОДНОЙ теме.

## Тема

{topic_name}

## Воспоминания по этой теме (от старых → к новым)

{memories}

---

Напиши одну плотную сводку того, что известно о пользователе применительно к этой
теме.

Правила:

* 2–4 предложения, в третьем лице, начиная с «Пользователь ...» (или с имени человека,
  если воспоминания о ком-то другом).
* Охвати тему целиком: опиши текущее положение дел и упоминай, как оно
  развивалось, только если изменение важно.
* Сохраняй конкретные детали: имена, места, числа, даты.
* НЕ выдумывай ничего, чего нет в воспоминаниях.
* НЕ перечисляй воспоминания по одному; синтезируй их.
* Язык вывода должен совпадать с языком воспоминаний.

Верни ТОЛЬКО текст сводки, без вступления, без JSON, без кавычек."""


# ================================================================
# System 2 evolve (pipelines/system2_agent.py)
# ================================================================

SYSTEM2_AGENT_PROMPT = """Ты — агент когнитивной обработки (Agent). Твоя задача — выращивать когнитивные структуры более высокого порядка из сырых данных памяти пользователя.

## Архитектура памяти

### VDB (векторная база данных) — только чтение
| Слой | Описание |
|-------|-------------|
| L0 BASIC_INFO | Атрибуты пользователя (имя, возраст, профессия) |
| L1 RAW | Исходные расшифровки разговоров |
| L2 FACT | Атомарные факты, извлечённые из разговоров |
| L3 SUMMARY | Сводки сессий |
| L4 IDENTITY | Черты личности, предпочтения, привычки |
| L5 KNOWLEDGE | Предметные знания |

### Graph (граф знаний) — ты единственный, кто в него пишет
| Слой | Описание |
|-------|-------------|
| L6 SCHEMA | Поведенческие паттерны — привязаны к области, атомарны, неизменяемы после создания |

## Что такое L6 Schema?

Schema — это один межсобытийный поведенческий паттерн в долгосрочной модели пользователя,
состоящий из следующих трёх компонентов:


- **Circumstance (обстоятельства)**: область/тема/ситуация, в которой наблюдается этот паттерн. Schema ОБЯЗАНА оставаться в пределах своих обстоятельств — НЕ обобщай на другие области. Межобластной абстракцией система занимается отдельно.
- **Pattern (паттерн)**: привычное поведение, стиль мышления или склонность к действиям пользователя в этих обстоятельствах.
- **Insight (инсайт)**: лежащий в основе психологический мотив или ментальная модель.

### Формат содержания
Используй одно предложение, объединяющее все три компонента:
«Когда [обстоятельства], пользователь [паттерн] — что отражает [инсайт].»

Для устойчивых паттернов, связанных с эмоциями, терапией, стрессом, горем или травмой,
не растворяй конкретный автобиографический фон в общей
характеристике личности. Предпочитай привязанную структуру, которая сохраняет:
«Триггер/фон -> повторяющаяся эмоциональная реакция -> наблюдаемый ресурс совладания.»
Включай только те триггеры, реакции и ресурсы совладания, которые есть в доказательствах,
принадлежащих пользователю (user-owned). Совет ассистента — не наблюдаемый ресурс совладания пользователя.

### Правила
- **Атомарность**: один паттерн на Schema. Два разных паттерна → две Schema.
- **Неизменяемость**: после создания содержание НИКОГДА не меняется.
- **Только доказательства**: новые факты, которые лишь подтверждают существующую формулировку → вызывай
  `add_evidence`. Если новые доказательства существенно меняют, исправляют или сужают
  текущее устойчивое состояние, используй `revise_schema`, чтобы старая версия сохранилась для
  аудита, но была исключена из активного поиска.
- **Привязка к области**: оставайся в пределах наблюдаемой области. Межобластной абстракцией занимается отдельный системный процесс.
- **Отделяй факты от паттернов**: отдельная явная идентичность, состояние здоровья,
  использование оборудования, принадлежность, проект или предпочтение относятся к памяти состояний L2,
  а не к L6. L6 требует доказательств, принадлежащих пользователю, которые представляют как минимум две независимые
  сырые записи (raw) или сессии. Один согласованный факт L2 может представлять несколько записей;
  проверяй его source_raw_memory_ids, а не считай узлы фактов.
- **Безопасность субъекта**: факты из одного исходного фрагмента могут описывать других людей или
  примеры. Создавай пользовательскую Schema, только когда материал явно приписывает
  паттерн пользователю. В противном случае не выводи для этого материала никакой операции.
- **Покрытие кандидатов**: при проверке исходного контекста (source-context review) учти каждый перечисленный
  факт-кандидат: либо используй его как доказательство в `create_schema`/`add_evidence`,
  либо выдай `skip_fact`. Сырой контекст может подтвердить его субъект или восстановить опущенную
  деталь, но не должен порождать несвязанные Schema.
- **Порог доказательств**: для создания L6 нужен один или несколько фактов-доказательств,
  принадлежащих пользователю и представляющих как минимум две независимые сырые записи или сессии.
  Совет ассистента сам по себе не устанавливает паттерн пользователя.

### Хорошие и плохие примеры
✅ «Когда пользователь готовит, он строго следует шагам рецепта и точно отмеряет ингредиенты — что отражает потребность во внешней структуре, чтобы справляться с неопределённостью.»
✅ «Когда пользователь играет в игры, он всегда сверяется с прохождениями, чтобы добиться 100% завершения, — что вызвано низкой терпимостью к незавершённости.»
✅ «После неожиданной потери наставника напоминания о смертности могут внезапно возвращать горе; пользователь делает паузу для размышлений и совершает тихие прогулки, чтобы вновь обрести равновесие.»
❌ «Пользователь подходит к музыке как к средству творческого синтеза и построения культурных мостов, постоянно смешивая разные музыкальные традиции...» (несколько паттернов слиты, слишком широко)
❌ «Пользователь увлечён многими вещами и ценит качество.» (нет обстоятельств, слишком расплывчато)
❌ «Пользователь ориентирован на смысл и устойчив.» (стирает устойчивый триггер и наблюдаемые доказательства совладания)

## Твой порядок работы

Входные материалы (тебя вызывают, только когда существует хотя бы один кластер):
- **Результаты кластеризации (Cluster Results)**: основной вход — факты, сгруппированные по семантическому сходству
- **Некластеризованные факты (дополнительно)**: факты, не попавшие ни в один кластер; приоритет ниже, чем у результатов кластеризации

Для каждой группы фактов (кластеризованных или нет):
1. **Поиск существующих Schema**: если существующая Schema уже отражает этот паттерн, вызови `add_evidence`. Используй `revise_schema`, только если старая формулировка после добавления новых доказательств стала бы существенно неполной или вводящей в заблуждение.
2. **Создание новой Schema**: только если ни одна существующая Schema не охватывает этот паттерн. Одно предложение, три компонента.
3. **Построение связей**: если две Schema тематически связаны, используй `add_edge` (RELATED_TO).

## Принципы

- Все операции с Graph ОБЯЗАНЫ выполняться через инструменты (tools)
- Содержание Schema НЕИЗМЕНЯЕМО — никогда не создавай заново то, что уже существует
- Предпочитай `add_evidence` созданию дубликатов
- Лучше не создавать, чем создавать некачественные узлы
- Одна Schema = один атомарный паттерн в одной области
- При назначении тегов предпочитай переиспользовать теги из списка существующих тегов"""


# ================================================================
# Fragments assembled in code
# ================================================================

# Display name of this language, used in logs and docs.
LANGUAGE_NAME = "Русский"

# Appended to every memory-writing prompt ONLY when the caller set the
# language explicitly (per call or MemoryConfig.language). Auto-detected
# requests never see it.
OUTPUT_LANGUAGE_DIRECTIVE = """

---

# ЯЗЫК ВЫВОДА

Пиши каждое значение на естественном языке, которое ты выводишь (текст воспоминаний, сводки, обоснования, запросы), на русском языке, на каком бы языке ни были разговор или существующие воспоминания. Это правило имеет приоритет над любым правилом выше, требующим совпадения с языком входных данных. Сохраняй JSON-ключи, имена полей, значения перечислений, названия операций, ID, код, пути к файлам, команды, сообщения об ошибках и имена собственные в точности как есть.
"""

# enable_intention=False: the "two kinds of memory" section of
# EXTRACT_SYSTEM_PROMPT is replaced by a single-bucket section. The pattern
# must match this language's EXTRACT_SYSTEM_PROMPT.
NO_INTENTION_SECTION_PATTERN = r"# ДВА ВИДА ПАМЯТИ.*?(?=\n# ВЛАДЕЛЕЦ \(OWNER\)\n)"

NO_INTENTION_MEMORY_SECTION = (
    "# ПАМЯТЬ\n"
    "\n"
    "Ты извлекаешь один вид памяти: **memory** (воспоминания).\n"
    "\n"
    "## memory\n"
    "\n"
    "Сюда идёт всё долговечное и достойное запоминания о пользователе — и о любом другом\n"
    "названном по имени человеке в разговоре:\n"
    "\n"
    "* предпочтения, мнения, ценности, отношение к чему-либо\n"
    "* события, действия, опыт\n"
    "* привычки, модели поведения\n"
    "* отношения с людьми, черты характера\n"
    "* объективные факты, решения, ограничения\n"
    "* текущие занятия\n"
    "* **планы на будущее / предстоящие действия**, которые стоит запомнить\n"
    "  (помещай их в `memory`; НЕ придумывай отдельный раздел intentions)\n"
    "\n"
    "Неявные предпочтения НУЖНО выводить, когда на них явно указывают обстоятельства.\n"
    "\n"
    "НЕ разделяй «какой человек пользователь» и «что произошло».\n"
    "И то и другое идёт в `memory`.\n"
    "\n"
    "---\n"
    "\n"
)

# (old, new) pairs applied in order after the section swap.
NO_INTENTION_REPLACEMENTS = (
    (
        "Каждое воспоминание и каждое намерение ОБЯЗАНО содержать `owner`",
        "Каждое воспоминание ОБЯЗАНО содержать `owner`",
    ),
)

INTENTION_DISABLED_NOTE = (
    "\n\n---\n\n# НАМЕРЕНИЯ (INTENTION) ОТКЛЮЧЕНЫ\n"
    "Извлечение намерений отключено. Даже если в примерах few-shot встречается "
    "`intentions`, **не** выводи этот ключ; помещай планы на будущее в `memory`.\n"
)

# Coding / working extractor: wraps the history and the new messages.
CODING_CONVERSATION_BLOCK = (
    "ПОСЛЕДНИЕ 5 РЕПЛИК ПОЛЬЗОВАТЕЛЯ (ТОЛЬКО КОНТЕКСТ; не извлекай их повторно):\n"
    "{history}"
    "\n\nНОВЫЕ СООБЩЕНИЯ (извлекай только из этой полной записи):\n"
    "{new}"
)
CODING_EMPTY_BLOCK = "(нет)"

# Name line at the top of a multi-person conversation. Also stored in L1_RAW,
# so pipelines.base parses every language's form back.
USER_NAME_LINE = "Имя пользователя — {name}"

# System 2 single-call mode: output contract appended to SYSTEM2_AGENT_PROMPT.
SYSTEM2_OUTPUT_INSTRUCTIONS = """

## Формат вывода

НЕ вызывай инструменты. Сразу выведи JSON-массив операций, обёрнутый в блок кода ```json.

Доступные операции:

1. **create_schema** — создать новую поведенческую Schema L6
   ```{"op": "create_schema", "schema_kind": "behavior_pattern", "content": "краткий паттерн, понятный пользователю", "retrieval_text": "поведение плюс связанные ситуации", "evidence_list": ["fact_node_id_1", "fact_node_id_2"], "tags": ["tag1"]}```

2. **add_evidence** — добавить доказательства к существующей Schema (содержание остаётся неизменным)
   ```{"op": "add_evidence", "node_id": "existing_schema_node_id", "evidence_list": ["new_fact_id_1"]}```

3. **revise_schema** — создать новую версию, когда новые доказательства существенно меняют текущее состояние, и вывести старую версию из активного поиска. Не используй для совместимых деталей.
   ```{"op": "revise_schema", "node_id": "old_schema_id", "schema_kind": "explicit_state", "content": "обновлённый текущий профиль", "retrieval_text": "обновлённый текст для поиска", "evidence_list": ["new_fact_id_1"], "tags": ["tag1"], "reason": "почему старая формулировка вводила бы в заблуждение"}```

4. **add_edge** — создать связь между двумя Schema
   ```{"op": "add_edge", "source_id": "schema_id_1", "target_id": "schema_id_2", "reason": "причина связи"}```

5. **skip_fact** — явно пометить факт-кандидат как проверенный, не создавая
   Schema. Используй только для фактов о другом человеке, преходящих событий, советов ассистента,
   которые не устанавливают черту пользователя, или фактов, уже полностью охваченных.
   ```{"op": "skip_fact", "node_id": "candidate_fact_id", "reason": "не устойчивый паттерн пользователя"}```

## Контракт вывода

1. Вывод ОБЯЗАН быть JSON-массивом, обёрнутым в блок кода ```json.
2. Если данных недостаточно для надёжных выводов, выведи `[]`. При
   проверке исходного контекста (source-context review) `[]` означает, что каждый кандидат в этой проверке
   был рассмотрен и ни один не подтверждает устойчивую Schema.
3. НИКАКОГО текста вне блока кода.
4. ID в evidence_list должны браться из node_id фактов, предоставленных в материалах.
5. node_id для add_evidence / revise_schema должен браться из ID существующих узлов Graph.
6. При проверке исходного контекста каждый факт-кандидат должен оказаться в evidence_list или в skip_fact."""

# Appended to SYSTEM2_OUTPUT_INSTRUCTIONS when the schema evidence gate is on.
SYSTEM2_SCHEMA_EVIDENCE_GATE = """

7. L6 представляет только межсобытийные поведенческие паттерны. create_schema должна использовать доказательства, принадлежащие пользователю (user-owned) и представляющие как минимум две независимые сырые записи (raw) или сессии. Один согласованный факт может подойти, если source_raw_memory_ids содержит несколько независимых записей.
8. Не создавай L6 для отдельной явной идентичности, состояния здоровья, использования оборудования, принадлежности, проекта или предпочтения. Этими фактами владеет каноническая проекция состояний L2."""

# (old, new) pairs that turn the tool-calling wording of SYSTEM2_AGENT_PROMPT
# into single-call wording. Each `old` must occur in this language's prompt.
SYSTEM2_SINGLE_CALL_REPLACEMENTS = (
    ("- Все операции с Graph ОБЯЗАНЫ выполняться через инструменты (tools)\n", ""),
    ("вызови `add_evidence`", "используй операцию add_evidence"),
    ("используй `add_edge` (RELATED_TO)", "используй операцию add_edge"),
)

# System 2 user message (materials). Keys are fixed; values are format
# strings with the named fields shown.
SYSTEM2_MATERIALS = {
    "title": "## Предобработанные материалы\n",
    "stats": (
        "### Статистика\n- Всего фактов в VDB: {total}\n"
        "- Свежие факты (к обработке): {fresh} (исключено как уже использованные доказательства={evidenced})\n"
        "- Найдено кластеров: {clusters}\n"
        "- Фактов в кластерах: {clustered}, некластеризованное дополнение: {unclustered}\n"
        "- Всего Schema в Graph: {graph_total} (найдено={recalled})"
    ),
    "graph_status_empty": "- Состояние Graph: **ПУСТ** (первый запуск когнитивной обработки)\n",
    "clusters_header": "### Результаты кластеризации\n",
    "label_holistic": "{n} межсессионных фактов о пользователе; только подкреплённые доказательствами устойчивые эмоциональные/терапевтические паттерны",
    "label_source_context": "{n} фактов-кандидатов; сырая запись служит только для проверки субъекта/деталей",
    "label_topic": "{n} фактов, тема",
    "raw_label": "Соответствующий сырой фрагмент для каждого кандидата",
    "holistic_note": (
        "Это один ограниченный ночной проход целостной консолидации. Создай не более "
        "{max_schemas} привязанных терапевтических Schema. "
        "Предпочитай объединять устойчивый триггер/фон, повторяющуюся эмоциональную реакцию "
        "и наблюдаемый ресурс совладания или ограничение решений из разных сырых записей/сессий. "
        "Перед create_schema объедини raw_sources для её ID доказательств и требуй как минимум два "
        "различных ID сырых источников; два факта из одной сырой записи — это одно событие. "
        "Выведи [], если доказательств недостаточно.\n"
    ),
    "companion_header": "**Подсказки о сопутствующих фактах из независимых источников (кандидаты, а не выводы):**",
    "unclustered_header": "### Некластеризованные факты (дополнительно)\n",
    "unclustered_hint": "Факты ниже не попали ни в один кластер выше. Просмотри их после тем кластеров; приоритет ниже, чем у результатов кластеризации.\n",
    "forward_header": "### Связанные узлы Graph (найдены поиском по центроидам кластеров, совпадений: {count})\n",
    "graph_empty": "### Существующие узлы Graph\nGraph сейчас ПУСТ — это первый запуск когнитивной обработки. НЕ ищи в Graph (поиск ничего не вернёт). Сразу создавай Schema по результатам кластеризации.\n",
    "graph_no_recall": (
        "### Существующие узлы Graph\n"
        "В Graph {graph_total} Schema, "
        "но векторный поиск по центроидам не нашёл совпадений. На основе результатов кластеризации реши, нужны ли новые Schema.\n"
    ),
    "reverse_header": "### Обратные ссылки Graph (факты VDB, на которые ссылаются существующие Schema)\n",
    "tags_header": "### Существующие теги (предпочитай переиспользовать их, а не создавать синонимы)\n",
    "closing": (
        "Проанализируй материалы выше и выведи JSON-массив операций. "
        "Реши, создавать ли новые Schema или добавлять доказательства к существующим. "
        "Если данных недостаточно для надёжных выводов, выведи пустой массив `[]`. "
        "При назначении тегов предпочитай переиспользовать теги из списка существующих тегов выше."
    ),
}