Skip to content
Python

feat(sdk): prompts in 11 languages and an explicit language option

alvinfei16da11f788e4
diff --git a/.env.example b/.env.example
index a44ef8e..0394a75 100644
--- a/.env.example
+++ b/.env.example
@@ -78,6 +78,7 @@ MEMORY_VECTOR_STORE=chroma
# ── 处理模式 ──
# MEMORY_MODE=pro # lite | pro | ultra
+# MEMORY_LANGUAGE= # 提示词/记忆语言:en | zh-Hans | zh-Hant | ja | es | de | pt | fr | ko | ru | id;空=zh/en 自动检测
# ── Coding Memory(生产力 / 编码场景独立链路,默认开启)──
# 独立于 chat 记忆的一套链路:写入端对 messages 判类,coding 场景抽「任务→方案」存 sqlite;
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 97e4530..48f0d1e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,35 @@ Hy Memory and MemHub are versioned and released independently.
## Unreleased
+- Hy Memory: LLM prompts now ship in 11 languages: `en`, `zh-Hans`,
+ `zh-Hant`, `ja`, `es`, `de`, `pt`, `fr`, `ko`, `ru` and `id`. They live in
+ one registry, `hy_memory/prompts/`, with one module per language. Call
+ sites use `get_prompt(name, language)`, so a new language only needs a new
+ module. The registry covers chat extraction (system prompt, basic_info,
+ intentions, few-shot including Example 11), the no-intention variant,
+ reconcile and its search-query prompt, the working/coding extractor, both
+ coding reconcilers and the chain summary, the episode and topic summaries,
+ System 2 evolve, and the user name line. The English and Simplified Chinese
+ strings are unchanged byte for byte, and a test pins them. The old names
+ (`prompts_zh.*_ZH`, `extractor.EXTRACT_SYSTEM_PROMPT`, ...) still import.
+ The nine new languages are machine translations, and native-speaker review
+ is recommended.
+- Hy Memory: new optional `language` to choose the prompt language
+ explicitly. Set it on `MemoryConfig.language` (env `MEMORY_LANGUAGE`) for
+ a client default, or per call on `add` / `async_add`, `add_extracted`,
+ `finalize_session`, `evolve` and `sweep`. A per-call value overrides the
+ config. The value goes through every LLM call of the request: extract and
+ basic profile, reconcile, the coding path, the summaries and System 2.
+ Aliases: `zh`, `zh-CN` → `zh-Hans`; `zh-TW`, `zh-HK` → `zh-Hant`; `pt-BR` →
+ `pt`. An unknown code raises `ValueError` listing the supported codes, and
+ the HTTP server returns 400. With an explicit language, memories are
+ written in that language even when the conversation uses another one.
+ Without a language, the existing zh/en auto-detection runs unchanged and
+ memories keep the source language. `search` has no `language`: its judge
+ and rewrite prompts are English-only and keep the query's language.
+- Hy Memory: the HTTP server accepts `language` on `/api/v1/add` and
+ `/api/v1/add_extracted`.
+
## Hy Memory 2.0.10 — 2026-11-01
- New `hy_memory.reembed` module for switching the embedding
diff --git a/README.md b/README.md
index 8bd3e94..50bc100 100644
--- a/README.md
+++ b/README.md
@@ -98,6 +98,12 @@ export OPENAI_API_KEY="sk-your-key"
See the [Environment Variable Reference](docs/env_reference.md) for the full list.
+Prompts ship in 11 languages (`en`, `zh-Hans`, `zh-Hant`, `ja`, `es`, `de`, `pt`,
+`fr`, `ko`, `ru`, `id`). By default the SDK picks Chinese or English from the
+input. Set `MEMORY_LANGUAGE` (or `language=` on `add()`) to choose one
+explicitly; memories are then written in that language. See
+[Prompt language](docs/usage.md#提示词语言language).
+
### 3. Chat Memory
```python
diff --git a/README.zh.md b/README.zh.md
index a2c699b..cc047fc 100644
--- a/README.zh.md
+++ b/README.zh.md
@@ -98,6 +98,11 @@ export OPENAI_API_KEY="sk-your-key"
完整配置见 [环境变量参考](docs/env_reference.md)。
+提示词提供 11 种语言(`en`、`zh-Hans`、`zh-Hant`、`ja`、`es`、`de`、`pt`、`fr`、
+`ko`、`ru`、`id`)。默认按输入自动在中文与英文之间选择;设置 `MEMORY_LANGUAGE`(或在
+`add()` 上传 `language=`)可显式指定,记忆随之用该语言书写。详见
+[提示词语言](docs/usage.md#提示词语言language)。
+
### 3. Chat 记忆
```python
diff --git a/docs/env_reference.md b/docs/env_reference.md
index 699d552..ba25c9b 100644
--- a/docs/env_reference.md
+++ b/docs/env_reference.md
@@ -9,6 +9,7 @@
|---|---|---|
| `MEMORY_MODE` | `pro` | `lite` / `pro` / `ultra` |
| `MEMORY_DATA_DIR` | `~/.hy_memory` | 本地数据、缓存和日志根目录 |
+| `MEMORY_LANGUAGE` | — | LLM 提示词与记忆正文语言:`en` / `zh-Hans` / `zh-Hant` / `ja` / `es` / `de` / `pt` / `fr` / `ko` / `ru` / `id`(别名 `zh`、`zh-CN` → `zh-Hans`,`zh-TW`、`zh-HK` → `zh-Hant`,`pt-BR` → `pt`)。未设置时按输入做 zh/en 自动检测;per-call `language=` 优先 |
- `lite`:纯 Embedding 写入,Graph 强制关闭。
- `pro`:LLM 提取与 reconcile;Graph 由 `MEMORY_ENABLE_GRAPH` 控制。
diff --git a/docs/usage.md b/docs/usage.md
index dbd77c4..0d2819b 100644
--- a/docs/usage.md
+++ b/docs/usage.md
@@ -103,6 +103,7 @@ result = client.add(
metadata=None,
meta=None,
embed_override=None,
+ language=None,
)
```
@@ -136,6 +137,54 @@ LLM。pro / ultra 仍遵循各自的层级与场景参数,默认不公开原
正交:前者说明“从哪个产品/入口写入”,后者仍是记忆隔离中的 agent 身份。source 会
执行 `strip().lower()` 后存储,并随 chat、working、coding 记忆一起返回。
+### 提示词语言(`language`)
+
+SDK 的 LLM 提示词提供 11 种语言,按语言码注册在 `hy_memory/prompts/`
+(每种语言一个模块,`get_prompt(name, language)` 统一取用):
+
+| 语言码 | 语言 | 别名 |
+|---|---|---|
+| `en` | English | `en-US`、`en-GB` |
+| `zh-Hans` | 简体中文 | `zh`、`zh-CN`、`zh-SG` |
+| `zh-Hant` | 繁體中文 | `zh-TW`、`zh-HK`、`zh-MO` |
+| `ja` | 日本語 | |
+| `es` | Español | |
+| `de` | Deutsch | |
+| `pt` | Português | `pt-BR`、`pt-PT` |
+| `fr` | Français | |
+| `ko` | 한국어 | |
+| `ru` | Русский | |
+| `id` | Bahasa Indonesia | |
+
+语言码大小写不敏感,`_` 与 `-` 等价;未知语言码抛 `ValueError` 并列出支持的语言码。
+
+```python
+# client 默认值(也可用环境变量 MEMORY_LANGUAGE=ja)
+client = HyMemoryClient.from_config({"mode": "pro", "language": "ja"})
+
+# per-call 覆盖 client 默认值
+client.add(messages, user_id="u1", language="de")
+client.add_extracted(["Der Nutzer trinkt keinen Kaffee."], user_id="u1", language="de")
+client.finalize_session(user_id="u1", session_id="s1", language="de")
+client.evolve(user_id="u1", language="de") # ultra
+client.sweep(user_ids=["u1"], language="de") # ultra
+```
+
+优先级:per-call `language` > `MemoryConfig.language`(`MEMORY_LANGUAGE`)> 自动检测。
+
+- **未指定语言(默认)**:行为与以前完全一致。SDK 按输入做 zh/en 自动检测,中文输入用
+ 简体中文提示词,其余用英文提示词;自动检测不会选到其他语言。提示词里的「输出语言与
+ 输入语言一致」规则仍然生效,所以记忆正文保持对话的原始语言。
+- **显式指定语言**:本次请求的全部 LLM 调用(抽取、基础画像、reconcile、working /
+ coding 链路的抽取与两个 reconciler 及演变总结、episode / topic 摘要、System 2)都使用
+ 该语言的提示词,并在提示词末尾追加该语言的「输出语言」规则:记忆正文、摘要等自然语言
+ 字段一律用该语言书写,即使对话是另一种语言。JSON 键、字段名、枚举值、代码、路径、
+ 报错信息和专有名词保持原样;tags 仍是英文小写关键词。
+- 只有英文版的提示词(session / dynamic episode、cross-domain sweeper)在显式指定语言时
+ 同样追加该输出规则;搜索侧的场景判断 / query rewrite 只有英文版且保持 query 原语言,
+ 因此 `search()` 不接受 `language`。
+- 自定义 `extract_system_prompt_zh` / `extract_system_prompt_en` 只覆盖 `zh-Hans` / `en`。
+
### `search()` / `async_search()`
普通 chat 检索:
diff --git a/hy_memory/agent/episode_summary.py b/hy_memory/agent/episode_summary.py
index d48cd08..324f60a 100644
--- a/hy_memory/agent/episode_summary.py
+++ b/hy_memory/agent/episode_summary.py
@@ -43,6 +43,12 @@ from datetime import datetime
from typing import Any, Dict, List, Optional
import uuid
+from ..prompts import (
+ get_prompt,
+ normalize_language,
+ resolve_language,
+ with_output_language,
+)
from ..utils.source_filter import merge_sources
logger = logging.getLogger(__name__)
@@ -115,56 +121,9 @@ Messages:
"""
-EPISODE_SUMMARY_PROMPT = """You are summarizing ONE episode of conversation with the user.
-
-An episode is a single stretch of discussion — one thing that was talked about,
-possibly across several sessions of writing.
-
-## Memories captured during this episode (oldest → newest)
-
-{memories}
-
----
-
-Write a single dense summary of what happened / what was discussed in this episode.
-
-Rules:
-
-* 2–4 sentences, third person, starting with "The user ..." (or the named person
- if the memories are about someone else).
-* Tie the memories together into one coherent account — an episode usually has a
- thread running through it (a plan, a problem, an outing, a decision).
-* Preserve concrete details: names, places, numbers, dates.
-* Do NOT invent anything that is not in the memories.
-* Do NOT enumerate the memories one by one; synthesize them.
-* Output language must match the language of the memories.
-
-Return ONLY the summary text, no preamble, no JSON, no quotes."""
-
-
-EPISODE_SUMMARY_PROMPT_ZH = """你在为**一段讨论**(一个 episode)做总结。
-
-一个 episode 是一段连续的讨论 —— 围绕一件事,可能跨越好几次写入。
-
-## 这段讨论中抽取到的记忆(时间正序)
-
-{memories}
-
----
-
-写一段关于这次讨论内容的高密度摘要。
-
-要求:
-
-* 2–4 句,第三人称,以"用户…"开头(若记忆讲的是别人,则以那个人的名字开头)。
-* 把这些记忆串成一个连贯的叙述 —— 一段讨论通常有一根主线(一个计划、一个问题、
- 一次出行、一个决定)。
-* 保留具体细节:人名、地点、数字、日期。
-* 绝不编造记忆里没有的内容。
-* 不要逐条罗列记忆,要综合成一段。
-* 输出语言与记忆的语言一致。
-
-只返回摘要正文,不要任何前言、不要 JSON、不要引号。"""
+# 多语言版本见 hy_memory/prompts/<language>.py;旧名字保留为别名。
+from ..prompts.en import EPISODE_SUMMARY_PROMPT # noqa: E402,F401 (re-export)
+from ..prompts.zh_hans import EPISODE_SUMMARY_PROMPT as EPISODE_SUMMARY_PROMPT_ZH # noqa: E402,F401 (re-export)
SESSION_EPISODE_PROMPT = """Convert this complete conversation session into one retrieval-friendly episode narrative.
@@ -596,9 +555,13 @@ def _assign_facts_to_segments(facts: List[Any], segments: List[dict]) -> Dict[in
async def finalize_dynamic_episode_capsules(
*, vector_store, embed_service, llm_provider, user_id: str,
agent_id: Optional[str], session_id: str, summary_concurrency: int = 3,
+ language: Optional[str] = None,
) -> dict:
"""Split a completed session, create compact L3 capsules, and link its facts.
+ The capsule prompt is English-only; an explicit ``language`` appends that
+ language's output rule so the capsule text is written in it.
+
Boundary and summary generation are separate calls. Boundary failure degrades
to one whole-session capsule. A segmented-summary failure also retries the
session as one capsule so the write never loses the complete event context.
@@ -802,6 +765,7 @@ async def finalize_dynamic_episode_capsules(
start = end + 1
semaphore = asyncio.Semaphore(max(1, min(16, int(summary_concurrency or 1))))
+ explicit_language = normalize_language(language)
async def summarize(spec):
segment_index, segment_start, segment_end, segment = spec
@@ -809,9 +773,13 @@ async def finalize_dynamic_episode_capsules(
try:
async with semaphore:
response = await llm_provider.complete(
- prompt=DYNAMIC_CAPSULE_PROMPT.format(
- timestamp=timestamp_text,
- messages=_render_messages(segment),
+ prompt=with_output_language(
+ DYNAMIC_CAPSULE_PROMPT.format(
+ timestamp=timestamp_text,
+ messages=_render_messages(segment),
+ ),
+ explicit_language,
+ explicit=explicit_language is not None,
),
max_tokens=4096,
)
@@ -1128,9 +1096,13 @@ def _cosine(a: List[float], b: List[float]) -> float:
async def finalize_session_episode(
*, vector_store, embed_service, llm_provider, user_id: str,
agent_id: Optional[str], session_id: str,
+ language: Optional[str] = None,
) -> dict:
"""Create one first-class narrative from all raw chunks in a caller session.
+ The prompt is English-only; an explicit ``language`` appends that
+ language's output rule so the narrative is written in it.
+
This is deliberately explicit: the SDK cannot infer that the final write of a
session has arrived. Repeated calls upsert the same deterministic node id.
"""
@@ -1213,6 +1185,10 @@ async def finalize_session_episode(
timestamp=timestamp_text,
conversation=conversation,
)
+ explicit_language = normalize_language(language)
+ prompt = with_output_language(
+ prompt, explicit_language, explicit=explicit_language is not None,
+ )
response = await llm_provider.complete(prompt=prompt, max_tokens=3000)
narrative = (getattr(response, "content", "") or "").strip()
if not narrative:
@@ -1274,9 +1250,12 @@ async def summarize_closed_episode(
max_memories: int = 60,
temperature: Optional[float] = None,
trace=None,
+ language: Optional[str] = None,
) -> Optional[str]:
"""总结一个**刚刚关闭**的 episode,返回摘要节点 id(跳过则 None)。
+ language 为显式 prompt 语言码;None 时按记忆内容做 zh/en 自动检测。
+
由 writer 在检测到 episode 滚动时 fire-and-forget 调用:此时上一个 episode
不会再有新内容进来,所以这一次总结就是最终产物,不需要后续 merge / 重写。
"""
@@ -1317,6 +1296,7 @@ async def summarize_closed_episode(
_t0 = _dt.now()
summary, prompt, tokens = await _generate(
llm_provider=llm_provider, memories=contents, temperature=temperature,
+ language=language,
)
_elapsed = (_dt.now() - _t0).total_seconds() * 1000
if trace is not None:
@@ -1351,15 +1331,16 @@ async def summarize_closed_episode(
async def _generate(
*, llm_provider, memories: List[str], temperature: Optional[float] = None,
+ language: Optional[str] = None,
) -> tuple:
"""返回 (摘要文本, 实际 prompt, token 用量) —— 后两个供埋点,线上要能复盘。"""
- from ..utils.lang_detect import is_chinese
-
body = "\n".join(f"- {c}" for c in memories if c)
if not body:
return "", "", {}
- tpl = EPISODE_SUMMARY_PROMPT_ZH if is_chinese(body) else EPISODE_SUMMARY_PROMPT
- prompt = tpl.format(memories=body)
+ explicit = normalize_language(language)
+ code = resolve_language(explicit, body)
+ prompt = get_prompt("EPISODE_SUMMARY_PROMPT", code).format(memories=body)
+ prompt = with_output_language(prompt, code, explicit=explicit is not None)
resp = await llm_provider.complete(
prompt=prompt,
max_tokens=400,
diff --git a/hy_memory/agent/extractor.py b/hy_memory/agent/extractor.py
index daffebd..18caa60 100644
--- a/hy_memory/agent/extractor.py
+++ b/hy_memory/agent/extractor.py
@@ -20,6 +20,12 @@ import re
from .llm_provider import LLMProvider, _content_fingerprint, _log_llm_content_enabled
from ..config import LLMConfig as GlobalLLMConfig
+from ..prompts import (
+ get_prompt,
+ normalize_language,
+ resolve_language,
+ with_output_language,
+)
logger = logging.getLogger(__name__)
@@ -164,704 +170,13 @@ class V2ExtractResult:
# - 不再输出 time_ref 字段。时间相关信息如果是时间敏感的(schedule / past event),
# 让 LLM 把已解析的时间自然嵌入 content 即可;稳定偏好类 content 保持不含时间。
-# System prompt(固定,不参与 format)
-EXTRACT_SYSTEM_PROMPT = """# ROLE
-
-You are a Memory Extractor.
-
-Extract durable, high-value memories from conversations and convert them into structured, self-contained statements.
-
-Only extract information that is likely to matter in future conversations.
-
----
-
-# INPUTS
-
-You will receive:
-
-* Last k Messages
-* New Messages
-* Memory Date
-* Current Date
-
-Use:
-
-* Last k Messages only for coreference resolution
-* Memory Date as the ONLY temporal anchor
-* Current Date only as metadata, never for resolving relative time
-
----
-
-# WHAT TO EXTRACT
-
-Extract ONLY genuinely new information introduced in the NEW user messages.
-
-Good memories include:
-
-* preferences
-* long-term projects
-* habits
-* goals
-* recurring activities
-* opinions
-* relationships
-* important experiences
-* stable traits
-* future plans
-* decisions
-* constraints
-* accepted recommendations
-
-Do NOT extract:
-
-* small talk
-* acknowledgements
-* generic emotions
-* temporary conversational context
-* assistant reminders of old memories
-* information already implied by prior context
-* vague personality judgments
-
----
-
-# SUBJECT
-
-Every memory must be self-contained, written in third person, with an explicit
-subject. Which subject to use is decided by **who spoke**:
-
-| Speaker | Subject to write | Example |
-| --- | --- | --- |
-| `role: "user"` | the user | "The user ..." / "用户..." |
-| any speaker with a `name` other than the user (e.g. `name: "John"`) | that person, by name | "John ..." |
-| `role: "assistant"` with NO `name` | the AI assistant | "The assistant ..." |
-
-The two input sections express the speaker differently:
-
-* **New Messages** is a JSON array — read `role` and the optional `name` field.
-* **Last k Messages** is rendered text — the speaker is the bracket label,
- `[user]:` / `[John]:` / `[assistant]:`, optionally preceded by one line
- "The user's name is Tim" / "用户名叫Tim".
-
-Rules:
-
-* The user is the person these memories belong to. Even when the user's own name
- is known (from `name` on their message, or from the leading name line), still
- write "The user ...", NEVER "Tim ...".
-* **`role: "assistant"` WITH a `name` is another real person, not the AI.**
- Write their memories with their name as the subject: "John ...".
-* Only a nameless `role: "assistant"` is the AI assistant.
-* Never invent a name for the AI assistant, it has none.
-
----
-
-# LANGUAGE RULES
-
-* Output language must match input language.
-* Preserve original scripts and technical terms exactly.
-* Never transliterate names, brands, or equations.
-
----
-
-# TWO KINDS OF MEMORY
-
-You extract two kinds of memory: **memory** and **intentions**.
-
-## memory
-
-Everything durable and worth remembering about the user — and about any other
-named person in the conversation — goes here:
-
-* preferences, opinions, values, attitudes
-* events, actions, experiences
-* habits, behavioral patterns
-* relationships, traits
-* objective facts, decisions, constraints
-* ongoing activities
-
-Implicit preferences MUST be inferred when strongly suggested
-(e.g. resuming an activity → positive interest; avoiding something →
-negative preference; repeated voluntary effort → sustained interest).
-
-Do NOT separate "what kind of person the user is" from "what happened".
-Both go into `memory`.
-
-## intentions
-
-A forward-looking thing the user **plans or intends to do in the future**,
-which can be acted on and which becomes irrelevant once done or past.
-
-Examples:
-
-* "The user has a job interview next Tuesday."
-* "The user plans to move apartments at the end of the month."
-* "The user intends to finish the report before Friday."
-
-NOT intentions (these belong in `memory`):
-
-* stable preferences / traits ("The user likes basketball")
-* completed past events ("The user moved to Beijing last year")
-* general goals with no actionable future step
-
-### valid_until
-
-For each intention, provide `valid_until`: the date after which the
-intention no longer matters (the deadline / target date), resolved
-against **Memory Date** (e.g. "next Tuesday" → that absolute date).
-If no deadline can be determined, set `valid_until` to `null`.
-
----
-
-# OWNER
-
-Every memory and intention MUST carry an `owner` saying which memory store it
-belongs to. There are exactly two values:
-
-* `"user"` — anything belonging to the user's own memory store. This includes
- facts/preferences/traits about the user themselves, AND facts about other
- named real people in the conversation, because those are still things the
- user's memory should hold.
-* `"agent"` — information the AI assistant (a nameless `role: "assistant"`)
- provides (recommendations, confirmations, things it researched), or a future
- action the user wants the **assistant** to perform ("remind me in 8 hours").
-
-A named person is NEVER `owner: "agent"` — they are a real person, not the AI,
-even though their messages carry `role: "assistant"`. Their memories are
-`owner: "user"` with their name as the content subject.
-
-Decide `owner` per item. When unsure, default to `"user"`.
-
----
-
-# TEMPORAL RULES
-
-Resolve relative time using Memory Date.
-
-Examples:
-
-* "next week"
-* "last month"
-* "tomorrow"
-
-If time cannot be resolved safely:
-
-* remove the relative wording
-* keep the memory atemporal
-
-Do not invent chronology.
-
-**Just-happened events are events — keep them.** When the user reports something as
-just completed ("just got back", "just finished", "this morning", "yesterday"), the
-completion date is the Memory Date. Emit the **event itself** with that date; do not
-fold it into a background statement.
-
-* "I just got back from a trip with my family"
- → "The user returned from a family trip on <Memory Date>."
- NOT → "The user takes family trips." (the return date is the answer to "when did
- they get back", and dropping it makes the question unanswerable)
-
-Where an event has both a start and an end that the conversation gives separately,
-record both rather than collapsing them into one span.
-
----
-
-# QUALITY RULES
-
-Each memory must be:
-
-* self-contained
-* contextually complete
-* retrieval-friendly
-* information-dense
-
-Retain important details:
-
-* names
-* products
-* locations
-* numbers
-* equations
-* constraints
-
-Never generalise a specific into a category. Write what was actually said.
-
-* "Banff" → keep "Banff", NOT "the Rocky Mountains"
-* "a 3-year-old border collie named Luna" → keep the breed, age and name
-
-**Specifics supplied by the other speaker still count.** A fact is often built across
-turns: the other speaker names the thing, the user confirms it. The subject rules
-decide *whose* memory it is — they do not license dropping detail.
-
-* [Sam]: "Did you take advantage of the skiing opportunities in Banff?"
- [user]: "Yeah, it was great for skiing!"
- → "The user went skiing in Banff and found the snow amazing."
- NOT → "The user enjoys winter sports." (both the place and the activity were
- established, one by each speaker)
-
-Avoid fragmentary memories lacking context.
-
-Choose the smallest number of memories that still preserves distinct future
-retrieval needs.
-
-* Compression means combining, not omitting. Every explicit durable proposition
- in the new messages must appear exactly once in the output.
-* Combine details when they share the same subject and the same real-world event,
- state, preference, plan, or decision. A coherent event may use 1–3 sentences.
-* Do not emit both a broad statement and narrower restatements of the same evidence.
-* Split only when the subject differs, the events happened independently, or the
- memories describe different states.
-* Keep a cause, recommendation, or consequence with the fact it explains when
- separating them would lose the relationship.
-* Never merge separate dated occurrences merely because they share a topic.
-* Preserve the source's time precision. Do not turn vague phrases such as "last
- weekend" or "last summer" into exact calendar dates unless the date is explicit
- or uniquely determined; "the weekend before <Memory Date>" is acceptable.
-
----
-
-# TAGS
-
-Each memory must include 1–3 concise tags.
-- Topical keywords stay lowercase (travel, health, work).
-- Proper nouns keep capitalization (Jasper, Canada, Banff, Prius).
-
-Examples:
-
-* work
-* travel
-* Jasper
-* Canada
-* health
-
----
-"""
-
-STRUCTURE_METADATA_PROMPT_EN = """
-
----
-
-# STRUCTURAL ORGANIZATION
-
-For every `memory`, also output:
-
-* `topic_paths`: a backward-compatible list of zero to three broad-to-specific
- semantic paths.
-* `event_facet`: an object with only `subject`, `participants`, `action`,
- `objects`, `locations`, and `state`; state is `planned`, `ongoing`,
- `completed`, or `unknown`.
-* `topic_assignments`: zero to six subject-specific memberships. Each item is
- `{subject, role, path}`, where `path` is a list of `{name, type}` segments and
- `type` is one of `topic`, `facet`, `series`, or `episode`. Use `topic` for a
- broad domain, `facet` for a concrete activity/semantic aspect, `series` only
- for repeated occurrences of the same concrete activity/state line, and
- `episode` only for one bounded real-world occurrence. A shared event may have
- one assignment per explicit participant while keeping one canonical memory.
- Types follow `topic -> facet -> series -> episode`; levels may be skipped but
- types may not repeat or move backward.
-
-This extractor sees only the current write and therefore must not emit a
-`series` segment. Emit Topic/Facet/Episode here. Reconcile may later establish a
-Series after comparing independent stored occurrences.
-
-This is write-time organization. Do not infer Series/Episode from path depth,
-manufacture hierarchy from a proper noun or broad tag, or assign a person only
-because they co-occur in unrelated context. Stop at the most specific supported
-level and use empty values when uncertain. Never encode query forms such as
-"when", "how many", "who", plurality, or ordinal wording.
-"""
-
-# Few-shot examples (appended to the system prompt only when few_shot_enabled).
-# Each example mirrors the real input shape (Last k Messages / New Messages /
-# Memory Date) and our output schema (memory / intentions / basic_info with
-# owner & tags), and ends with a one-line takeaway.
-EXTRACT_FEW_SHOT_EN = """
----
-
-# EXAMPLES
-
-## Example 1 — Boundary: old context is for resolution only, never re-extracted
-
-Last k Messages:
-[{"role": "user", "content": "I've been looking at rescue dogs at the shelter downtown."},
- {"role": "assistant", "content": "That's lovely — found one you like?"}]
-New Messages:
-[{"role": "user", "content": "Yeah, picked her up yesterday — a 3-year-old border collie named Luna."}]
-Memory Date: 2025-04-10
-
-Output:
-```json
-{
- "memory": [
- {"content": "The user adopted a 3-year-old border collie named Luna from a downtown shelter on 2025-04-09.", "tags": ["pets", "family"], "owner": "user"}
- ],
- "intentions": [],
- "basic_info": {}
-}
-```
-The old messages only resolve "her" and supply context ("downtown shelter"). Do NOT emit a stale memory like "the user is considering adopting a dog" — only the genuinely new fact (the completed adoption) is extracted, with "yesterday" resolved against Memory Date.
-
-## Example 2 — Condense a long assistant reply
-
-New Messages:
-[{"role": "user", "content": "Write me a short essay on why remote work boosts productivity."},
- {"role": "assistant", "content": "Sure — opening: 'Remote work has reshaped how teams operate...' [~2000 words of body omitted] ...closing: 'In short, autonomy and fewer interruptions drive higher output.'"}]
-Memory Date: 2025-03-22
-
-Output:
-```json
-{
- "memory": [
- {"content": "The assistant drafted a short essay for the user arguing that remote work boosts productivity because autonomy and fewer interruptions drive higher output.", "tags": ["writing", "remote-work"], "owner": "agent"}
- ],
- "intentions": [],
- "basic_info": {}
-}
-```
-The assistant's reply is long. Never store the verbatim essay — distill it to topic + thesis. owner is "agent" because the assistant produced it. Bloated verbatim content makes memory unusable.
-
-## Example 3 — Composite extraction: basic_info + intention + condensed agent plan
-
-New Messages:
-[{"role": "user", "content": "Hi, I'm Kenji. I'm planning a trip to Japan next month — could you put together a 7-day itinerary?"},
- {"role": "assistant", "content": "# 7-Day Classic Japan Golden Route (Tokyo → Kyoto → Nara → Osaka)\\nFly into Tokyo, Shinkansen south to Kyoto, day-trip Nara, depart from Osaka (Kansai).\\n\\n## Day 1: Arrival in Tokyo\\n- Land at Haneda/Narita, drop bags at hotel near Tokyo Station.\\n- Late afternoon: Sensoji Temple (Asakusa), wander Nakamise Street, try taiyaki.\\n- Evening: Shibuya Crossing + Shibuya Sky rooftop for sunset; izakaya dinner (yakitori, sake).\\n\\n## Day 2: Tokyo markets & landmarks — [omitted]\\n## Day 3: Shinkansen to Kyoto, Fushimi Inari, Gion — [omitted]\\n## Day 4: Kyoto temples (Kiyomizu-dera, Kinkaku-ji, Ginkaku-ji) — [omitted]\\n## Day 5: Nara day trip (Nara Park deer, Todai-ji) — [omitted]\\n## Day 6: Osaka (Osaka Castle, Dotonbori street food) — [omitted]\\n## Day 7: Osaka sightseeing + depart from Kansai Airport — [omitted]\\n\\nTip: buy a 7-day JR Pass before arriving. Want me to adjust anything?"}]
-Memory Date: 2025-09-15
-
-Output:
-```json
-{
- "memory": [
- {"content": "The assistant created a 7-day Japan itinerary for the user along the classic golden route: Tokyo (Asakusa, Shibuya), Shinkansen to Kyoto (Fushimi Inari, Kiyomizu-dera, Kinkaku-ji, Gion), a Nara day trip (deer park, Todai-ji), then Osaka (Osaka Castle, Dotonbori), departing from Kansai Airport.", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
- ],
- "intentions": [
- {"content": "The user plans to take a 7-day trip to Japan in October 2025.", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
- ],
- "basic_info": {"name": "Kenji"}
-}
-```
-One turn produces three outputs in different buckets: the name goes to basic_info, the trip is a forward-looking intention with a deadline, and the assistant's long multi-section itinerary is condensed into ONE dense agent memory — the route and key stops per city, NOT every day's bullets, tips, or food lists. Storing the whole reply verbatim would bloat memory; storing the skeleton keeps it queryable.
-
-## Example 4 — A later message confirming/adopting an earlier recommendation is itself a fact
-
-New Messages:
-[{"role": "user", "content": "My 6-year-old won't eat any vegetables. Any ideas?"},
- {"role": "assistant", "content": "Try blending spinach or carrots into pasta sauce — the color and flavor mostly disappear, and many kids accept it without noticing."},
- {"role": "user", "content": "Oh nice, we'll try that tonight. By the way, what's a good bedtime for that age?"},
- {"role": "assistant", "content": "For a 6-year-old, aim for 7–9 PM with about 10–11 hours of sleep."}]
-Memory Date: 2025-06-20
-
-Output:
-```json
-{
- "memory": [
- {"content": "The user has a 6-year-old child who refuses to eat vegetables, and accepted the assistant's suggestion to blend spinach or carrots into pasta sauce to hide them.", "tags": ["parenting", "food"], "owner": "user"},
- {"content": "The assistant advised the user that a 6-year-old should aim for a 7–9 PM bedtime with about 10–11 hours of sleep.", "tags": ["parenting", "sleep"], "owner": "agent"}
- ],
- "intentions": [],
- "basic_info": {}
-}
-```
-In the third message the user said "we'll try that tonight" — explicitly adopting the earlier suggestion. That acceptance is valuable and must be recorded ("accepted the assistant's suggestion to ..."), not discarded as small talk. The bedtime advice was just given and not yet adopted, so it is recorded as advice (owner "agent").
-
-## Example 5 — RAG/injected context: never store the injected text
-
-New Messages:
-[{"role": "user", "content": "[Retrieved context: The Eiffel Tower is 330m tall and was completed in 1889.] Given the above, I'm going to propose to my girlfriend at the top of the Eiffel Tower this summer."}]
-Memory Date: 2025-05-02
-
-Output:
-```json
-{
- "memory": [],
- "intentions": [
- {"content": "The user plans to propose to his girlfriend at the top of the Eiffel Tower in summer 2025.", "tags": ["relationship", "travel"], "valid_until": "2025-08-31", "owner": "user"}
- ],
- "basic_info": {}
-}
-```
-The bracketed retrieved context (the tower's height and year) is RAG-injected reference material, NOT something the user told us about themselves — do NOT store it. Only the user's own forward-looking plan is extracted. System/RAG-injected text is context for the model, never a memory.
-
-## Example 6 — Shared reference material: extract the content, not the sharing action
-
-New Messages:
-[{"role": "user", "content": "Remember my grandma's dumpling recipe so I don't lose it. Filling: 500g ground pork, 300g napa cabbage, 2 tbsp soy sauce, 1 tbsp sesame oil, a thumb of ginger minced. Cabbage salted 15 min then squeezed dry. Boil dumplings, add cold water twice, ready when they float."},
- {"role": "assistant", "content": "Got it, saved!"}]
-Memory Date: 2025-07-01
-
-Output:
-```json
-{
- "memory": [
- {"content": "The user's grandmother's dumpling recipe: filling of 500g ground pork, 300g napa cabbage (salted 15 minutes then squeezed dry), 2 tbsp soy sauce, 1 tbsp sesame oil, and a thumb of minced ginger; boil the dumplings, add cold water twice, and they are done when they float.", "tags": ["food", "recipe", "family"], "owner": "user"}
- ],
- "intentions": [],
- "basic_info": {}
-}
-```
-Extract the actual factual content (ingredients, quantities, the salt-and-squeeze step, the boiling method) — NOT "the user shared a recipe" or "the user asked to remember the recipe". The sharing action is worthless; the content is what's queryable.
-
-## Example 7 — Structured numbers and attributes preserved exactly
-
-New Messages:
-[{"role": "user", "content": "Logging my home-gym PRs this cycle: Squat 140kg x 3, Bench 100kg x 5, Deadlift 180kg x 2, Overhead Press 60kg x 6. Bodyweight 78kg, 3 sets per lift, 3 min rest."},
- {"role": "assistant", "content": "Logged — strong numbers!"}]
-Memory Date: 2026-01-20
-
-Output:
-```json
-{
- "memory": [
- {"content": "The user's current lifting PRs are Squat 140kg x 3, Bench 100kg x 5, Deadlift 180kg x 2, and Overhead Press 60kg x 6, at a bodyweight of 78kg.", "tags": ["fitness", "strength"], "owner": "user"},
- {"content": "The user trains with 3 sets per lift and 3 minutes of rest between sets.", "tags": ["fitness", "training"], "owner": "user"}
- ],
- "intentions": [],
- "basic_info": {}
-}
-```
-Every number and unit (kg, reps, sets, rest time) is preserved exactly — dropping them would destroy the most queryable information. Split into two clean topics (PRs vs. training protocol), but never round or omit the specifics.
-
-## Example 8 — Long multi-topic conversation: do not stop after the first topic
-
-New Messages:
-[{"role": "user", "content": "Big week — I finally defended my PhD thesis on Tuesday!"},
- {"role": "assistant", "content": "Huge congrats! How do you feel?"},
- {"role": "user", "content": "Relieved! I also signed a lease on an apartment in Berlin and move next month. And I've started learning German on Duolingo — 30-day streak. My partner Sofia is staying in Madrid for now, which is hard."}]
-Memory Date: 2025-11-08
-
-Output:
-```json
-{
- "memory": [
- {"content": "The user defended their PhD thesis on 2025-11-04.", "tags": ["education", "milestone"], "owner": "user"},
- {"content": "The user signed a lease on an apartment in Berlin.", "tags": ["housing"], "owner": "user"},
- {"content": "The user has been learning German on Duolingo and has a 30-day streak.", "tags": ["language", "learning"], "owner": "user"},
- {"content": "The user's partner Sofia is staying in Madrid for now, which the user finds hard.", "tags": ["relationship"], "owner": "user"}
- ],
- "intentions": [
- {"content": "The user plans to move to Berlin next month (around December 2025).", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
- ],
- "basic_info": {}
-}
-```
-Four+ topics — thesis defense, the Berlin apartment, learning German, and the partner in Madrid. Do not stop after the first topic. Note one turn split into a completed fact (lease signed) AND an intention (the upcoming move), and the emotional-but-substantive detail about Sofia is kept because it carries lasting relationship context.
-
-## Example 9 — Two real people: `name` on an assistant message means a real person
-
-New Messages:
-[{"role": "user", "name": "Tim", "content": "Just got back from the climbing gym, third time this week. Finally sent that overhang route."},
- {"role": "assistant", "name": "John", "content": "Nice! I've been swimming instead — my shoulder still hurts from last month."}]
-Memory Date: 2025-08-14
-
-Output:
-```json
-{
- "memory": [
- {"content": "The user has been climbing three times a week and recently completed a difficult overhang route.", "tags": ["fitness", "climbing"], "owner": "user"},
- {"content": "John has been swimming instead of other exercise because his shoulder still hurt after an injury around July 2025.", "tags": ["fitness", "health"], "owner": "user"}
- ],
- "intentions": [],
- "basic_info": {"name": "Tim"}
-}
-```
-John carries `role: "assistant"` but he has a `name`, so he is another real person, NOT the AI: his memory uses "John ..." as the subject and is still `owner: "user"` (it belongs to the user's memory store). The user's own memory stays "The user ..." even though we know the name is Tim — never "Tim has been climbing". `basic_info.name` comes from `name: "Tim"` on the user message, which is authoritative even though Tim never said his own name out loud.
-
-## Example 10 — Counter-example: another person's attributes never go into basic_info
-
-New Messages:
-[{"role": "user", "name": "Tim", "content": "你最近在忙什么?"},
- {"role": "assistant", "name": "John", "content": "我在柏林一家医院当护士,上的是夜班,挺累的。"}]
-Memory Date: 2025-09-02
-
-Output:
-```json
-{
- "memory": [
- {"content": "John是柏林一家医院的护士,上夜班,觉得很累。", "tags": ["work", "health"], "owner": "user"}
- ],
- "intentions": [],
- "basic_info": {"name": "Tim"}
-}
-```
-John's occupation and location are HIS attributes, so they go into `memory` with "John" as the subject. They must NEVER land in `basic_info.occupation` / `basic_info.location` — `basic_info` is exclusively the user's own profile. Only `name` (Tim, from the user message's `name` field) belongs there.
-
-## Example 11 — Counter-example: small talk has no basic_info
-
-New Messages:
-[{"role": "user", "content": "Hi"},
- {"role": "assistant", "content": "Hello! The user's name is The user. How can I help?"}]
-Memory Date: 2025-09-03
-
-Output:
-```json
-{
- "memory": [],
- "intentions": [],
- "basic_info": {}
-}
-```
-The user stated nothing about themselves. The assistant's line is not a user turn, and "The user" is a placeholder, not a name. Output `{}` — never `{"name": "The user"}` or `{"name": "user"}`.
-
----
-"""
-
-
-EXTRACT_PROMPT = """## Last k Messages
-
-{last_messages}
-
----
-
-## New Messages
-
-{content}
-
----
-
-## Memory Date
-
-{memory_at}
-
----
-
-## Current Date
-
-{current_date}
-
----
-
-# Output Format
-
-Return ONLY a JSON object inside a ```json fenced block.
-
-```json
-{{
- "memory": [
- {{
- "content": "...",
- "tags": ["..."],
- "owner": "user"
- }}
- ],
- "intentions": [
- {{
- "content": "...",
- "tags": ["..."],
- "valid_until": "YYYY-MM-DD",
- "owner": "user"
- }}
- ],
- "basic_info": {{}}
-}}
-```
-
-Rules:
-
-* `memory` = durable info worth remembering: preferences, opinions, attitudes,
- traits, events, plans, experiences, habits, decisions — about the user or
- about any other named real person, with the subject written per "# SUBJECT"
-* `intentions` = forward-looking things the user (or another named person) plans /
- intends to do in the future, with `valid_until` = the deadline/target date
- (resolved against Memory Date) or `null` if none
-* `owner` (required on every memory & intention) = `"user"` or `"agent"`
- (see "# OWNER" above; default `"user"` when unsure)
-* `basic_info` = the **user's own profile only**. Include stable profile
- fields (e.g. name, age, location, occupation, employer) **explicitly stated**
- in the NEW user messages. Never infer, never invent. If no field is explicitly
- stated, output `{{}}`.
- * HARD RULE: fill a field ONLY if the user stated it in a `user` turn.
- Anything said only by the assistant (including the assistant quoting an
- earlier memory such as "The user's name is X") does NOT count. If nothing
- qualifies, output `"basic_info": {{}}`.
- * NEVER write the field name itself or a placeholder as a value ("user",
- "The user", "用户", "name", "N/A", "unknown", "none", "-"). Omit the field.
- * Negative example: small talk such as `[user]: Hi` / `[assistant]: How can
- I help?`, or `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
- * Exception for `name`: the `name` field on the user's own message, or a leading
- line "The user's name is X" / "用户名叫X", is an authoritative source for
- `name` — even though the user never said it out loud.
- * NEVER put another real person's attributes here. If John (an assistant-role
- message carrying `name`) says "I'm a nurse in Berlin", that is a `memory`
- ("John is a nurse in Berlin."), NOT `basic_info.occupation` / `.location`.
-* No duplicate information across sections
-* Tags must contain 1–3 concise lowercase keywords
-* Use empty arrays `[]` or `{{}}` when nothing is extracted
-* Return valid JSON only
-
-Output the JSON now."""
-
-
-# User prompt when MEMORY_ENABLE_INTENTION=false(无 intentions 桶)
-EXTRACT_PROMPT_NO_INTENTION = """## Last k Messages
-
-{last_messages}
-
----
-
-## New Messages
-
-{content}
-
----
-
-## Memory Date
-
-{memory_at}
-
----
-
-## Current Date
-
-{current_date}
-
----
-
-# Output Format
-
-Return ONLY a JSON object inside a ```json fenced block.
-
-```json
-{{
- "memory": [
- {{
- "content": "...",
- "tags": ["..."],
- "owner": "user"
- }}
- ],
- "basic_info": {{}}
-}}
-```
-
-Rules:
-
-* `memory` = durable info worth remembering: preferences, opinions, attitudes,
- traits, events, experiences, habits, decisions, **and future plans / upcoming
- actions** — about the user or about any other named real person, with the
- subject written per "# SUBJECT". Do **not** invent a separate intentions bucket.
-* `owner` (required on every memory) = `"user"` or `"agent"`
- (see "# OWNER" above; default `"user"` when unsure)
-* `basic_info` = the **user's own profile only**. Include stable profile
- fields (e.g. name, age, location, occupation, employer) **explicitly stated**
- in the NEW user messages. Never infer, never invent. If no field is explicitly
- stated, output `{{}}`.
- * HARD RULE: fill a field ONLY if the user stated it in a `user` turn.
- Anything said only by the assistant (including the assistant quoting an
- earlier memory such as "The user's name is X") does NOT count. If nothing
- qualifies, output `"basic_info": {{}}`.
- * NEVER write the field name itself or a placeholder as a value ("user",
- "The user", "用户", "name", "N/A", "unknown", "none", "-"). Omit the field.
- * Negative example: small talk such as `[user]: Hi` / `[assistant]: How can
- I help?`, or `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
- * Exception for `name`: the `name` field on the user's own message, or a leading
- line "The user's name is X" / "用户名叫X", is an authoritative source for
- `name` — even though the user never said it out loud.
- * NEVER put another real person's attributes here. If John (an assistant-role
- message carrying `name`) says "I'm a nurse in Berlin", that is a `memory`
- ("John is a nurse in Berlin."), NOT `basic_info.occupation` / `.location`.
-* No duplicate information across sections
-* Tags: 1–3 concise keywords; topical tags lowercase; proper nouns keep capitalization
-* Use empty arrays `[]` or `{{}}` when nothing is extracted
-* Return valid JSON only — **never** include an `intentions` key
-
-Output the JSON now."""
+# Prompt 文本统一放在 hy_memory/prompts/<language>.py,按语言码经 get_prompt()
+# 取用。以下旧名字保留为英文版的别名(向后兼容)。
+from ..prompts.en import EXTRACT_SYSTEM_PROMPT # noqa: E402,F401 (re-export)
+from ..prompts.en import STRUCTURE_METADATA_PROMPT as STRUCTURE_METADATA_PROMPT_EN # noqa: E402,F401 (re-export)
+from ..prompts.en import EXTRACT_FEW_SHOT as EXTRACT_FEW_SHOT_EN # noqa: E402,F401 (re-export)
+from ..prompts.en import EXTRACT_PROMPT # noqa: E402,F401 (re-export)
+from ..prompts.en import EXTRACT_PROMPT_NO_INTENTION # noqa: E402,F401 (re-export)
# ================================================================
@@ -870,101 +185,26 @@ Output the JSON now."""
def _system_prompt_without_intention(system_prompt: str, *, lang: str) -> str:
- """从 system prompt 去掉 intentions 分桶,改为单一 memory(含未来计划)。"""
+ """从 system prompt 去掉 intentions 分桶,改为单一 memory(含未来计划)。
+
+ ``lang`` 是语言码(``en`` / ``zh-Hans`` / ``ja`` ...;旧值 ``zh`` 视作 zh-Hans)。
+ 每种语言的替换片段在 ``hy_memory/prompts/<lang>.py`` 中定义。
+ """
import re
- if lang == "zh":
- repl = (
- "# 记忆\n"
- "\n"
- "你只提取一类记忆:**memory(记忆)**。\n"
- "\n"
- "## memory(记忆)\n"
- "\n"
- "一切值得长期记住的信息都放这里——既包括用户本人的,也包括对话中其他具名真人的:\n"
- "\n"
- "* 偏好、观点、态度、价值观\n"
- "* 事件、行动、经历\n"
- "* 习惯、行为模式\n"
- "* 关系、稳定特质\n"
- "* 客观事实、决策、约束条件\n"
- "* 正在进行的活动\n"
- "* **未来计划 / 即将发生的安排**(若值得记住,直接写进 `memory`;"
- "不要单独开 intentions 桶)\n"
- "\n"
- "如果用户隐式表达偏好,也应提取。\n"
- "\n"
- "不要把\"用户是怎样的人\"和\"发生了什么\"分开。两者都放进 `memory`。\n"
- "\n"
- "---\n"
- "\n"
- )
- system_prompt = re.sub(
- r"# 两类记忆.*?(?=\n# OWNER)",
- repl,
- system_prompt,
- count=1,
- flags=re.S,
- )
- system_prompt = system_prompt.replace(
- "每条 memory 和 intention 都必须带 `owner`",
- "每条 memory 都必须带 `owner`",
- )
- system_prompt = system_prompt.replace(
- "每条 memory 和 intention 都必须带",
- "每条 memory 都必须带",
- )
- # few-shot 里若仍出现 intentions,用硬约束盖住
- system_prompt += (
- "\n\n---\n\n# INTENTION 关闭\n"
- "当前配置关闭了 intention 抽取。即使示例里出现 `intentions`,"
- "也**不要**输出该字段;未来计划写入 `memory`。\n"
- )
- else:
- repl = (
- "# MEMORY\n"
- "\n"
- "You extract one kind of memory: **memory**.\n"
- "\n"
- "## memory\n"
- "\n"
- "Everything durable and worth remembering about the user — and about any other\n"
- "named person in the conversation — goes here:\n"
- "\n"
- "* preferences, opinions, values, attitudes\n"
- "* events, actions, experiences\n"
- "* habits, behavioral patterns\n"
- "* relationships, traits\n"
- "* objective facts, decisions, constraints\n"
- "* ongoing activities\n"
- "* **future plans / upcoming actions** that are worth remembering\n"
- " (put them in `memory`; do NOT invent a separate intentions bucket)\n"
- "\n"
- "Implicit preferences MUST be inferred when strongly suggested.\n"
- "\n"
- "Do NOT separate \"what kind of person the user is\" from \"what happened\".\n"
- "Both go into `memory`.\n"
- "\n"
- "---\n"
- "\n"
- )
- system_prompt = re.sub(
- r"# TWO KINDS OF MEMORY.*?(?=\n# OWNER\n)",
- repl,
- system_prompt,
- count=1,
- flags=re.S,
- )
- system_prompt = system_prompt.replace(
- "Every memory and intention MUST carry an `owner`",
- "Every memory MUST carry an `owner`",
- )
- system_prompt += (
- "\n\n---\n\n# INTENTION DISABLED\n"
- "Intention extraction is disabled. Even if few-shot examples show "
- "`intentions`, do **not** emit that key; put future plans in `memory`.\n"
- )
- return system_prompt
+ language = "zh-Hans" if lang == "zh" else lang
+ repl = get_prompt("NO_INTENTION_MEMORY_SECTION", language)
+ system_prompt = re.sub(
+ get_prompt("NO_INTENTION_SECTION_PATTERN", language),
+ lambda _m: repl,
+ system_prompt,
+ count=1,
+ flags=re.S,
+ )
+ for old, new in get_prompt("NO_INTENTION_REPLACEMENTS", language):
+ system_prompt = system_prompt.replace(old, new)
+ # few-shot 里若仍出现 intentions,用硬约束盖住
+ return system_prompt + get_prompt("INTENTION_DISABLED_NOTE", language)
class Extractor:
@@ -1001,6 +241,7 @@ class Extractor:
tool_context: Optional[Dict[str, Any]] = None,
history_context: str = "",
basic_profile_fields: Optional[Dict[str, str]] = None,
+ language: Optional[str] = None,
) -> ExtractResult:
"""
统一提取:identity / facts / basic_info
@@ -1022,6 +263,9 @@ class Extractor:
**DEPRECATED**: 曾用于渲染 EXTRACT prompt 的基础画像 schema 段落,
现已移除该段落(basic_info 由内置 few-shot / 指令引导)。保留参数
仅为向后兼容,传入不再生效。
+ language: 显式 prompt 语言码(见 hy_memory.prompts.SUPPORTED_LANGUAGES,
+ 接受别名)。None 时按 content 做 zh/en 自动检测。显式指定时
+ 追加 OUTPUT_LANGUAGE_DIRECTIVE,记忆正文用该语言书写。
"""
MAX_TOOL_ROUNDS = 5
@@ -1048,73 +292,52 @@ class Extractor:
else:
_memory_at = _current_date
- # Select prompt based on input language
- from ..utils.lang_detect import is_chinese
+ # 选 prompt 语言:显式 language(per-call / MemoryConfig.language)优先;
+ # 未指定时沿用 zh/en 自动检测(行为与以前完全一致)。
+ _explicit_language = normalize_language(language)
+ _language = resolve_language(_explicit_language, content)
_enable_intention = bool(
getattr(self._llm_config, "enable_intention", True)
)
- if is_chinese(content):
- from .prompts_zh import (
- EXTRACT_PROMPT_ZH,
- EXTRACT_PROMPT_ZH_NO_INTENTION,
- EXTRACT_SYSTEM_PROMPT_ZH,
- EXTRACT_FEW_SHOT_ZH,
- )
-
+ # client 自定义 system prompt 仅覆盖对应语言(zh → zh-Hans, en → en);
+ # 直接用,不追加内置 few-shot
+ _custom_sys = None
+ if _language == "zh-Hans":
_custom_sys = getattr(
self._llm_config, "extract_system_prompt_zh", None
)
- if _custom_sys:
- # client 自定义 system prompt:直接用,不追加内置 few-shot
- system_prompt = _custom_sys
- else:
- system_prompt = EXTRACT_SYSTEM_PROMPT_ZH
- if getattr(self._llm_config, "few_shot_enabled", False):
- system_prompt = system_prompt + EXTRACT_FEW_SHOT_ZH
- if not _enable_intention and not _custom_sys:
- system_prompt = _system_prompt_without_intention(
- system_prompt, lang="zh"
- )
- if getattr(self._llm_config, "structure_metadata_enabled", False):
- from .prompts_zh import STRUCTURE_METADATA_PROMPT_ZH
- system_prompt += STRUCTURE_METADATA_PROMPT_ZH
- _user_tmpl = (
- EXTRACT_PROMPT_ZH
- if _enable_intention
- else EXTRACT_PROMPT_ZH_NO_INTENTION
- )
- prompt = _user_tmpl.format(
- content=content,
- current_date=_current_date,
- memory_at=_memory_at,
- last_messages=_last_messages,
- )
- else:
+ elif _language == "en":
_custom_sys = getattr(
self._llm_config, "extract_system_prompt_en", None
)
- if _custom_sys:
- system_prompt = _custom_sys
- else:
- system_prompt = EXTRACT_SYSTEM_PROMPT
- if getattr(self._llm_config, "few_shot_enabled", False):
- system_prompt = system_prompt + EXTRACT_FEW_SHOT_EN
- if not _enable_intention and not _custom_sys:
- system_prompt = _system_prompt_without_intention(
- system_prompt, lang="en"
+ if _custom_sys:
+ system_prompt = _custom_sys
+ else:
+ system_prompt = get_prompt("EXTRACT_SYSTEM_PROMPT", _language)
+ if getattr(self._llm_config, "few_shot_enabled", False):
+ system_prompt = system_prompt + get_prompt(
+ "EXTRACT_FEW_SHOT", _language
)
- if getattr(self._llm_config, "structure_metadata_enabled", False):
- system_prompt += STRUCTURE_METADATA_PROMPT_EN
- _user_tmpl = (
- EXTRACT_PROMPT if _enable_intention else EXTRACT_PROMPT_NO_INTENTION
- )
- prompt = _user_tmpl.format(
- content=content,
- current_date=_current_date,
- memory_at=_memory_at,
- last_messages=_last_messages,
+ if not _enable_intention and not _custom_sys:
+ system_prompt = _system_prompt_without_intention(
+ system_prompt, lang=_language
)
+ if getattr(self._llm_config, "structure_metadata_enabled", False):
+ system_prompt += get_prompt("STRUCTURE_METADATA_PROMPT", _language)
+ system_prompt = with_output_language(
+ system_prompt, _language, explicit=_explicit_language is not None,
+ )
+ _user_tmpl = get_prompt(
+ "EXTRACT_PROMPT" if _enable_intention else "EXTRACT_PROMPT_NO_INTENTION",
+ _language,
+ )
+ prompt = _user_tmpl.format(
+ content=content,
+ current_date=_current_date,
+ memory_at=_memory_at,
+ last_messages=_last_messages,
+ )
# 累计 token 统计
if _log_llm_content_enabled():
diff --git a/hy_memory/agent/mem_agent.py b/hy_memory/agent/mem_agent.py
index e9ecb60..b27d770 100644
--- a/hy_memory/agent/mem_agent.py
+++ b/hy_memory/agent/mem_agent.py
@@ -144,6 +144,7 @@ class MemAgent:
tool_context: Optional[Dict[str, Any]] = None,
history_context: str = "",
basic_profile_fields: Optional[Dict[str, str]] = None,
+ language: Optional[str] = None,
) -> AgentResult:
"""
处理添加记忆请求
@@ -161,6 +162,7 @@ class MemAgent:
basic_profile_fields:
{field_name: description} 字段表,由调用方从 MemoryConfig.basic_profile.fields
透传过来,extractor 会渲染到 prompt 中要求 LLM 在 JSON basic_info 字段返回。
+ language: 显式 prompt 语言码,透传给 extractor;None 时 zh/en 自动检测。
Returns:
处理结果
@@ -187,6 +189,7 @@ class MemAgent:
tool_context=tool_context,
history_context=history_context,
basic_profile_fields=basic_profile_fields,
+ language=language,
)
_t_parallel = datetime.now()
diff --git a/hy_memory/agent/prompts_zh.py b/hy_memory/agent/prompts_zh.py
index 9a9adce..b87ecbf 100644
--- a/hy_memory/agent/prompts_zh.py
+++ b/hy_memory/agent/prompts_zh.py
@@ -1,1236 +1,22 @@
"""
-中文版 Prompt 定义。
+中文版 Prompt 定义(兼容入口)。
-当检测到用户输入为中文时,使用此文件中的 prompt 替代英文版,
-确保 LLM 输出为中文。
+Prompt 文本已统一迁到 ``hy_memory/prompts/zh_hans.py``(按语言码注册,见
+``hy_memory.prompts.get_prompt``)。这里保留旧的 ``*_ZH`` 名字作为别名,
+字节级不变,旧代码 / 测试照常 import。
"""
-
-# ================================================================
-# EXTRACT PROMPT (中文版)
-# ================================================================
-# System prompt(固定,不参与 format)
-EXTRACT_SYSTEM_PROMPT_ZH = """你是一个记忆提取系统(Memory Extractor)。
-
-你的任务是从对话中提取:
-
-* 持久的
-* 高价值的
-* 对未来对话有帮助的
-
-用户记忆,并将其转换为结构化、可检索、自包含的记忆。
-
----
-
-# 输入内容
-
-你将收到:
-
-* 最近 k 条消息(Last k Messages)
-* 新消息(New Messages)
-* Memory Date
-* Current Date
-
-用途:
-
-* Last k Messages 仅用于:
-
- * 指代消解
- * 上下文理解
-* Memory Date 是唯一允许用于解析时间表达的时间锚点
-* Current Date 仅作为系统元数据,不用于时间推理
-
----
-
-# 提取原则
-
-只提取 NEW user messages 中首次出现的新信息。
-
-优先提取:
-
-* 长期偏好
-* 兴趣爱好
-* 长期项目
-* 未来计划
-* 决策
-* 约束条件
-* 行为习惯
-* 价值观
-* 稳定态度
-* 重复性活动
-* 重要经历
-* 用户接受的建议
-
-不要提取:
-
-* 寒暄
-* 客套话
-* 一次性情绪
-* 临时上下文
-* assistant 对旧 memory 的复述
-* 已经明显存在于历史上下文的信息
-* 模糊的人格评价
-
----
-
-# 主体规则
-
-每条 memory 必须自包含、可脱离上下文理解、使用第三人称,并且有明确主体。
-用哪个主体由**谁在说话**决定:
-
-| 说话人 | 主体写法 | 例子 |
-| --- | --- | --- |
-| `role: "user"` | 用户 | "用户…" / "The user …" |
-| 任何带 `name` 且不是用户的说话人(如 `name: "John"`) | 用这个人的名字 | "John…" |
-| `role: "assistant"` 且**无** `name` | AI 助手 | "助手…" / "The assistant …" |
-
-两个输入区段表达说话人的方式不同:
-
-* **新消息** 是 JSON 数组 —— 读 `role` 和可选的 `name` 字段。
-* **最近 k 条消息** 是渲染文本 —— 说话人是方括号标签 `[user]:` / `[John]:` / `[assistant]:`,
- 文首可能还有一行 "用户名叫Tim" / "The user's name is Tim"。
-
-规则:
-
-* 用户是这些记忆所属的那个人。即使已经知道用户叫什么(来自他消息上的 `name`,
- 或文首的名字行),仍然要写"用户…",**绝不**写成"Tim…"。
-* **`role: "assistant"` 但带 `name` 的是另一个真人,不是 AI。**
- 他的记忆用他的名字作主体:"John…"。
-* 只有不带 `name` 的 `role: "assistant"` 才是 AI 助手。
-* 绝不要给 AI 助手编名字,它没有名字。
-
----
-
-# 语言规则
-
-* 输出语言必须与输入语言一致
-* 保留原始术语、品牌名、公式、代码
-* 不要转写或翻译专有名词
-
----
-
-# 两类记忆
-
-你提取两类记忆:**memory(记忆)** 和 **intentions(意图)**。
-
-## memory(记忆)
-
-一切值得长期记住的信息都放这里——既包括用户本人的,也包括对话中其他具名真人的:
-
-* 偏好、观点、态度、价值观
-* 事件、行动、经历
-* 习惯、行为模式
-* 关系、稳定特质
-* 客观事实、决策、约束条件
-* 正在进行的活动
-
-如果用户隐式表达偏好,也应提取:
-
-* 主动恢复某个活动 → 正向兴趣
-* 长期避免某事 → 负向偏好
-* 重复主动投入 → 持续兴趣
-
-不要把"用户是怎样的人"和"发生了什么"分开。两者都放进 `memory`。
-
-## intentions(意图)
-
-用户**未来打算/计划去做**的、可被执行的、一旦完成或过期就失去意义的前瞻事项。
-
-例如:
-
-* "用户下周二要面试。"
-* "用户打算月底搬家。"
-* "用户计划周五前完成报告。"
-
-不属于意图(这些放进 `memory`):
-
-* 稳定偏好/特质("用户喜欢篮球")
-* 已完成的过去事件("用户去年搬到了北京")
-* 没有明确未来行动的泛泛目标
-
-### valid_until(有效截止日)
-
-每条 intention 给出 `valid_until`:该意图失效的日期(截止日/目标日),
-基于 **Memory Date** 解析相对时间(如"下周二"→对应的绝对日期)。
-如果无法确定截止日,则设为 `null`。
-
----
-
-# OWNER(归属)
-
-每条 memory 和 intention 都必须带 `owner`,标明它属于哪个记忆库。只有两个取值:
-
-* `"user"` —— 属于用户自己记忆库的一切。既包括关于用户本人的事实/偏好/特质,
- **也包括关于对话中其他具名真人的事实** —— 那些同样是用户的记忆该装的东西。
-* `"agent"` —— AI 助手(不带 `name` 的 `role: "assistant"`)提供的信息
- (推荐、确认、查到的资料),或用户希望 **assistant** 未来去做的事(如"8 小时后提醒我")。
-
-具名真人**绝不**是 `owner: "agent"` —— 他是真人不是 AI,即使他的消息带着
-`role: "assistant"`。他的记忆是 `owner: "user"`,content 以他的名字作主体。
-
-逐条判定 `owner`。无法确定时默认 `"user"`。
-
----
-
-# 时间规则
-
-使用 Memory Date 解析:
-
-* 明天
-* 下周
-* 上个月
-* 最近
-
-等相对时间。
-
-如果无法安全解析:
-
-* 去掉相对时间表达
-* 保持记忆无时间依赖
-
-不要编造时间顺序。
-
-**"刚刚发生"本身就是事件,必须保留。** 当用户把某件事说成刚完成("刚回来"、"刚做完"、
-"今天早上"、"昨天"),完成时间就是 Memory Date。要写出**这个事件本身**并带上该日期,
-不要把它揉进一句背景描述。
-
-* "我刚和家人旅行回来"
- → "用户于 <Memory Date> 结束家庭旅行返回。"
- 错误 → "用户会和家人一起旅行。"(返回日期正是"什么时候回来的"的答案,丢了这道题就答不了)
-
-如果对话分别给出了一件事的开始和结束时间,两者都要记录,不要压缩成一个时间段。
-
----
-
-# 质量要求
-
-每条 memory 必须:
-
-* 信息完整
-* 自包含
-* 适合 retrieval
-* 高信息密度
-
-保留重要细节:
-
-* 人名
-* 产品名
-* 地点
-* 数字
-* 公式
-* 约束条件
-
-绝不把具体事物泛化成类别,要写实际说出来的内容。
-
-* "Banff" → 保留 "Banff",不要写成"落基山脉"
-* "一只三岁的边牧 Luna" → 品种、年龄、名字都要保留
-
-**对方话轮里提供的细节同样算。** 一个事实常常是跨话轮建立起来的:对方说出具体名称,
-用户确认。主体规则决定这条记忆**属于谁**,但不等于可以丢掉细节。
-
-* [Sam]:"你在 Banff 滑雪了吗?"
- [user]:"是啊,滑雪特别棒!"
- → "用户在 Banff 滑过雪,觉得雪况很棒。"
- 错误 → "用户喜欢冬季运动。"(地点和活动分别由两人给出,都已确立)
-
-避免:
-
-* 缺少上下文的碎片化记忆
-* 纯情绪噪音
-* 无长期价值的信息
-
-用尽量少的 memory 保留彼此独立的未来检索需求:
-
-* 压缩是合并,不是省略。新消息中每个明确、持久的命题都应恰好出现一次。
-* 同一主体、同一现实事件、状态、偏好、计划或决定的细节应合成一条;一条完整事件可用 1–3 句。
-* 不要同时输出同一证据的宽泛概括和多个狭窄改写。
-* 只有主体不同、事件独立发生或状态不同才拆分。
-* 如果拆开会丢失关系,就把原因、建议或结果与它所解释的事实保存在同一条 memory 中。
-* 不要因为主题相同,就合并不同日期独立发生的事件。
-* 保持原文的时间精度。除非日期明确或可唯一确定,不要把“上周末”“去年夏天”等模糊时间改写成具体日期;可以写“Memory Date 之前的周末”。
-
----
-
-# TAGS
-
-每条 memory 必须包含 1–3 个 tags。
-
-要求:
-
-* 主题类标签用小写(travel、health、work)
-* 专名保留大小写(Jasper、Canada、Banff)
-* 简洁
-* 主题明确
-
-例如:
-
-* ai
-* work
-* travel
-* gaming
-* research
-"""
-
-STRUCTURE_METADATA_PROMPT_ZH = """
-
----
-
-# 结构化组织
-
-每条 `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。共同事件可为每个明确参与者分别归属,但正文仍
- 只保留一份 canonical memory。
- 类型顺序必须是 `topic -> facet -> series -> episode`;允许跳层,但禁止重复或倒序。
-
-Extractor 只看到当前一次写入,不能证明跨 occurrence 的重复,因此不得输出 series 段;这里只
-输出 Topic/Facet/Episode。Reconcile 在比较独立历史写入后才可以建立 Series。
-
-这是写入时的语义组织。不能按路径深度臆断 Series/Episode,不能根据专名、宽泛 tag 或无关
-共现臆造归属;只写证据支持的最具体层级,不确定时使用空值。
-禁止把 when/how many/who、复数、序数等未来问句形态编码进这些字段。
-"""
-
-EXTRACT_PROMPT_ZH = """## 最近 k 条消息
-
-{last_messages}
-
----
-
-## 新消息
-
-{content}
-
----
-
-## Memory Date
-
-{memory_at}
-
----
-
-## Current Date
-
-{current_date}
-
----
-
-
-# 输出格式
-
-仅返回一个 JSON 对象。
-
-格式:
-
-```json
-{{
- "memory": [
- {{
- "content": "...",
- "tags": ["..."],
- "owner": "user"
- }}
- ],
- "intentions": [
- {{
- "content": "...",
- "tags": ["..."],
- "valid_until": "YYYY-MM-DD",
- "owner": "user"
- }}
- ],
- "basic_info": {{}}
-}}
-```
-
-规则:
-
-* memory:
- 一切值得长期记忆的信息——偏好、观点、态度、特质、事件、计划、经历、习惯、决策。
- 既可以是关于 `[user]` 的,也可以是关于其他具名真人(`[John]`)的,主体写法见上方"# 主体规则"
-
-* intentions:
- 用户(或其他具名真人)未来打算/计划去做的前瞻事项,附 `valid_until`(截止日/目标日,
- 基于 Memory Date 解析);无法确定截止日时设为 `null`
-
-* owner(每条 memory 和 intention 都必填):`"user"` 或 `"agent"`
- (见上方"# OWNER";无法确定时默认 `"user"`)
-
-* basic_info:**只装用户本人的画像**。
- 仅当 NEW user messages 中**明确**陈述稳定画像字段(如 姓名、年龄、所在地、职业、雇主)时才填写。
- 绝不推断、绝不编造。没有任何字段被明确陈述时输出 `{{}}`。
- * **硬性规则**:只有用户在 `user` 回合里**明确说出**的字段才能填写。只在
- assistant 回合出现的内容(包括 assistant 引用旧记忆,如"The user's name is X"
- / "用户名是X")一律不算。没有符合条件的字段时,必须输出 `"basic_info": {{}}`。
- * **绝不**把字段名本身或占位符当值写入("用户"、"The user"、"user"、"name"、
- "姓名"、"N/A"、"unknown"、"未知"、"未提供"、"-"),宁可省略该字段。
- * 负例:寒暄如 `[user]: 你好` / `[assistant]: 我可以帮你。`,或
- `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`。
- * `name` 的例外:用户自己那条消息上的 `name` 字段,或文首形如
- "用户名叫X" / "The user's name is X" 的那一行,都是 `name` 的权威来源
- ——即使用户本人从未开口自报姓名。
- * **绝不**把其他真人的属性放进来。John(带 `name` 的 assistant 角色消息)说
- "我在柏林当护士",那是一条 `memory`("John是柏林的护士。"),
- **不是** `basic_info` 的 `occupation` / `location`。
-
-* 不要跨 section 重复信息
-
-* tags 必须为 1–3 个关键词(主题小写;地名/人名等专名保留大小写)
-
-* 没有内容时使用 [] 或 {{}}
-
-* 仅输出合法 JSON
-
-现在请输出JSON内容"""
-
-
-EXTRACT_PROMPT_ZH_NO_INTENTION = """## 最近 k 条消息
-
-{last_messages}
-
----
-
-## 新消息
-
-{content}
-
----
-
-## Memory Date
-
-{memory_at}
-
----
-
-## Current Date
-
-{current_date}
-
----
-
-
-# 输出格式
-
-仅返回一个 JSON 对象。
-
-格式:
-
-```json
-{{
- "memory": [
- {{
- "content": "...",
- "tags": ["..."],
- "owner": "user"
- }}
- ],
- "basic_info": {{}}
-}}
-```
-
-规则:
-
-* memory:
- 一切值得长期记忆的信息——偏好、观点、态度、特质、事件、经历、习惯、决策,
- **以及未来计划 / 即将发生的安排**(不要单独开 intentions 桶)。
- 既可以是关于 `[user]` 的,也可以是关于其他具名真人(`[John]`)的,主体写法见上方"# 主体规则"
-
-* owner(每条 memory 必填):`"user"` 或 `"agent"`
- (见上方"# OWNER";无法确定时默认 `"user"`)
-
-* basic_info:**只装用户本人的画像**。
- 仅当 NEW user messages 中**明确**陈述稳定画像字段(如 姓名、年龄、所在地、职业、雇主)时才填写。
- 绝不推断、绝不编造。没有任何字段被明确陈述时输出 `{{}}`。
- * **硬性规则**:只有用户在 `user` 回合里**明确说出**的字段才能填写。只在
- assistant 回合出现的内容(包括 assistant 引用旧记忆,如"The user's name is X"
- / "用户名是X")一律不算。没有符合条件的字段时,必须输出 `"basic_info": {{}}`。
- * **绝不**把字段名本身或占位符当值写入("用户"、"The user"、"user"、"name"、
- "姓名"、"N/A"、"unknown"、"未知"、"未提供"、"-"),宁可省略该字段。
- * 负例:寒暄如 `[user]: 你好` / `[assistant]: 我可以帮你。`,或
- `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`。
- * `name` 的例外:用户自己那条消息上的 `name` 字段,或文首形如
- "用户名叫X" / "The user's name is X" 的那一行,都是 `name` 的权威来源
- ——即使用户本人从未开口自报姓名。
- * **绝不**把其他真人的属性放进来。
-
-* 不要跨 section 重复信息
-* tags:1–3 个关键词;主题小写,专名保留大小写
-* 不要输出 `intentions` 字段
-
-"""
-
-
-
-# ================================================================
-# EXTRACT FEW-SHOT 示例(中文版)
-# ================================================================
-# 仅在 few_shot_enabled 时附加到 system prompt 末尾。
-# 每个示例都贴合真实输入结构(最近 k 条消息 / 新消息 / Memory Date)
-# 与输出 schema(memory / intentions / basic_info,含 owner 与 tags),
-# 并在结尾给出一句要点点评。
-EXTRACT_FEW_SHOT_ZH = """
----
-
-# 示例
-
-## 示例 1 —— 边界:旧消息只用于指代消解,绝不重复提取
-
-最近 k 条消息:
-[{"role": "user", "content": "我最近在市中心的收容所看流浪狗。"},
- {"role": "assistant", "content": "真好——有看中的吗?"}]
-新消息:
-[{"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 —— 浓缩 agent 的长篇回复
-
-新消息:
-[{"role": "user", "content": "帮我写一篇短文,论述为什么远程办公能提升效率。"},
- {"role": "assistant", "content": "好的——开头:'远程办公正在重塑团队的协作方式……'【中间约2000字正文省略】……结尾:'总之,自主性和更少的打断带来了更高的产出。'"}]
-Memory Date:2025-03-22
-
-输出:
-```json
-{
- "memory": [
- {"content": "assistant 为用户写了一篇短文,论点是远程办公因自主性更强、打断更少而提升效率。", "tags": ["writing", "remote-work"], "owner": "agent"}
- ],
- "intentions": [],
- "basic_info": {}
-}
-```
-agent 的回复很长。绝不原样存储整篇短文,而要提炼成"主题+论点"。owner 为 "agent",因为内容由 assistant 产出。臃肿的原文会让 memory 不可用。
-
-## 示例 3 —— 复合提取:basic_info + intention + 概括后的 agent 计划
-
-新消息:
-[{"role": "user", "content": "你好,我叫健司。我下个月打算去日本旅行,能帮我做一个7天的行程吗?"},
- {"role": "assistant", "content": "# 日本7天经典黄金路线(东京 → 京都 → 奈良 → 大阪)\\n飞抵东京,乘新干线南下京都,奈良一日游,最后从大阪关西机场离境。\\n\\n## 第1天:抵达东京\\n- 降落羽田/成田,在东京站附近酒店放行李。\\n- 傍晚:浅草寺,逛仲见世商店街,尝鲷鱼烧。\\n- 晚上:涩谷十字路口 + 涩谷天空看日落;居酒屋晚餐(烤串、清酒)。\\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": "assistant 为用户制定了一份7天日本经典黄金路线行程:东京(浅草、涩谷)、新干线到京都(伏见稻荷、清水寺、金阁寺、祇园)、奈良一日游(喂鹿公园、东大寺),最后大阪(大阪城、道顿堀),从关西机场离境。", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
- ],
- "intentions": [
- {"content": "用户计划在2025年10月去日本旅行7天。", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
- ],
- "basic_info": {"name": "健司"}
-}
-```
-一个轮次产出三种不同 bucket:姓名进 basic_info;旅行是带截止日的前瞻 intention;assistant 那份很长的多段行程被概括成**一条**高密度 agent memory——只保留路线骨架和各城市的关键景点,而**不是**逐日的细节、贴士或美食清单。原样存整篇回复会让 memory 臃肿,存骨架才可检索。
-
-## 示例 4 —— 后续消息中用户采纳/确认了先前建议,本身就是事实
-
-新消息:
-[{"role": "user", "content": "我家6岁的孩子一点蔬菜都不肯吃,有什么办法吗?"},
- {"role": "assistant", "content": "可以把菠菜或胡萝卜打碎拌进意面酱里——颜色和味道基本尝不出来,很多孩子就这么接受了。"},
- {"role": "user", "content": "好主意,今晚就试试。对了,这个年纪几点睡比较好?"},
- {"role": "assistant", "content": "6岁的孩子建议晚上7到9点睡,保证大约10到11小时睡眠。"}]
-Memory Date:2025-06-20
-
-输出:
-```json
-{
- "memory": [
- {"content": "用户有一个6岁的孩子,不肯吃蔬菜,用户采纳了 assistant 的建议——把菠菜或胡萝卜打碎拌进意面酱里以掩盖蔬菜。", "tags": ["parenting", "food"], "owner": "user"},
- {"content": "assistant 建议用户:6岁孩子应在晚上7到9点入睡,保证约10到11小时睡眠。", "tags": ["parenting", "sleep"], "owner": "agent"}
- ],
- "intentions": [],
- "basic_info": {}
-}
-```
-用户在第三条消息说"今晚就试试"——明确采纳了先前的建议。这条采纳信息很有价值,必须记录("用户采纳了……"),不能当寒暄丢掉。睡眠建议刚给出、尚未被采纳,因此记为 assistant 给出的建议(owner "agent")。
-
-## 示例 5 —— RAG/注入上下文:绝不存储被注入的文本
-
-新消息:
-[{"role": "user", "content": "【检索到的资料:埃菲尔铁塔高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 注入的文本只是给模型的上下文,永远不是 memory。
-
-## 示例 6 —— 用户分享资料:提取资料内容,而非分享动作
-
-新消息:
-[{"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 —— 结构化数值与属性完整保留
-
-新消息:
-[{"role": "user", "content": "记一下我这个周期的家庭健身房 PR:深蹲 140kg x 3,卧推 100kg x 5,硬拉 180kg x 2,推举 60kg x 6。体重 78kg,每个动作 3 组,组间休息 3 分钟。"},
- {"role": "assistant", "content": "记好了——数据很强!"}]
-Memory Date:2026-01-20
-
-输出:
-```json
-{
- "memory": [
- {"content": "用户当前的力量 PR 为深蹲 140kg x 3、卧推 100kg x 5、硬拉 180kg x 2、推举 60kg x 6,体重 78kg。", "tags": ["fitness", "strength"], "owner": "user"},
- {"content": "用户的训练安排为每个动作 3 组、组间休息 3 分钟。", "tags": ["fitness", "training"], "owner": "user"}
- ],
- "intentions": [],
- "basic_info": {}
-}
-```
-每个数值和单位(kg、次数、组数、休息时间)都完整保留——丢掉它们会毁掉最可检索的信息。拆成两个清晰主题(PR 与训练方案),但绝不取整或省略具体数值。
-
-## 示例 8 —— 多主题长对话:不要只提取第一个话题
-
-新消息:
-[{"role": "user", "content": "这周很重要——我周二终于通过了博士论文答辩!"},
- {"role": "assistant", "content": "太恭喜了!感觉怎么样?"},
- {"role": "user", "content": "如释重负!我还在柏林签了一套公寓的租约,下个月搬过去。另外我开始在多邻国学德语了——已经连续打卡30天。我的伴侣索菲娅暂时还留在马德里,这点挺难受的。"}]
-Memory Date:2025-11-08
-
-输出:
-```json
-{
- "memory": [
- {"content": "用户在2025-11-04通过了博士论文答辩。", "tags": ["education", "milestone"], "owner": "user"},
- {"content": "用户在柏林签了一套公寓的租约。", "tags": ["housing"], "owner": "user"},
- {"content": "用户在多邻国学德语,已连续打卡30天。", "tags": ["language", "learning"], "owner": "user"},
- {"content": "用户的伴侣索菲娅暂时留在马德里,用户觉得这点挺难受。", "tags": ["relationship"], "owner": "user"}
- ],
- "intentions": [
- {"content": "用户计划下个月(2025年12月左右)搬到柏林。", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
- ],
- "basic_info": {}
-}
-```
-四个以上话题——答辩、柏林公寓、学德语、伴侣在马德里。不要只提取第一个话题。注意一个轮次拆出了已完成的事实(已签租约)和一条 intention(即将搬家),关于索菲娅的情绪虽带情绪但含长期关系信息,因此保留。
-
-## 示例 9 —— 两个真人:assistant 消息带 name 说明那是真人
-
-新消息:
-[{"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年7月左右受伤的肩膀还在疼。", "tags": ["fitness", "health"], "owner": "user"}
- ],
- "intentions": [],
- "basic_info": {"name": "Tim"}
-}
-```
-John 带的是 `role: "assistant"`,但他有 `name`,所以他是另一个真人而不是 AI:他的记忆用"John…"作主体,且 `owner` 仍是 `"user"`(属于用户的记忆库)。用户自己的记忆仍写"用户…",即使已知他叫 Tim 也不能写成"Tim每周攀岩三次"。`basic_info.name` 来自用户那条消息上的 `name: "Tim"`——它是权威来源,即使 Tim 本人从未开口自报姓名。
-
-## 示例 10 —— 反例:别人的属性绝不进 basic_info
-
-新消息:
-[{"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` / `location` —— `basic_info` 专属于用户本人。只有 `name`(Tim,来自用户消息的 `name` 字段)才该放进去。注意输出语言随输入语言(此例为英文)。
-
-## 示例 11 —— 反例:寒暄没有 basic_info
-
-新消息:
-[{"role": "user", "content": "你好"},
- {"role": "assistant", "content": "你好!我可以帮你。之前记得 The user's name is 用户."}]
-Memory Date:2025-09-03
-
-输出:
-```json
-{
- "memory": [],
- "intentions": [],
- "basic_info": {}
-}
-```
-用户没有说任何关于自己的信息。assistant 那句不是 user 回合,"用户" 也是占位符而不是名字。必须输出 `{}`——**绝不能**输出 `{"name": "用户"}`。
-
----
-"""
-
-
-# ================================================================
-# SEARCH_QUERY PROMPT (中文版)
-# ================================================================
-
-SEARCH_QUERY_PROMPT_ZH = """你是一个搜索查询生成器。给定一组新提取的记忆,生成一组简短的搜索查询,用于在向量数据库中找到相关的已有记忆。
-
-目标是最大化召回率——即使措辞差异很大,也要找到与新记忆语义相关的已有记忆。
-
-## 新记忆:
-{new_memories}
-
-## 指引
-
-生成的搜索查询应覆盖:
-- 记忆中提到的关键主题、实体和主题
-- 核心概念的改写或抽象版本
-- 用户记忆库中可能存在的相关概念
-
-输出一个 JSON 字符串数组(5-15条查询,简短聚焦):
-
-["查询1", "查询2", "查询3", ...]
-
-只输出 JSON 数组,不要有其他文字。"""
-
-
-# ================================================================
-# RECONCILE PROMPT (中文版)
-# ================================================================
-
-
-RECONCILE_PROMPT_ZH = """你是一个记忆整合系统(Memory Reconciler)。
-
-你的任务是将新的 memories 整合进已有 memory base,同时保持:
-
-* 信息无损
-* 无矛盾
-* 高可检索性
-* 结构紧凑
-* 避免碎片化
-
----
-
-# 输入内容
-
-你将收到:
-
-* Existing memories
-* New memories
-* Current date
-
----
-
-# Existing memories
-
-每条 existing memory 包含:
-
-* memory_id
-* content
-* owner
-* memory_at
-* tags
-
----
-
-# New memories
-
-每条 new memory 包含:
-
-* content
-* owner
-* memory_at(发生时间)
-* tags
-
-new memories 没有 ID。
-
----
-
-# 操作类型
-
----
-
-## ADD
-
-当信息:
-
-* 完全新
-* 与已有 memory 不冲突
-* 不属于已有主题
-
-时使用。
-
-格式:
-
-```json
-{{
- "op": "ADD",
- "content": "...",
- "owner": "user",
- "tags": ["..."]
-}}
-```
-
----
-
-## UPDATE
-
-当:
-
-* 新旧 memory 描述同一主题
-* 且没有冲突
-* 合并后能提高完整性或可检索性
-
-时使用。
-
-要求:
-
-* 无损合并
-* 保留所有有效信息
-* 不要产生重复 memory
-* 两者在某个值上不一致时,保留 memory_at 更晚的那个值;绝不用更早的 memory 覆盖更新的值
-
-### 同一次事件的补充 vs 另一次发生
-
-只有当新 memory 是在补充**同一次现实事件**或同一条持久事实时,才使用 **UPDATE**。
-
-如果同一个人在另一个时间再次发生同类活动/事件(另一次旅行、比赛、受伤、购买、健康事件等),
-应保留为独立 **ADD**,并保留该次自己的日期与细节。如果已有 memory 明确是同一具体系列的另一次
-发生,可添加 `related: [{{"memory_id":"...","relation":"same_series"}}]`。
-
-不要把多个不同日期的事件合并成一条很长的次数/时间线 memory;检索层会从这些关联的 L2 组装 timeline。
-
-格式:
-
-```json
-{{
- "op": "UPDATE",
- "memory_id": "...",
- "content": "...",
- "owner": "user",
- "tags": ["..."]
-}}
-```
-
----
-
-## SUPERSEDE
-
-仅在以下情况使用:
-
-* 新 memory 与旧 memory 在同一维度冲突
-* 两者不能同时为真
-* 旧 memory 已不再代表当前状态
-* 新 memory 的 memory_at 不早于旧 memory 的 memory_at
-
-例如:
-
-* 用户换城市
-* 用户换工作
-* 用户关系状态变化
-* 用户长期偏好发生明确反转
-
-不要用于:
-
-* 增加细节
-* wording 差异
-* 同义表达
-* 可共存偏好
-* 新 memory 的 memory_at 早于旧 memory:它是更早的状态,绝不能取代更新的状态(见「时间规则」)
-
-要求:
-
-* content 只能写“新的状态”
-* 不要复制旧信息
-* 系统会自动保留旧节点并接到演化链上,你无需关心历史版本
-
-格式:
-
-```json
-{{
- "op": "SUPERSEDE",
- "memory_id": "...",
- "content": "...",
- "supersede_reason": "...",
- "owner": "user",
- "tags": ["..."]
-}}
-```
-
-### 把多条旧记忆折叠进同一条链
-
-如果**两条或更多**已有记忆描述的是**同一维度**,而新记忆是该维度上的最新变化(它的 memory_at 晚于所有被折叠的记忆),
-你可以把它们折叠进同一条演化链。此时用 `memory_ids`(有序列表,**旧→新**)
-代替单个 `memory_id`:
-
-```json
-{{
- "op": "SUPERSEDE",
- "memory_ids": ["<最旧的id>", "<较新的id>"],
- "content": "<只写最新的状态>",
- "supersede_reason": "...",
- "owner": "user",
- "tags": ["..."]
-}}
-```
-
-列出的旧记忆会按旧→新连成一条链,新记忆成为链头。`content` 仍然只描述**最新状态**——
-**绝不**把旧记忆的内容抄进来;旧内容保留在链的历史里,依然可被检索。
-
----
-
-# 关键规则
-
----
-
-## 信息无损
-
-所有有效信息必须仍然可检索。
-
-不要丢失:
-
-* 新 memory 中的信息
-* 被 UPDATE/SUPERSEDE 的旧信息
-
-注意:
-
-SUPERSEDE 不需要复制旧内容,因为旧节点仍存在。
-
----
-
-## 重复检测
-
-如果 new memory 已经被 existing memory 完整覆盖:
-
-不要输出任何操作。
-
----
-
-## 避免碎片化
-
-如果多个 memory:
-
-* 讨论同一主题
-* 内容兼容
-
-优先 UPDATE 合并。
-
-不同日期的独立事件保持独立 ADD;仅在主体相同且具体活动/事件类型相同时使用 `same_series`。
-
----
-
-## Granularity
-
-每条 memory 应只表达:
-
-* 一个完整主题
-* 一个清晰状态
-
-避免:
-
-* 过碎
-* 过长
-* 多主题混杂
-
----
-
-## 主体规则
-
-**绝不跨主体合并或 supersede。** 主体是 content 所描述的那个人:"用户…" / "John…" / "Mary…"。
-关于不同人的记忆是彼此独立的事实,即使句式几乎一样 —— "用户喜欢喝咖啡" 和 "John喜欢喝咖啡"
-是两条各自独立的记忆,绝不能互相 UPDATE 或 SUPERSEDE。
-
----
-
-## owner 规则
-
-`owner`(`user`/`agent`):从被写入的 memory 原样拷贝。
-**绝不跨 owner 合并或 supersede** —— 用户的事实和 assistant 的事实即使主题相同也是两条不同记忆。
-
----
-
-## 时间规则
-
-每条 memory(新的和已有的)都带 memory_at,表示它发生的时间。记忆**不一定按发生顺序写入**:
-历史可能晚导入,导入还没处理完时用户也可能手动添加记忆。所以一条 new memory 可能**比已有记忆更早**。
-
-* 新旧**只看 memory_at**。"New memories" 只表示"正在写入",不表示"更近"。
-* 更早的 memory 绝不能取代更新的 memory:不能 SUPERSEDE 一条更新的记忆,也不能用 UPDATE 拿更早的值覆盖更新的值。
-* 如果 new memory 比与它冲突的已有记忆更早:保留已有记忆作为当前状态;把 new memory 以"过去状态"ADD
- (用过去时,并带上时间,例如"2023 年用户住在上海"),没有新信息就不输出。
-* `memory_at: null` 表示时间未知。未知**不算更新**:不要用 memory_at 为 null 的 memory 去 SUPERSEDE 一条有时间的记忆。
-* 不要编造时间顺序。
-* 不要仅因为“看起来更新”就 supersede。
-
----
-
-## NO FORK RULE
-
-* SUPERSEDE 要么指向一条 existing memory(`memory_id`),要么把**同一维度**的多条
- memory 折叠进同一条链(`memory_ids`,旧→新);UPDATE 只能指向一条 existing memory。
-* 同一条 existing memory 不得被多个操作 touch。
-* 不要创建分叉 supersede 链。
-
----
-
-## 可选字段:`related`
-
-任何操作上都**可以**附加一个 `related` 数组,记录本次写入的 memory 与某条
-**已有 memory** 之间的关系。它不改变存什么,只是额外记一条关联。
-
-```json
-{{
- "op": "ADD",
- "content": "...",
- "owner": "user",
- "tags": ["..."],
- "related": [{{"memory_id": "<已有记忆的 id>", "relation": "causes"}}]
-}}
-```
-
-只允许这四种关系:
-
-* `causes` —— 两条记忆构成因果(如"开始每天跑步" → "膝盖开始疼")
-* `elaborates` —— 对已有记忆的细化,或它的后续发展
-* `contrasts` —— 两者存在张力但**都仍然成立**(如果一条让另一条不再成立,
- 那是 SUPERSEDE,不是 `contrasts`)
-* `same_series` —— 同一主体、同一具体活动或事件类型在不同时间的独立发生
- (例如两次不同的滑雪旅行)
-
-要求:
-
-* 只能关联到"已有记忆"里出现过的 id,**绝不编造 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 array。
-
-例如:
-
-```json
-[
- {{
- "op": "ADD",
- "content": "...",
- "owner": "user",
- "tags": ["..."]
- }},
- {{
- "op": "UPDATE",
- "memory_id": "...",
- "content": "...",
- "owner": "user",
- "tags": ["..."]
- }},
- {{
- "op": "SUPERSEDE",
- "memory_id": "...",
- "content": "...",
- "supersede_reason": "...",
- "owner": "user",
- "tags": ["..."]
- }}
-]
-```
-
-如果无需修改:
-
-```json
-[]
-```
-
-仅输出合法 JSON。
-
-现在输出 JSON 数组。"""
-
-RECONCILE_STRUCTURE_METADATA_PROMPT_ZH = """
-
-附加结构输出契约:
-
-每条 ADD、UPDATE 或 SUPERSEDE 结果都要保留或修正 `topic_paths`、`event_facet` 与
-`topic_assignments`。
-`topic_paths` 是从宽到窄的语义路径,例如 `["sport", "swimming"]`;不能仅凭共享宽 tag
-猜父子关系。`event_facet` 只含 subject/participants/action/objects/locations/state。
-`topic_assignments` 按主体给出带类型的 topic/facet/series/episode 路径;Series/Episode 必须
-由事实本身明确支持,不能由路径深度推断;类型顺序必须遵守
-`topic -> facet -> series -> episode`(可跳层,不可重复或倒序)。如果 Existing memories
-中已有主体相同、语义等价
-且边界兼容的路径,应复用其完全相同的节点名称和类型,避免同义节点分叉。需要精确复用时输出
-`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
-"through":"topic|facet|series|episode"}]`;ID 必须来自 Existing memories,`through` 表示复制
-该旧路径直到指定类型,新事实明确给出的更深后缀仍保持为新节点。主体、具体活动/状态线或
-Episode 边界不同则禁止强行复用。所有结构字段均不得编码
-when/how many/who、复数或序数等未来问句形态。
-
-Series 只能在 reconcile 阶段建立:新 memory 与至少一条独立 Existing memory 必须是同一具体
-活动/状态线的不同 occurrence。当前一次写入拆出的多个命题不能作为重复发生的证据。
-"""
-
-
-# 中文版 reconcile few-shot 示例(仅在 few_shot_enabled 时注入 {few_shot_section})。
-# 每个示例给出 existing/new 输入与期望的 ops,并附一句要点点评。ID 为简写。
-RECONCILE_FEW_SHOT_ZH = """
-###################
-示例
-###################
-
-## 示例 1 —— 同一条新记忆:一部分与已有链冲突,另一部分无关
-
-已有记忆:
-[
- {"memory_id": "m1", "content": "用户在 Stripe 担任产品经理。", "owner": "user", "history_versions": [{"content": "用户在一家金融科技创业公司做产品经理。"}]}
-]
-新记忆:
-[
- {"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 同维度,m1 已带历史 → SUPERSEDE,成为新链头)和一个无关细节(陶艺 → ADD)。要把这一条记忆按不同部分拆成不同操作——新链头只描述就业状态,绝不带上陶艺。
-
-## 示例 2 —— 把两条未成链的旧记忆 + 新变化折叠成一条 3 节点链
-
-已有记忆:
-[
- {"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"}
-]
-新记忆:
-[
- {"content": "用户现在在本地的开放麦之夜表演吉他。", "owner": "user"}
-]
-
-输出:
-```json
-[
- {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "用户在本地的开放麦之夜表演吉他。", "supersede_reason": "吉他水平演进:学习 → 能弹曲子 → 登台表演", "owner": "user", "tags": ["music", "hobby"]}
-]
-```
-a1 和 a2 原本没有链关系,但它们描述的是同一维度(吉他水平的进展),新记忆是最新一步。用 `memory_ids` 按旧→新折叠,它们成为一条 3 节点链(a1 ← a2 ← 新链头)。链头 `content` 只描述当前状态——不要再复述"在学"或"能弹几首"。
-
-## 示例 3 —— 新链头绝不能复制旧记忆的内容
-
-已有记忆:
-[
- {"memory_id": "c1", "content": "用户租住在东京涩谷的一居室,月租 18 万日元,很喜欢走 5 分钟就到地铁站,但抱怨晚上很吵、还没有停车位。", "owner": "user"}
-]
-新记忆:
-[
- {"content": "用户刚买下并搬进了横滨郊区的一套三居室房子,带花园和双车位车库。", "owner": "user"}
-]
-
-输出:
-```json
-[
- {"op": "SUPERSEDE", "memory_id": "c1", "content": "用户买下并搬进了横滨郊区的一套三居室房子,带花园和双车位车库。", "supersede_reason": "居住地从涩谷租住的一居室变为横滨自有的三居室", "owner": "user", "tags": ["housing"]}
-]
-```
-新记忆 SUPERSEDE c1 并成为链头。链头 `content` 只描述横滨的新房子。**不要**把旧住处那些鲜明的细节(涩谷、18 万月租、走 5 分钟到地铁、吵闹、没停车位)拖进新节点——它们明显属于旧住处而非新家。这些保留在链历史里、仍可检索;抄进来会让链头自相矛盾(同时既在涩谷租房又在横滨买房)。
-
-## 示例 4 —— 主体不同就绝不合并,措辞再像也不行
-
-已有记忆:
-[
- {"memory_id": "d1", "content": "用户每天早上喝黑咖啡。", "owner": "user"}
-]
-新记忆:
-[
- {"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)
-
-已有记忆:
-[
- {"memory_id": "i1", "content": "John injured his ankle last season and needed time off plus physical therapy.", "owner": "user", "memory_at": "2023-05-21 19:48"}
-]
-新记忆:
-[
- {"content": "John twisted his ankle again during a recent game.", "owner": "user", "memory_at": "2023-10-13 13:50"}
-]
-
-输出:
-```json
-[
- {"op": "UPDATE", "memory_id": "i1", "content": "John has injured his ankle two times: first last season (around the 2022–2023 season), needing time off and physical therapy; second during a game around 2023-10-13.", "owner": "user", "tags": ["health", "basketball", "injury"]}
-]
-```
-同一类事件再次发生 → UPDATE 旧记忆:写出**总次数**,并按时间列出每次。不要再 ADD 一条 “John injured his ankle”,也不要 SUPERSEDE(第一次受伤并未变成假)。
-"""
+from ..prompts.zh_hans import ( # noqa: F401
+ EXTRACT_FEW_SHOT as EXTRACT_FEW_SHOT_ZH,
+ EXTRACT_PROMPT as EXTRACT_PROMPT_ZH,
+ EXTRACT_PROMPT_NO_INTENTION as EXTRACT_PROMPT_ZH_NO_INTENTION,
+ EXTRACT_SYSTEM_PROMPT as EXTRACT_SYSTEM_PROMPT_ZH,
+ RECONCILE_FEW_SHOT as RECONCILE_FEW_SHOT_ZH,
+ RECONCILE_PROMPT as RECONCILE_PROMPT_ZH,
+ RECONCILE_STRUCTURE_METADATA_PROMPT as RECONCILE_STRUCTURE_METADATA_PROMPT_ZH,
+ SEARCH_QUERY_PROMPT as SEARCH_QUERY_PROMPT_ZH,
+ STRUCTURE_METADATA_PROMPT as STRUCTURE_METADATA_PROMPT_ZH,
+)
# ================================================================
diff --git a/hy_memory/agent/reconciler.py b/hy_memory/agent/reconciler.py
index 6c67cf0..3521ee7 100644
--- a/hy_memory/agent/reconciler.py
+++ b/hy_memory/agent/reconciler.py
@@ -160,299 +160,18 @@ class ReconcileResult:
# Prompts
# ================================================================
-SEARCH_QUERY_PROMPT = """You are a search query generator. Given a list of newly extracted memories, generate a set of short search queries that can be used to find related existing memories in a vector database.
-
-The goal is to maximize recall — find existing memories that are semantically related to the new memories, even if the wording is very different.
-
-## New memories:
-{new_memories}
-
-## Instructions
-
-Generate search queries that cover:
-- Key topics, entities, and themes mentioned in the memories
-- Rephrased or abstracted versions of the core concepts
-- Related concepts that might exist in the user's memory store
-
-Output a JSON array of query strings (5-15 queries, short and focused):
-
-["query1", "query2", "query3", ...]
-
-Output JSON array only, no other text."""
-
-RECONCILE_PROMPT = """You are a memory management system.
-
-Your task is to merge new memories into an existing memory base while keeping it:
-
-* lossless
-* non-contradictory
-* compact
-* highly retrievable
-
----
-
-# Operations
-
-## ADD
-
-Use when the information is entirely new.
-
-```json
-{{
- "op": "ADD",
- "content": "...",
- "owner": "user",
- "tags": ["..."]
-}}
-```
-
----
-
-## UPDATE
-
-Use when:
-
-* the new memory is compatible with an existing one
-* they describe the same topic
-* merging improves completeness or retrievability
-
-Rules:
-
-* merge losslessly
-* preserve all useful information
-* do NOT create duplicates
-* if the two disagree on a value, keep the value from the memory with the later
- `memory_at`; never let an older memory overwrite a newer value
-
-### Same occurrence vs. another occurrence
-
-Use **UPDATE** only when the new memory adds detail to the same real-world
-occurrence or durable fact already recorded.
-
-If the same person does the same kind of activity/event again at another time
-(another trip, game, injury, purchase, health scare, etc.), keep the occurrence
-as a separate **ADD**. Preserve its own date and details. When an existing memory
-is clearly another occurrence in that same concrete series, link it with
-`related: [{{"memory_id":"...","relation":"same_series"}}]`.
-
-Do not merge separate dated occurrences into one long count/timeline memory.
-The retrieval layer builds timelines from the linked L2 memories.
-
-```json
-{{
- "op": "UPDATE",
- "memory_id": "...",
- "content": "...",
- "owner": "user",
- "tags": ["..."]
-}}
-```
-
----
-
-## SUPERSEDE
-
-Use ONLY when:
-
-* the new memory contradicts an existing memory
-* both cannot be true at the same time
-* the old memory would now give the wrong current-state answer
-* the new memory's `memory_at` is the same as or LATER than the existing memory's `memory_at`
-
-Examples:
-
-* city changed
-* employer changed
-* relationship status changed
-
-Do NOT use for:
-
-* added detail
-* compatible preferences
-* wording differences
-* semantic equivalence
-* a new memory whose `memory_at` is EARLIER than the existing memory's — it is an
- older state and must never replace a newer one (see "Time order")
-
-Rules:
-
-* content must contain ONLY the new state
-* do NOT copy unchanged information
-* the system keeps the old node and links it onto the evolution chain automatically; you don't need to handle history
-
-```json
-{{
- "op": "SUPERSEDE",
- "memory_id": "...",
- "content": "...",
- "supersede_reason": "...",
- "owner": "user",
- "tags": ["..."]
-}}
-```
-
-### Folding several existing memories into one chain
-
-If TWO OR MORE existing memories track the SAME dimension and the new memory is
-the latest change on that dimension — its `memory_at` is later than every folded
-memory's `memory_at` — you may fold them into a single evolution
-chain. Use `memory_ids` (an ordered list, OLDEST → NEWEST) instead of a single
-`memory_id`:
-
-```json
-{{
- "op": "SUPERSEDE",
- "memory_ids": ["<oldest_id>", "<newer_id>"],
- "content": "<only the newest state>",
- "supersede_reason": "...",
- "owner": "user",
- "tags": ["..."]
-}}
-```
-
-The listed memories are chained oldest → newest and the new memory becomes the
-chain head. `content` still describes ONLY the newest state — never copy the
-older memories' text into it; they remain queryable in the chain history.
-
----
-
-# Rules
-
-* Preserve all meaningful information.
-* Skip exact duplicates.
-* Prefer merging related fragments.
-* Separate dated occurrences stay separate ADDs; use `same_series` only for the
- same subject and same concrete activity/event type.
-* Keep each memory focused on one coherent topic.
-* Follow "Time order" below.
-* **NEVER merge or supersede across different subjects.** The subject is whoever
- the content is about: "The user ..." vs "John ..." vs "Mary ...". Memories about
- different people are independent facts even when the sentence is otherwise
- identical — "The user likes coffee" and "John likes coffee" are two separate
- memories, never an UPDATE or a SUPERSEDE of each other.
-* `owner` (`user`/`agent`): copy it from the memory being written. NEVER merge or supersede across different owners — a user's fact and the assistant's fact are distinct even on the same topic.
-* A SUPERSEDE either targets ONE memory (`memory_id`) or folds several memories on the same dimension into one chain (`memory_ids`, oldest→newest). An UPDATE targets exactly ONE memory.
-* Never touch the same existing memory from more than one op.
-* Output language matches input memory language.
-
----
-
-# Time order
-
-Every memory, new or existing, has `memory_at`: when it happened. Memories are
-NOT always written in the order they happened — history can be imported late,
-and a memory can be added while older history is still being processed. A new
-memory can therefore be OLDER than an existing one.
-
-* Decide which memory is newer ONLY by `memory_at`. "New memories" means "being
- written now", not "more recent".
-* An older memory must never replace a newer one: no SUPERSEDE of a newer
- memory, and no UPDATE that overwrites a newer value with an older one.
-* If a new memory is older than an existing memory it conflicts with, keep the
- existing memory as the current state. ADD the new one as a past state, worded
- in the past with its time (for example "In 2023 the user lived in Shanghai"),
- or output nothing if it adds no information.
-* `memory_at: null` means unknown time. Unknown is NOT newer: never SUPERSEDE a
- memory that has a known `memory_at` with one whose `memory_at` is null.
-* Do not invent chronology.
-
----
-
-# Optional: `related`
-
-On any op you MAY add a `related` array recording how the memory being written
-relates to an EXISTING memory. This does not change what gets stored — it only
-records a link.
-
-```json
-{{
- "op": "ADD",
- "content": "...",
- "owner": "user",
- "tags": ["..."],
- "related": [{{"memory_id": "<existing_id>", "relation": "causes"}}]
-}}
-```
-
-Only these four relations are allowed:
-
-* `causes` — the two memories are in a cause/effect relationship
- (e.g. "started running daily" → "knee started hurting")
-* `elaborates` — adds detail to, or is a later development of, the existing memory
-* `contrasts` — they are in tension but BOTH still true (if one makes the other
- false, that is a SUPERSEDE, not a `contrasts` link)
-* `same_series` — separate dated occurrences of the same concrete activity or
- event type for the same subject (for example, two different skiing trips)
-
-Rules:
-
-* Only link to memories that appear in "Existing memories" — never invent an id.
-* Only emit a link when the relationship is **explicit and specific**. Two memories
- merely being about the same broad topic is NOT a relation — leave `related` out.
-* `same_series` requires the same subject and a concrete repeated action/event;
- shared broad tags such as health, travel, sport, food, or work are insufficient.
-* Omit the field entirely when there is nothing to link. Zero links is the normal case.
-* Never use `related` as a substitute for UPDATE / SUPERSEDE.
-
----
-{few_shot_section}
-###################
-Input Data
-###################
-
-Current date: {current_date}
-
-## Existing memories
-
-{existing_memories}
-
-## New memories
-
-{new_memories}
-
----
-
-# Output
-
-Return ONLY a JSON array inside a fenced ```json code block.
-
-If no changes are needed:
-
-```json
-[]
-```
-
-Now produce the JSON array."""
-
-RECONCILE_STRUCTURE_METADATA_PROMPT_EN = """
-
-Additional structural output contract:
-
-For every ADD, UPDATE, or SUPERSEDE result, preserve or refine `topic_paths`,
-`event_facet`, and `topic_assignments`. `event_facet` contains only `subject`,
-`participants`, `action`, `objects`, `locations`, and `state`.
-`topic_assignments` contains subject-specific `{subject, role, path}` entries;
-each path segment is `{name, type}` and type is `topic|facet|series|episode`.
-Types follow `topic -> facet -> series -> episode`; levels may be skipped but
-types may not repeat or move backward.
-Use Series only for repeated occurrences of one concrete activity/state line and
-Episode only for one bounded real-world occurrence. Never infer these types from
-depth, a broad shared tag, or unrelated co-occurrence. When an Existing memory
-already has a semantically equivalent subject-specific path, reuse its exact node
-names and types instead of creating a synonym fork. To request exact reuse, emit
-`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
-"through":"topic|facet|series|episode"}]`. The referenced ID must appear in
-Existing memories. `through` means copy that existing path prefix through the
-named structural type; an explicitly authored deeper suffix remains new. Reuse
-is forbidden when the subject, concrete activity/state line, or Episode boundary
-differs. These fields describe the memory, never a future query form such as
-"when", "how many", or "who".
-
-Series is a reconcile-time relation: establish it only when the new memory and
-at least one independent Existing memory are distinct occurrences of the same
-concrete activity/state line. Multiple propositions from the current write do
-not prove repetition.
-"""
+# Prompt 文本统一放在 hy_memory/prompts/<language>.py(get_prompt 按语言码取);
+# 以下旧名字保留为英文版别名(向后兼容)。
+from ..prompts import ( # noqa: E402
+ get_prompt,
+ normalize_language,
+ resolve_language,
+ with_output_language,
+)
+from ..prompts.en import SEARCH_QUERY_PROMPT # noqa: E402,F401 (re-export)
+from ..prompts.en import RECONCILE_PROMPT # noqa: E402,F401 (re-export)
+from ..prompts.en import RECONCILE_STRUCTURE_METADATA_PROMPT as RECONCILE_STRUCTURE_METADATA_PROMPT_EN # noqa: E402,F401 (re-export)
+from ..prompts.en import RECONCILE_FEW_SHOT as RECONCILE_FEW_SHOT_EN # noqa: E402,F401 (re-export)
def append_reconcile_structure_prompt(
@@ -461,10 +180,8 @@ def append_reconcile_structure_prompt(
"""Append the structure contract only for an explicit experiment config."""
if not enabled:
return prompt
- if language == "zh":
- from .prompts_zh import RECONCILE_STRUCTURE_METADATA_PROMPT_ZH
- return prompt + RECONCILE_STRUCTURE_METADATA_PROMPT_ZH
- return prompt + RECONCILE_STRUCTURE_METADATA_PROMPT_EN
+ code = "zh-Hans" if language == "zh" else language
+ return prompt + get_prompt("RECONCILE_STRUCTURE_METADATA_PROMPT", code)
def _as_aware(value: Any) -> Optional[datetime]:
@@ -550,147 +267,42 @@ def build_reconcile_prompt(
current_date: str,
few_shot_enabled: bool = False,
structure_metadata_enabled: bool = False,
+ language: Optional[str] = None,
) -> str:
- """Build the language-matched reconcile prompt used by the write path."""
- from ..utils.lang_detect import is_chinese
-
- if is_chinese("\n".join(new_memories)):
- from .prompts_zh import RECONCILE_FEW_SHOT_ZH, RECONCILE_PROMPT_ZH
-
- few_shot = ("\n" + RECONCILE_FEW_SHOT_ZH + "\n") if few_shot_enabled else ""
- prompt = RECONCILE_PROMPT_ZH.format(
- current_date=current_date,
- new_memories=new_memories_block,
- existing_memories=existing_memories_block,
- few_shot_section=few_shot,
- )
- return append_reconcile_structure_prompt(
- prompt,
- enabled=structure_metadata_enabled,
- language="zh",
- )
+ """Build the reconcile prompt used by the write path.
- few_shot = ("\n" + RECONCILE_FEW_SHOT_EN + "\n") if few_shot_enabled else ""
- prompt = RECONCILE_PROMPT.format(
+ ``language`` set → that language's prompt plus the output-language rule;
+ None → zh/en auto-detection over the new memories (unchanged behaviour).
+ """
+ explicit = normalize_language(language)
+ code = resolve_language(explicit, "\n".join(new_memories))
+ few_shot = (
+ ("\n" + get_prompt("RECONCILE_FEW_SHOT", code) + "\n")
+ if few_shot_enabled else ""
+ )
+ prompt = get_prompt("RECONCILE_PROMPT", code).format(
current_date=current_date,
new_memories=new_memories_block,
existing_memories=existing_memories_block,
few_shot_section=few_shot,
)
- return append_reconcile_structure_prompt(
+ prompt = append_reconcile_structure_prompt(
prompt,
enabled=structure_metadata_enabled,
- language="en",
+ language=code,
)
+ return with_output_language(prompt, code, explicit=explicit is not None)
-# Reconcile few-shot examples (injected into {few_shot_section} only when
-# few_shot_enabled). Each shows the existing/new input and the expected ops,
-# with a one-line takeaway. IDs are shortened for readability.
-RECONCILE_FEW_SHOT_EN = """
-###################
-Examples
-###################
-
-## Example 1 — One new memory: part conflicts with an existing chain, part is unrelated
-
-Existing memories:
-[
- {"memory_id": "m1", "content": "The user works as a product manager at Stripe.", "owner": "user", "history_versions": [{"content": "The user works as a product manager at a fintech startup."}]}
-]
-New memories:
-[
- {"content": "The user has left Stripe and is now a product lead at Notion, and has recently taken up pottery on weekends.", "owner": "user"}
-]
-
-Output:
-```json
-[
- {"op": "SUPERSEDE", "memory_id": "m1", "content": "The user works as a product lead at Notion.", "supersede_reason": "employer changed from Stripe to Notion", "owner": "user", "tags": ["work"]},
- {"op": "ADD", "content": "The user has recently taken up pottery on weekends.", "owner": "user", "tags": ["hobby"]}
-]
-```
-A SINGLE new memory carries two things: the job change (same dimension as the existing employment chain m1, which already has history → SUPERSEDE, becomes the new chain head) and an unrelated detail (pottery → ADD). Split the one memory into the right op per part — the new head describes ONLY the employment state, never the pottery.
-
-## Example 2 — Fold two unlinked existing memories + the new change into one 3-node chain
-
-Existing memories:
-[
- {"memory_id": "a1", "content": "The user is learning to play the guitar.", "owner": "user", "memory_at": "2024-02-10 09:00"},
- {"memory_id": "a2", "content": "The user can now play a few full songs on the guitar.", "owner": "user", "memory_at": "2024-09-05 09:00"}
-]
-New memories:
-[
- {"content": "The user now performs guitar at local open-mic nights.", "owner": "user"}
-]
-
-Output:
-```json
-[
- {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "The user performs guitar at local open-mic nights.", "supersede_reason": "guitar skill progressed: learning → playing songs → performing live", "owner": "user", "tags": ["music", "hobby"]}
-]
-```
-a1 and a2 were never linked, but they track the same dimension (guitar progress) and the new memory is the latest step. Fold them with `memory_ids` ordered oldest→newest; they become a 3-node chain (a1 ← a2 ← new head). The head `content` describes ONLY the current state — it does not restate "learning" or "a few songs".
-
-## Example 3 — New head must NOT copy the old memory's content
-
-Existing memories:
-[
- {"memory_id": "c1", "content": "The user lives in a rented one-bedroom apartment in Shibuya, Tokyo, pays ¥180,000/month, loves the 5-minute walk to the station, but complains the place is noisy at night and has no parking.", "owner": "user"}
-]
-New memories:
-[
- {"content": "The user just bought and moved into a three-bedroom house in the suburbs of Yokohama with a garden and a two-car garage.", "owner": "user"}
-]
-
-Output:
-```json
-[
- {"op": "SUPERSEDE", "memory_id": "c1", "content": "The user bought and moved into a three-bedroom house in suburban Yokohama, with a garden and a two-car garage.", "supersede_reason": "residence changed from a rented Shibuya apartment to an owned Yokohama house", "owner": "user", "tags": ["housing"]}
-]
-```
-The new memory SUPERSEDEs c1 and becomes the chain head. The head `content` describes ONLY the new Yokohama house. Do NOT drag the old apartment's distinctive details (Shibuya, ¥180,000 rent, the station walk, the noise/parking complaints) into the new node — those clearly belong to the old residence, not the new one. They stay in chain history and remain retrievable; copying them would make the head self-contradictory (renting in Shibuya AND owning in Yokohama at once).
-
-## Example 4 — Different subjects are never merged, however similar the wording
-
-Existing memories:
-[
- {"memory_id": "d1", "content": "The user drinks black coffee every morning.", "owner": "user"}
-]
-New memories:
-[
- {"content": "John drinks black coffee every morning.", "owner": "user"},
- {"content": "The user now drinks black coffee twice a day, morning and after lunch.", "owner": "user"}
-]
-
-Output:
-```json
-[
- {"op": "ADD", "content": "John drinks black coffee every morning.", "owner": "user", "tags": ["food"]},
- {"op": "UPDATE", "memory_id": "d1", "content": "The user drinks black coffee twice a day, in the morning and after lunch.", "owner": "user", "tags": ["food"]}
-]
-```
-The two new memories are near-identical in wording but have DIFFERENT subjects. "John ..." is about another person, so it is a plain ADD — never an UPDATE or SUPERSEDE of d1, even though d1 says almost the same thing about the user. Only the memory whose subject is also "The user" may merge with d1.
-
-## Example 5 — Recurring event: bump count and keep a timeline (UPDATE, not ADD)
-
-Existing memories:
-[
- {"memory_id": "i1", "content": "John injured his ankle last season and needed time off plus physical therapy.", "owner": "user", "memory_at": "2023-05-21 19:48"}
-]
-New memories:
-[
- {"content": "John twisted his ankle again during a recent game.", "owner": "user", "memory_at": "2023-10-13 13:50"}
-]
-
-Output:
-```json
-[
- {"op": "UPDATE", "memory_id": "i1", "content": "John has injured his ankle two times: first last season (around the 2022–2023 season), needing time off and physical therapy; second during a game around 2023-10-13.", "owner": "user", "tags": ["health", "basketball", "injury"]}
-]
-```
-Same event type happening again → UPDATE the old memory. State the **count** and list occurrences with times when known. Do NOT ADD a second "John injured his ankle" fact, and do NOT SUPERSEDE (the first injury did not stop being true).
-"""
+def build_search_query_prompt(
+ new_memories: List[str], *, language: Optional[str] = None,
+) -> str:
+ """Search-query generation prompt (same language rule as reconcile)."""
+ explicit = normalize_language(language)
+ code = resolve_language(explicit, "\n".join(new_memories))
+ mem_lines = "\n".join(f"{i+1}. {m}" for i, m in enumerate(new_memories))
+ prompt = get_prompt("SEARCH_QUERY_PROMPT", code).format(new_memories=mem_lines)
+ return with_output_language(prompt, code, explicit=explicit is not None)
# ================================================================
@@ -745,7 +357,9 @@ class MemoryReconciler:
self._llm = LLMProvider(self.config)
return self._llm
- async def _generate_search_queries(self, new_memories: List[str]) -> tuple:
+ async def _generate_search_queries(
+ self, new_memories: List[str], language: Optional[str] = None,
+ ) -> tuple:
"""
Pre-process: 从全部新 memory 中提取 search queries,
用于补充向量搜索的召回能力。
@@ -753,17 +367,7 @@ class MemoryReconciler:
Returns:
(queries: List[str], llm_response: Optional[LLMResponse])
"""
- mem_lines = "\n".join(f"{i+1}. {m}" for i, m in enumerate(new_memories))
-
- # Select prompt based on input language
- from ..utils.lang_detect import is_chinese
-
- if is_chinese("\n".join(new_memories)):
- from .prompts_zh import SEARCH_QUERY_PROMPT_ZH
-
- prompt = SEARCH_QUERY_PROMPT_ZH.format(new_memories=mem_lines)
- else:
- prompt = SEARCH_QUERY_PROMPT.format(new_memories=mem_lines)
+ prompt = build_search_query_prompt(new_memories, language=language)
try:
llm = self._get_llm()
@@ -849,6 +453,7 @@ class MemoryReconciler:
graph_store=None, # Optional GraphStore:Entity MENTIONS boost
new_memory_embeddings: Optional[Dict[str, List[float]]] = None,
source: str = "default",
+ language: Optional[str] = None,
) -> ReconcileResult:
"""
对 new_memories 做 reconcile。
@@ -856,6 +461,7 @@ class MemoryReconciler:
Args:
new_memories: 新记忆内容列表(content only,用于 embed 搜索)
new_memories_with_meta: 可选,含 tags 的完整 meta
+ language: 显式 prompt 语言码;None 时按新记忆做 zh/en 自动检测
"""
if not new_memories:
return ReconcileResult(ops=[], success=True)
@@ -876,7 +482,7 @@ class MemoryReconciler:
if self._enable_search_query:
search_queries, sq_response = await self._generate_search_queries(
- new_memories
+ new_memories, language=language,
)
sq_elapsed = (_time.perf_counter() - t_sq) * 1000
@@ -887,18 +493,10 @@ class MemoryReconciler:
# 写 SEARCH_QUERY pipeline log
if cache and request_id:
- mem_lines = "\n".join(f"{i+1}. {m}" for i, m in enumerate(new_memories))
if self._enable_search_query:
- from ..utils.lang_detect import is_chinese as _is_zh
-
- if _is_zh("\n".join(new_memories)):
- from .prompts_zh import SEARCH_QUERY_PROMPT_ZH
-
- sq_prompt = SEARCH_QUERY_PROMPT_ZH.format(
- new_memories=mem_lines
- )
- else:
- sq_prompt = SEARCH_QUERY_PROMPT.format(new_memories=mem_lines)
+ sq_prompt = build_search_query_prompt(
+ new_memories, language=language,
+ )
else:
sq_prompt = "[search query disabled — hybrid retrieval per new memory]"
try:
@@ -1447,6 +1045,7 @@ class MemoryReconciler:
getattr(self.config.llm, "few_shot_enabled", False)
),
structure_metadata_enabled=_structure_metadata_on,
+ language=language,
)
# ── Step 5: LLM 调用 + 重试 ──
diff --git a/hy_memory/agent/tools/basic_profile.py b/hy_memory/agent/tools/basic_profile.py
index b68a423..a51dbef 100644
--- a/hy_memory/agent/tools/basic_profile.py
+++ b/hy_memory/agent/tools/basic_profile.py
@@ -225,6 +225,16 @@ _PLACEHOLDER_VALUES = frozenset({
"not provided", "not specified", "not mentioned",
"未提供", "未知", "不详", "未说明", "未提及", "无",
"-", "?",
+ # 其他提示词语言里的「用户」/「未知」(显式 language 时模型可能照抄)
+ "使用者", "該使用者", "用戶", "該用戶", "不詳", "無",
+ "ユーザー", "ユーザ", "不明", "なし",
+ "사용자", "유저", "알 수 없음", "없음",
+ "el usuario", "usuario", "la usuaria", "desconocido", "ninguno",
+ "der nutzer", "nutzer", "der benutzer", "benutzer", "unbekannt", "keine",
+ "o usuário", "usuário", "o utilizador", "utilizador", "desconhecido", "nenhum",
+ "l'utilisateur", "utilisateur", "inconnu", "aucun",
+ "пользователь", "неизвестно", "нет",
+ "pengguna", "tidak diketahui", "tidak ada",
})
# 内置字段的中文标签:弱模型也会把字段说明的中文词当值。
diff --git a/hy_memory/client.py b/hy_memory/client.py
index 99285cd..75a0437 100644
--- a/hy_memory/client.py
+++ b/hy_memory/client.py
@@ -909,6 +909,19 @@ class HyMemoryClient:
"""
return "coding" if str(scene or "").strip().lower() == "coding" else "working"
+ def _resolve_language(self, language: Optional[str]) -> Optional[str]:
+ """per-call language > MemoryConfig.language; None = zh/en 自动检测。
+
+ 返回 canonical 码;未知码抛 ValueError(列出支持的码与别名)。
+ """
+ from .prompts import normalize_language
+
+ code = normalize_language(language)
+ if code is not None:
+ return code
+ config = getattr(self, "_config", None)
+ return normalize_language(getattr(config, "language", None))
+
@staticmethod
def _parse_input(data: AddInput):
"""
@@ -1723,6 +1736,7 @@ class HyMemoryClient:
request_id: Optional[str] = None,
meta: Optional[Dict[str, Any]] = None,
embed_override: Optional[Dict[str, Any]] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""
写入记忆。
@@ -1773,6 +1787,13 @@ class HyMemoryClient:
meta 独立持久化,只做业务透传。
语义为「该次 write 时刻的上下文」,故存为 list——同一节点被
多次写入合并时会追加而非覆盖,详见 get() 返回的 meta 字段。
+ language: 本次请求的 LLM prompt 语言码(en / zh-Hans / zh-Hant / ja / es /
+ de / pt / fr / ko / ru / id;别名 zh、zh-CN → zh-Hans,zh-TW、
+ zh-HK → zh-Hant,pt-BR → pt)。优先于 MemoryConfig.language
+ (env MEMORY_LANGUAGE);两者都未设时沿用 zh/en 自动检测。
+ 显式指定时 extract / reconcile / coding 链路 / 基础画像等本次
+ 请求的全部 LLM 调用都用该语言的 prompt,记忆正文也用该语言书写。
+ 未知码抛 ValueError(列出支持的码)。
Returns:
chat 链路:{"success": True, "memory_id": "...", "request_id": "...", "elapsed_ms": ...}
@@ -1788,6 +1809,7 @@ class HyMemoryClient:
workspace_id=workspace_id, branch=branch,
request_id=request_id, meta=meta,
embed_override=embed_override,
+ language=language,
),
include_runtime_diag=True,
)
@@ -1798,15 +1820,20 @@ class HyMemoryClient:
user_id: str,
agent_id: str = "default_agent",
session_id: str,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""Finalize one caller session into a first-class episode narrative.
The feature is opt-in through MEMORY_SESSION_EPISODE_ENABLED. Calls are
idempotent: the same user/agent/session tuple upserts one deterministic node.
+
+ ``language`` (or MemoryConfig.language) makes the narrative be written in
+ that language; see add(). The episode prompts themselves are English-only.
"""
return self._loop_thread.run(
self.async_finalize_session(
user_id=user_id, agent_id=agent_id, session_id=session_id,
+ language=language,
),
include_runtime_diag=True,
)
@@ -2263,6 +2290,7 @@ class HyMemoryClient:
user_id: str,
agent_id: str = "default_agent",
max_batches: Optional[int] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""
手动触发 System 2 认知加工(ultra 模式专用,同步阻塞直到完成)。
@@ -2285,6 +2313,8 @@ class HyMemoryClient:
Args:
user_id: 用户 ID
agent_id: Agent ID
+ language: System 2 / sweeper prompt 语言码,语义同 add()(per-call >
+ MemoryConfig.language > 按 materials 做 zh/en 检测)。
Returns:
{"success": True, "request_id": "...", "tasks_processed": 1, "results": {...},
@@ -2298,6 +2328,7 @@ class HyMemoryClient:
return self._loop_thread.run(
self.async_evolve(
user_id=user_id, agent_id=agent_id, max_batches=max_batches,
+ language=language,
)
)
@@ -2307,8 +2338,10 @@ class HyMemoryClient:
user_id: str,
agent_id: str = "default_agent",
max_batches: Optional[int] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""手动触发 System 2 认知加工(异步)"""
+ language = self._resolve_language(language)
t0 = __import__("time").perf_counter()
# 获取 System2Writer
@@ -2331,6 +2364,7 @@ class HyMemoryClient:
result = await writer.evolve(
user_id=user_id, agent_id=agent_id, max_batches=max_batches,
+ language=language,
)
result["elapsed_ms"] = round((__import__("time").perf_counter() - t0) * 1000, 2)
return result
@@ -2339,6 +2373,7 @@ class HyMemoryClient:
self,
user_ids: List[str],
agent_ids: Optional[List[str]] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""
手动触发 cross-domain sweeper(同步)。
@@ -2352,6 +2387,8 @@ class HyMemoryClient:
Args:
user_ids: SDK user_id 列表
agent_ids: Agent ID 列表(默认 ["default_agent"])
+ language: 输出语言码,语义同 add()。sweeper prompt 只有英文版,显式
+ 指定时追加该语言的输出规则。
Returns:
{"success": True, "results": [{...}, ...]}
@@ -2361,7 +2398,9 @@ class HyMemoryClient:
f"sweep() requires mode='ultra', but this client is mode='{self._mode}'."
)
return self._loop_thread.run(
- self.async_sweep(user_ids=user_ids, agent_ids=agent_ids)
+ self.async_sweep(
+ user_ids=user_ids, agent_ids=agent_ids, language=language,
+ )
)
@_ensure_internal_loop
@@ -2369,11 +2408,13 @@ class HyMemoryClient:
self,
user_ids: List[str],
agent_ids: Optional[List[str]] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""手动触发 cross-domain sweeper(异步)
对每个 user_id × agent_id 组合执行一次 sweeper。
"""
+ language = self._resolve_language(language)
t0 = __import__("time").perf_counter()
try:
@@ -2385,7 +2426,9 @@ class HyMemoryClient:
results = []
for uid in user_ids:
for aid in effective_agents:
- r = await writer.run_sweeper(user_id=uid, agent_id=aid)
+ r = await writer.run_sweeper(
+ user_id=uid, agent_id=aid, language=language,
+ )
results.append({"user_id": uid, "agent_id": aid, **r})
elapsed_ms = round((__import__("time").perf_counter() - t0) * 1000, 2)
@@ -2740,13 +2783,17 @@ class HyMemoryClient:
request_id: Optional[str] = None,
meta: Optional[Dict[str, Any]] = None,
embed_override: Optional[Dict[str, Any]] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""写入记忆(异步)
embed_override: 本次写入的 embedding 端点覆盖(不改 model/dims,只换接入点)。
dict,可含 base_url / api_key / extra_headers / timeout;None = 用 client 配置。
可用于按请求切换任意 OpenAI-compatible embedding endpoint。
+ language: 本次请求的 prompt 语言码,详见 add()。
"""
+ # 先校验语言码:非法值直接 ValueError,不占用 request_id 的幂等槽位
+ language = self._resolve_language(language)
request_id = request_id or str(uuid.uuid4())
replay = await self._claim_write_outcome(
request_id=request_id,
@@ -2770,7 +2817,7 @@ class HyMemoryClient:
source=source,
metadata=metadata, memory_at=memory_at,
scene=scene, workspace_id=workspace_id, branch=branch,
- request_id=request_id, meta=meta,
+ request_id=request_id, meta=meta, language=language,
)
else:
result = await self._async_add_impl(
@@ -2778,7 +2825,7 @@ class HyMemoryClient:
source=source,
metadata=metadata, memory_at=memory_at,
scene=scene, workspace_id=workspace_id, branch=branch,
- request_id=request_id, meta=meta,
+ request_id=request_id, meta=meta, language=language,
)
except BaseException:
await self._mark_write_outcome_unknown(request_id)
@@ -2797,8 +2844,10 @@ class HyMemoryClient:
user_id: str,
agent_id: str = "default_agent",
session_id: str,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""Async counterpart of :meth:`finalize_session`."""
+ language = self._resolve_language(language)
series = bool(getattr(self._config.recall, "series_episode_enabled", False))
dynamic = bool(
getattr(self._config.recall, "dynamic_episode_enabled", False) or series
@@ -2828,6 +2877,7 @@ class HyMemoryClient:
user_id=user_id,
agent_id=agent_id,
session_id=session_id,
+ language=language,
)
if finalize is finalize_dynamic_episode_capsules:
finalize_kwargs["summary_concurrency"] = getattr(
@@ -2867,6 +2917,7 @@ class HyMemoryClient:
branch: Optional[str] = None,
request_id: Optional[str] = None,
meta: Optional[Dict[str, Any]] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""写入记忆(异步)
@@ -2875,6 +2926,7 @@ class HyMemoryClient:
None = 自动判定。详见 add() docstring。
workspace_id / branch: Coding memory 路径专用,详见 add() docstring。
meta: 调用方自定义业务 meta,透传存储,详见 add() docstring。
+ language: 已解析的 canonical 语言码(None = zh/en 自动检测)。
"""
from .utils.source_filter import normalize_source
source = normalize_source(source)
@@ -2973,6 +3025,7 @@ class HyMemoryClient:
request_id=request_id,
source=source,
memory_at=memory_at,
+ language=language,
)
# Public receipt always identifies the productivity namespace.
resp["variant"] = scene_variant
@@ -3038,6 +3091,7 @@ class HyMemoryClient:
# 落库 memory_ops / WRITE_SUMMARY / pipeline_logs 的单一真相源。
request_id=request_id,
client_meta=meta,
+ language=language,
)
# mode → writer:
@@ -3126,6 +3180,7 @@ class HyMemoryClient:
metadata: Optional[Dict[str, Any]] = None,
memory_at: Optional[datetime] = None,
request_id: Optional[str] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""写入「调用方已抽取好的」记忆:跳过 extract,直接进 reconcile。
@@ -3140,6 +3195,7 @@ class HyMemoryClient:
Args:
contents: 单条事实字符串,或多条事实字符串列表。
+ language: reconcile prompt 的语言码,语义同 add()。
其余参数语义同 add()。
Returns:
@@ -3151,6 +3207,7 @@ class HyMemoryClient:
contents, user_id=user_id, agent_id=agent_id,
session_id=session_id, source=source, metadata=metadata,
memory_at=memory_at, request_id=request_id,
+ language=language,
),
include_runtime_diag=True,
)
@@ -3167,8 +3224,10 @@ class HyMemoryClient:
metadata: Optional[Dict[str, Any]] = None,
memory_at: Optional[datetime] = None,
request_id: Optional[str] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""Idempotent async wrapper for extracted-memory writes."""
+ language = self._resolve_language(language)
request_id = request_id or str(uuid.uuid4())
replay = await self._claim_write_outcome(
request_id=request_id,
@@ -3189,6 +3248,7 @@ class HyMemoryClient:
metadata=metadata,
memory_at=memory_at,
request_id=request_id,
+ language=language,
)
except BaseException:
await self._mark_write_outcome_unknown(request_id)
@@ -3211,6 +3271,7 @@ class HyMemoryClient:
metadata: Optional[Dict[str, Any]] = None,
memory_at: Optional[datetime] = None,
request_id: Optional[str] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""写入已抽取好的记忆(异步);跳过 extract,直接 reconcile。详见 add_extracted()。"""
request_id = request_id or str(uuid.uuid4())
@@ -3251,6 +3312,7 @@ class HyMemoryClient:
extra=extra,
memory_at=memory_at,
request_id=request_id,
+ language=language,
)
# lite/pro → MemoryWriter;ultra → System2Writer(内部复用 MemoryWriter)
diff --git a/hy_memory/coding/extractor.py b/hy_memory/coding/extractor.py
index 82afde6..d63090a 100644
--- a/hy_memory/coding/extractor.py
+++ b/hy_memory/coding/extractor.py
@@ -21,7 +21,12 @@ from typing import List, Optional, Dict, Any, Tuple
from ..agent.llm_provider import LLMProvider
from ..pipelines.base import ChatMessage
-from ..utils.lang_detect import is_chinese
+from ..prompts import (
+ get_prompt,
+ normalize_language,
+ resolve_language,
+ with_output_language,
+)
from .preproc import (
extract_files,
keep_last_k_user_turns,
@@ -65,332 +70,7 @@ _VERBATIM_STATEMENT_CHARS = 600
# Prompt
# ================================================================
-EXTRACT_PROMPT = """\
-You extract durable WORKING memories from a task-execution session segment.
-A "working" session is any hands-on task where the user operates a computer /
-system through tools — this covers BOTH software/code work (writing, debugging,
-refactoring, building, deploying, API/library usage) AND system & operations
-work (running shell/PowerShell commands, disk/storage analysis or cleanup, file
-& folder operations, installing/configuring software, environment/device setup,
-hardware/disk health inspection, backup, scheduling/automation, data processing).
-
-You produce TWO layers from the SAME segment:
-
- EXPERIENCES (procedural, "how to do it") — reusable method, extracted only
- when it clears the VALUE BAR below. A (task, search_keys, solution,
- boundary_envs) bundle.
-
- FACT (episodic, "what happened this time") — EXACTLY ONE record of THIS
- session: what the user wanted, how it was gone about, how it came out. No
- value bar, but there is never more than one.
-
-The two layers answer different questions and are stored separately. A method
-that generalizes goes in EXPERIENCES; the story of this particular session —
-only true for this system / this project / right now — goes in the FACT.
-
-═══════════════════════════════════════════════════════════════════
-VALUE BAR (EXPERIENCES ONLY) — DO NOT cross this lightly.
-═══════════════════════════════════════════════════════════════════
-A memory MUST satisfy ALL of:
- (a) Solves a problem likely to recur for the same user
- (b) Solution is non-trivial: combines multiple pieces of info / steps, OR
- carries a decision rationale, OR captures a hard-won workaround, OR is a
- reusable procedure/recipe for an operational task (e.g. how to analyze &
- clean up disk usage, how to batch-organize files, how to inspect hardware
- health, how to set up a scheduled job)
- (c) A future agent / user would prefer looking it up over re-discovering it
-
-IMPORTANT — analysis / diagnostic / investigation tasks COUNT:
-A task does NOT have to make a change or "fix" something to be worth remembering.
-Read-only / analytical / troubleshooting work is valuable when its PROCEDURE or
-CONCLUSION is reusable. Explicitly extract:
- - Analysis / diagnostic recipes: the reusable procedure + what it revealed
- (e.g. "how to analyze which folders eat C-drive space" — the scan commands,
- the gotchas hit, and the finding). "It only produced a report, no change"
- is NOT a reason to skip — the reusable METHOD is the memory.
- - Investigation outcomes, INCLUDING negative / not-found results
- (e.g. "searched folder X across C: and D: with rg / fs_search / SQL index —
- not found anywhere"). A recorded dead-end saves the next agent from repeating
- the same fruitless search, so it clears the bar.
-Do NOT reject a memory merely because "the assistant could regenerate the
-commands" or "nothing was actually modified". If the procedure or the conclusion
-would save future effort, keep it.
-
-DO NOT extract:
- - Truly trivial single-step ops with no reusable procedure ("rename one file",
- "git status", "run ls once")
- - One-off issues already resolved with no transferable lesson
- - Information that is already in the repo/system (don't duplicate package.json)
- - Per-PR / per-session throwaway tasks unless they encode a reusable pattern
- - The act of ASKING THE USER for missing information. Requesting a parameter,
- listing what is unknown, or eliciting required fields is conversational
- behaviour, not a method: every agent already knows how to ask a question, so
- there is nothing to look up later. Never emit an experience whose task or
- search_keys are shaped like "how to ask for X", "gather the missing Y",
- "eliciting required fields", "what to clarify before starting". Note this
- stays out of EXPERIENCES only — that the session ended waiting on the user
- is real state and belongs in the FACT.
-
-If the segment made no substantive progress because it stalled waiting on the
-user — the assistant only asked for parameters, or was blocked before doing any
-real work — emit "experiences": [] and write the FACT alone. Nothing was
-learned yet, so there is no method to store. This matters more than it looks:
-an experience distilled from a stall reads as a legitimate skill on retrieval,
-and a later segment of the same task will match it and ask the user again
-instead of proceeding, so the stall reproduces itself for the rest of the
-session. Judge substance by what the tools actually did, not by whether the
-turn produced fluent text.
-
-Heuristic: if the user (or a future agent doing the same kind of task) would
-want this written down instead of figuring it out again, keep it. A multi-step
-operational procedure (even a system/ops or read-only analysis/search one, not
-just code) usually qualifies. Only drop it if it is a single command any user
-would find via `--help` in 30 seconds AND carries no decision/gotcha worth
-remembering.
-
-═══════════════════════════════════════════════════════════════════
-EXPERIENCE FIELDS
-═══════════════════════════════════════════════════════════════════
-
-task — Query-shaped name; phrase as how a user would later ASK.
- "publish a release to the xx platform" not
- "publish_release_internal"
- Self-contained (no "this", "the file", "we").
-
-search_keys — 0 to 5 alternative phrasings capturing important aspects of
- solution that `task` alone wouldn't match. Phrase as questions
- or topics future users would ASK ABOUT. Distinct from task.
- Omit if task already covers everything.
-
-solution — Complete, self-contained content the user actually needs:
- commands, credential locations (NOT credential VALUES),
- file paths, ordered steps, gotchas, decision rationale.
- Aggregate multi-turn end-to-end work into ONE solution if it
- forms a coherent task; split into multiple memories only when
- the user did unrelated tasks.
-
-boundary_envs — Concrete pinning that solution depends on, multi-line "key: value":
- runtime / SDK / library + version
- API endpoint or method signature
- external service / middleware version
- env var NAME (not value)
- config file path
- host / cluster / region identifier
- If solution is environment-agnostic, leave as "" (empty).
- Purpose: when the underlying SDK/middleware upgrades, future
- consumers can inspect this to decide if solution still applies.
-
-confidence — 0.0 to 1.0
- 1.0 user explicitly stated this as a rule / instruction
- 0.7 inferred with good evidence from tool actions
- 0.5 weakly inferred; one observation; uncertain
-
-═══════════════════════════════════════════════════════════════════
-FACT FIELD — EXACTLY ONE per segment, no value bar
-═══════════════════════════════════════════════════════════════════
-
-You write ONE fact for the whole segment — a recoverable state record for this
-session, not a polished retrospective and never a list of separate findings. A
-future agent must be able to resume from it without mistaking a suggestion,
-inference, or partial search for something verified.
-
-subject — WHO or WHAT this session is about: the single entity the work was
- performed on or for. One short noun phrase, no sentence, no verb.
- Pick the most specific entity that the session is *about*, not the
- tool it used:
- a person's name when the session serves one named person
- ("Dylan", "Matthew")
- the file / module / symbol when the work targets code
- ("auth/middleware.ts", "parse_plan_text")
- the service / host / device / drive for ops work
- ("D:\\WXWork", "redis-cache-prod", "ci.yml")
- This is a HARD KEY, not prose: two sessions about different people
- or different files MUST get different subjects, and two sessions
- about the same one MUST get the same string, spelled identically.
- Prefer the exact identifier as it appears in the trace over a
- description of it. If the segment genuinely has no single subject,
- output "".
-
- Why it matters: subject is the gate that decides whether a later
- session is allowed to overwrite this one as "the same task,
- continued". Get it wrong and one person's state silently replaces
- another's.
-
-statement — A compact record of THIS session. Two parts, and the second is the
- one that gets lost.
- Preserve task-scoped givens and concrete constraints instead of
- replacing them with a generic evaluation of the outcome. State
- each rule once: repeated instruction text competes with the data
- the memory must retain.
-
- PART 1 — what happened, about 300 latin characters (~150 CJK).
- Start with the specific goal and object ("reclaim disk space taken
- by D:\\WXWork", "locate the new_file_search folder"), not a generic
- "fix a bug" / "find a file". Then roughly what was inspected, tried,
- or changed. Then how it ended, with the semantics of exactly one of:
- completed, partially completed, failed, blocked, or
- still awaiting verification. Include negative results and dead ends
- without overstating them.
-
- PART 2 — the TASK-SCOPED GIVENS: everything the WHOLE task runs on,
- even when this segment did not establish it and even when it feels
- too elementary to state. Bindings (what each name/symbol/label
- stands for), fixed values the task supplies rather than derives,
- conventions adopted (indexing base, units, timezone, defaults), and
- this segment's own result WITH its value ("x = 7", not "the value
- was computed").
-
- Write PART 2 as data, one item per line, values as given:
- 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
- A line should be almost entirely values. Keep the trace's notation —
- symbols, units, numbers, spellings — and drop its sentences: strip
- the phrases that announce a given rather than being one ("I would
- prefer", "it should be somewhere between … and …"). They repeat once
- per item, so a 15-item list pays for them 15 times.
- Carry them on EVERY fact; never write "as above" or "same as the
- previous session" — retrieval returns a handful of facts by
- similarity and the referent may not be among them.
-
- Aim under 1200 characters total. If PART 2 does not fit, fix the
- notation, never the coverage: statement is the retrieval vector AND
- the only field a later segment can read (details is neither embedded
- nor injected), so anything cut from it is gone. Compress the wording
- around a given; never the given.
-
- The test: if the next segment cannot see the original material, can
- it continue from this record alone? Only a yes counts. A missing
- binding does not fail loudly — the name still looks meaningful, so
- it gets read with its general-usage meaning and the answer that
- follows is fluent and about a different question.
-
- LANGUAGE — same language as the session trace: statement is the
- retrieval vector and queries arrive in the user's working language,
- so another language pays a cross-lingual penalty on every lookup.
-
- EVIDENCE FIDELITY — record only actions actually executed and
- evidence explicitly present in the trace. Preserve material
- commands, flags, arguments, errors, and numbers verbatim.
- NEVER complete a command with customary flags, and never turn
- advice or plans into actions:
- "ran Get-ChildItem -Force" → "ran Get-ChildItem"
- (the trace did not contain `-Force`; do not invent it)
- Scope every negative finding to what was actually searched, and
- enumerate EVERY explicit coverage limit that could invalidate it,
- especially permission failures and depth limits: keep the roots,
- filters, and depth that were in effect ("not found under C:\\ and
- D:\\ at depth 3; some directories were not covered due to Access
- denied"), never widen it to "does not exist". Do not omit one limit
- to make the record prettier.
- Never promote a partial search to global absence.
- A blocked attempt keeps its blocker.
- Preserve the distinction among attempted, observed, verified,
- inferred, and unresolved — express it naturally ("tried … but was
- blocked by Access denied", "suspected …, not yet verified"), not as
- labels. Without tool output or explicit confirmation, NEVER claim a
- fix succeeded, a cause was established, or a path does not exist.
-
- Do NOT record greetings or pure chatter — that is the only case
- getting "fact": null. A segment that merely stated requirements, or
- stalled before doing work, still established something.
-
-details — The session's concrete OUTPUT, copied over verbatim. `statement` is
- a summary and a summary necessarily drops the individual values; a
- later lookup almost always wants one specific value, not the gist.
- So whatever addressable result this session produced, reproduce it
- here in its original form and structure:
- a plan / schedule / itinerary → keep every line, every day, every
- slot, and every price exactly as written
- a config or code block → keep the block
- a command's material output → keep the lines that carry the
- findings (sizes, counts, versions, error text)
- a structured result (table, list of records) → keep the rows
- Preserve the original layout — line breaks, `Day 1:` / key: value
- prefixes, units, currency symbols, ids. Do not re-summarize, do not
- reorder, do not round numbers, do not translate.
-
- Copy ONLY what is present in the trace. Never fill a gap: if a slot
- was left unfilled, leave it unfilled or say so — an invented value
- is worse than a missing one, because it will be retrieved and used.
- Cap around 4000 characters; if the output is longer, keep the parts
- carrying concrete values and drop decorative prose, noting what was
- dropped.
-
- "" when the session produced no such artifact (pure investigation
- with no findings yet, or a stall waiting on the user).
-
- This field is NOT part of the retrieval vector — `statement` and
- `subject` do the finding, `details` supplies the value once found.
- So do not write retrieval bait here, and do not duplicate the
- summary; write the raw thing.
-
-files — 0..N absolute or repo-relative FILE OR DIRECTORY paths actually
- operated on or investigated during this session. Keep investigated
- roots such as `C:\\` and `D:\\`. Only include paths that were
- actually accessed/searched, not paths merely suggested or planned;
- [] if none apply.
-═══════════════════════════════════════════════════════════════════
-HOST CONTEXT (given by SDK)
-═══════════════════════════════════════════════════════════════════
-- workspace_id present: {workspace_present}
-- branch present: {branch_present}
-
-When no workspace_id is present, the solution cannot rely on unstated
-project-local context — spell out any repo / path / service it needs inside
-`solution` or `boundary_envs` so the memory stays usable on its own.
-
-═══════════════════════════════════════════════════════════════════
-CONVERSATION
-═══════════════════════════════════════════════════════════════════
-{conversation_block}
-
-═══════════════════════════════════════════════════════════════════
-OUTPUT (strict JSON only, no markdown)
-═══════════════════════════════════════════════════════════════════
-{{
- "experiences": [
- {{
- "task": "...",
- "search_keys": ["...", "..."],
- "solution": "...",
- "boundary_envs": "...",
- "confidence": 0.9
- }}
- ],
- "fact": {{
- "subject": "...",
- "statement": "...",
- "files": ["..."],
- "details": "..."
- }}
-}}
-
-DEFAULT TO EXTRACTING. When the segment did real work, you MUST output at least
-one experience — even if the task looks simple or was a one-shot success, still
-capture the reusable essence of what was done (the method / command / how-to).
-When the session is thin, the single most valuable experience is enough.
-
-The ONE exception is the stall case above: if the segment did no real work
-because it was blocked asking the user for missing information, output
-"experiences": [] and write only the fact. Do not manufacture an experience to
-satisfy this instruction — a fabricated one ("how to ask for the departure
-city") is worse than none, because it is later retrieved and followed. Empty is
-allowed ONLY for that reason, never as a shortcut when work was actually done.
-
-"fact" is a SINGLE object, never a list — one record per session.
-
-ALWAYS write the fact. The bar for the fact is not "was this valuable" but "did
-anything at all happen", and a segment reaching you has already cleared that.
-This includes segments that look like setup rather than work: a single
-user message stating requirements, parameters, or a starting state, with no
-tools run, is exactly the material a later session cannot reconstruct on its own
-— 把需求、参数、起始状态连同情形一起写进 `statement`(紧凑记法,不要照抄对话原句),
-不要推给 `details`(`details` 不进检索向量,读取侧也不再注入它)。Use
-"fact": null ONLY for greetings and pure chatter with no content whatsoever.
-When in doubt, write the fact: an unneeded record costs one row, while a dropped
-one costs every later session that needed it and has no way to know it existed.
-"""
+from ..prompts.en import CODING_EXTRACT_PROMPT as EXTRACT_PROMPT # noqa: E402,F401 (re-export)
# ================================================================
@@ -421,350 +101,7 @@ one costs every later session that needed it and has no way to know it existed.
#
# 修改 prompt 时应使用代表性 coding traces 做回归,确认坐标、决策与验证状态仍保留。
-EXTRACT_PROMPT_CODING = """\
-╔═══════════════════════════════════════════════════════════════════════════╗
-║ HARD CONSTRAINT — read this before anything else, it overrides any ║
-║ phrasing later in this prompt that sounds like it wants a narrative. ║
-║ ║
-║ You are NOT writing a report of what a person did. You are writing what a ║
-║ FUTURE AGENT needs in order to act. That agent already has its own task; ║
-║ it does not care what this user wanted. It needs to know: what was decided ║
-║ here, at which code coordinates, what was tried and rejected, and whether ║
-║ it was verified. ║
-║ ║
-║ Concretely, in every `statement` and every `solution`: ║
-║ · The grammatical subject is the CODE or THE DECISION — never "the user" ║
-║ and never "the agent". Do not write "The user attempted to…", ║
-║ "The user wanted…", "The agent then checked…". ║
-║ · Never close with a bookkeeping phrase like "the session was completed", ║
-║ "the error was noted", "no solution was found yet". Close with the ║
-║ decision and its verification status. If nothing was decided, close ║
-║ with what was RULED OUT and the next unexplored lead — that is the ║
-║ reusable part. ║
-║ · Keep the concrete symptom (error string, failing command, wrong ║
-║ output) — that is what a future search will match on. ║
-║ ║
-║ bad: "The user attempted to write a QTable to RST with header_rows and ║
-║ hit a TypeError. The session was completed with the error noted." ║
-║ good: "ascii.rst's RST writer rejects header_rows: `tbl.write(..., \ ║
-║ format='ascii.rst', header_rows=['name','unit'])` raises TypeError ║
-║ because RST.__init__ does not forward it, unlike ascii.fixed_width ║
-║ which accepts it. No fix written — the writer needs the same ║
-║ header_rows plumbing as fixed_width." ║
-╚═══════════════════════════════════════════════════════════════════════════╝
-
-You extract durable WORKING memories from a task-execution session segment.
-A "working" session is any hands-on task where the user operates a computer /
-system through tools — this covers BOTH software/code work (writing, debugging,
-refactoring, building, deploying, API/library usage) AND system & operations
-work (running shell/PowerShell commands, disk/storage analysis or cleanup, file
-& folder operations, installing/configuring software, environment/device setup,
-hardware/disk health inspection, backup, scheduling/automation, data processing).
-
-You produce TWO layers from the SAME segment:
-
- EXPERIENCES (procedural, "how to do it") — reusable method, extracted only
- when it clears the VALUE BAR below. A (task, search_keys, solution,
- boundary_envs) bundle.
-
- FACT (episodic, "what was established this time") — EXACTLY ONE record of THIS
- session. It is NOT a narrative of what the user did. It records, in this order:
- the task and its concrete symptom (this is what makes it findable later), the
- code coordinates, WHAT WAS SETTLED ON and what was rejected, and how far it was
- verified. No value bar, but there is never more than one.
-
-The two layers answer different questions and are stored separately. A method
-that generalizes goes in EXPERIENCES; the story of this particular session —
-only true for this system / this project / right now — goes in the FACT.
-
-═══════════════════════════════════════════════════════════════════
-VALUE BAR (EXPERIENCES ONLY) — DO NOT cross this lightly.
-═══════════════════════════════════════════════════════════════════
-A memory MUST satisfy ALL of:
- (a) Solves a problem likely to recur for the same user
- (b) Solution is non-trivial: combines multiple pieces of info / steps, OR
- carries a decision rationale, OR captures a hard-won workaround, OR is a
- reusable procedure/recipe for an operational task (e.g. how to analyze &
- clean up disk usage, how to batch-organize files, how to inspect hardware
- health, how to set up a scheduled job)
- (c) A future agent / user would prefer looking it up over re-discovering it
-
-IMPORTANT — analysis / diagnostic / investigation tasks COUNT:
-A task does NOT have to make a change or "fix" something to be worth remembering.
-Read-only / analytical / troubleshooting work is valuable when its PROCEDURE or
-CONCLUSION is reusable. Explicitly extract:
- - Analysis / diagnostic recipes: the reusable procedure + what it revealed
- (e.g. "how to analyze which folders eat C-drive space" — the scan commands,
- the gotchas hit, and the finding). "It only produced a report, no change"
- is NOT a reason to skip — the reusable METHOD is the memory.
- - Investigation outcomes, INCLUDING negative / not-found results
- (e.g. "searched folder X across C: and D: with rg / fs_search / SQL index —
- not found anywhere"). A recorded dead-end saves the next agent from repeating
- the same fruitless search, so it clears the bar.
-Do NOT reject a memory merely because "the assistant could regenerate the
-commands" or "nothing was actually modified". If the procedure or the conclusion
-would save future effort, keep it.
-
-DO NOT extract:
- - Truly trivial single-step ops with no reusable procedure ("rename one file",
- "git status", "run ls once")
- - One-off issues already resolved with no transferable lesson
- - Information that is already in the repo/system (don't duplicate package.json)
- - Per-PR / per-session throwaway tasks unless they encode a reusable pattern
-
-Heuristic: if the user (or a future agent doing the same kind of task) would
-want this written down instead of figuring it out again, keep it. A multi-step
-operational procedure (even a system/ops or read-only analysis/search one, not
-just code) usually qualifies. Only drop it if it is a single command any user
-would find via `--help` in 30 seconds AND carries no decision/gotcha worth
-remembering.
-
-═══════════════════════════════════════════════════════════════════
-CODE WORK — what a future agent cannot re-derive, so it MUST be captured
-═══════════════════════════════════════════════════════════════════
-When the segment is software work on a repository, the reusable method is only
-half of it. The other half is WHERE the work lives and WHICH VERSION won. Those
-cannot be recovered by reading the code later — the code shows the current state,
-not which branch it sits on, nor what was already rejected.
-
-This section does NOT ask for a longer record. It asks you to SPEND THE SAME
-BUDGET on higher-value tokens: drop restated goals, narration of what the
-assistant "then decided to", and pasted code you are only echoing; spend those
-characters on the four items below instead. A record that omits the branch but
-quotes 30 lines of diff is a bad trade.
-
-1. BRANCH / WORKING LOCATION — verbatim, in the fact `statement`. If the segment
- mentions or checks out `feat/x` / `fix/y`, that token MUST appear. An agent
- that resumes on the wrong branch produces changes that are silently thrown
- away, so this one token outranks every other detail.
-
-2. WHICH VERSION WON — when the user changed their mind, name the winner and mark
- the loser in one clause: "settled on A; the interim B was dropped". Not both in
- full — one clause. Keeping only the latest is wrong: an agent that meets the
- rejected code must recognize it, or it will "fix" things back to the discarded
- variant. Phrases like `scratch that / go back to / actually, let's / no, not that`
- mark this: what follows is of record, what precedes is superseded.
-
-3. EXACT COORDINATES, NOT PASTED CODE — repo-relative path
- (`qutebrowser/utils/debug.py`, never bare `debug.py`) plus the function /
- class touched. If a signature changed, give the new signature. If a constant,
- regex or literal was decided, quote THAT verbatim — but quote only it, not the
- surrounding block. One accurate line beats a paragraph of approximation.
-
-4. VERIFIED vs MERELY WRITTEN — four words is enough ("tests run and passing" /
- "confirmed by git diff only, tests not run"). "the edit is in" and "the edit is in
- and tested" lead a future agent to do very different things next.
-
-Anti-pattern — summarizing the goal and dropping the coordinates:
- bad: "refactored the colour parsing logic to be cleaner."
- good: "on feat/q4, in qutebrowser/config/configtypes.py QtColor._parse_value:
- settled on `mult = 360.0 if kind == 'h' else 255.0`; the interim version that
- used 255.0 for everything was dropped. Tests not run."
- (the good one is SHORTER than most bad ones — it just spends every character
- on something that cannot be re-derived)
-
-═══════════════════════════════════════════════════════════════════
-EXPERIENCE FIELDS
-═══════════════════════════════════════════════════════════════════
-
-task — Query-shaped name; phrase as how a user would later ASK.
- "publish a release to the xx platform", not "publish_release_internal"
- Self-contained (no "this", "the file", "we").
-
-search_keys — 0 to 5 alternative phrasings capturing important aspects of
- solution that `task` alone wouldn't match. Phrase as questions
- or topics future users would ASK ABOUT. Distinct from task.
- Omit if task already covers everything.
-
-solution — Complete, self-contained content the user actually needs:
- commands, credential locations (NOT credential VALUES),
- file paths, ordered steps, gotchas, decision rationale.
- Aggregate multi-turn end-to-end work into ONE solution if it
- forms a coherent task; split into multiple memories only when
- the user did unrelated tasks.
-
-boundary_envs — Concrete pinning that solution depends on, multi-line "key: value":
- runtime / SDK / library + version
- API endpoint or method signature
- external service / middleware version
- env var NAME (not value)
- config file path
- host / cluster / region identifier
- If solution is environment-agnostic, leave as "" (empty).
- Purpose: when the underlying SDK/middleware upgrades, future
- consumers can inspect this to decide if solution still applies.
-
-confidence — 0.0 to 1.0
- 1.0 user explicitly stated this as a rule / instruction
- 0.7 inferred with good evidence from tool actions
- 0.5 weakly inferred; one observation; uncertain
-
-═══════════════════════════════════════════════════════════════════
-FACT FIELD — EXACTLY ONE per segment, no value bar
-═══════════════════════════════════════════════════════════════════
-
-You write ONE fact for the whole segment — a recoverable state record for this
-session, not a polished retrospective and never a list of separate findings. A
-future agent must be able to resume from it without mistaking a suggestion,
-inference, or partial search for something verified.
-
-statement — A compact summary of THIS session. It has two jobs at once, and it
- must do BOTH: it is the retrieval vector (a future agent finds it by
- searching with a fresh issue report, phrased the way a user phrases a
- problem), and it is the payload that agent then acts on. So:
-
- OPEN with the task and the symptom, in the words a user would use.
- This is what makes it findable — keep the surface form close to how
- the problem would be reported. Name the specific goal and object
- ("reclaim disk space under D:\\WXWork", "adjust the hue multiplier
- in QtColor._parse_value on feat/q4", "locate the new_file_search
- folder"), never a generic "fix a bug" / "look for a file". Include
- the concrete symptom: the error string, the failing command, the
- wrong output.
-
- THEN give the coordinates and the decision.
- repo-relative path, symbol, and branch for code work. State what was
- SETTLED ON, and in the same clause mark what was dropped
- ("settled on X; the interim Y was dropped"). This is the part that
- cannot be re-derived by reading the code — the code only shows the
- winner, never that Y was tried and rejected. An agent that meets the
- rejected variant later must be able to recognize it, or it will
- "fix" the code back to the discarded version.
-
- CLOSE with the evidence status.
- Exactly one of: completed, partially completed, failed, blocked, or
- still awaiting verification — plus how it was checked ("tests run and
- passing" / "confirmed by git diff only, tests not run"). Include
- negative results and dead ends without overstating them.
-
- ⚠️ Never stop at the narrative. "The user tried X and hit error Y; no
- solution found yet" is a wasted record: it retrieves fine but gives a
- future agent nothing to act on. If the session genuinely reached no
- decision, say what was ruled out and what the next unexplored lead is —
- that is the reusable part.
-
- The subject of the sentences should be the code and the decision, not
- "the user". 2 to 4 sentences, flowing prose, not labelled sections.
- Hard ceiling ~400 latin characters (~200 CJK characters).
-
- EVIDENCE FIDELITY — mandatory:
- - Record only actions actually executed and evidence explicitly
- present in the trace. Preserve material commands, flags,
- arguments, errors, and numbers verbatim. NEVER complete a
- command with customary flags or turn advice/plans into actions.
- - Preserve the distinction among attempted, observed, verified,
- inferred, and unresolved. Do not add those labels to the prose;
- express their meaning naturally, e.g. "tried … but was blocked by
- Access denied" or "suspect … , not yet verified".
- - Without tool output or explicit confirmation, NEVER claim a fix
- succeeded, a cause was established, a file/folder does not
- exist, or tests passed.
- - Scope every negative finding to what was actually searched and
- enumerate EVERY explicit coverage limit that could invalidate
- it, especially permission failures and maximum search depth:
- "not found within the searched parts of C:\\ and D:\\; some
- directories were skipped on Access denied, and the search was also
- depth-limited". Do not omit one limit to make the
- summary prettier. Never promote a partial search to global
- absence.
- - State causality as certain only when the trace directly verifies
- it. Otherwise retain the hedge ("suspected" / "inferred" / "not yet
- verified"); do not rewrite an
- incorrect test assumption as the system's root cause.
-
- CRITICAL — this text IS the retrieval vector, and it is the only
- thing a future query gets matched against. A generic summary is
- worthless, because EVERY session looks like a generic summary: it
- would match every query and answer none of them. So you MUST name
- the concrete anchors that make THIS session findable — real file
- paths, function / symbol names, branch names, commands, error
- strings, versions, config keys and values, host / service names.
- If someone later searches for any one of those specifics, this
- summary has to be the thing that comes back.
- good: "fixing a failing `npm run build` in CI. Read
- .github/workflows/ci.yml and package.json; traced it to webpack
- 5.74 hitting ERR_OSSL_EVP_UNSUPPORTED under node 18. Bumping the
- workflow's node to 20 made the build pass; node 18 still
- reproduces locally."
- good: "on branch feat/q0, in qutebrowser/utils/debug.py signal_name:
- PyQt<5.11 only exposes the name via repr(sig), and repr comes in
- both a bracketed and a parenthesised form. Settled on two patterns
- tried in order with fullmatch, breaking on the first hit; the
- single-regex version was dropped. Confirmed by git diff, tests not
- run."
- bad: "user wanted a build bug fixed, the agent looked at some config
- files, changed some code, and fixed it."
- (no path, no command, no error string, no version — nothing
- to retrieve on; every session reads exactly like this)
- bad: "fixed the signal-name parsing compatibility issue on a feature
- branch."
- (which branch? which file? which function? which of the two
- competing versions won? nothing here survives being
- retrieved a week later)
- Fidelity examples (bad → good):
- "ran Get-ChildItem -Force" → "ran Get-ChildItem"
- (the trace did not contain `-Force`; do not invent it)
- "confirmed new_file_search does not exist" →
- "new_file_search was not found within the searched parts of C:\\ and
- D:\\; some directories were skipped on Access denied or by the depth
- limit, so the investigation is only partly done"
- "identical payloads cause a spurious lock error" →
- "the verification script assumed the last writer is always a fixed
- rank; that assumption does not hold, so whether there is a lock bug
- is still unverified"
-
- Do NOT record greetings or pure chatter. If the segment established
- nothing at all, output "fact": null.
-
-files — 0..N absolute or repo-relative FILE OR DIRECTORY paths actually
- operated on or investigated during this session. Keep investigated
- roots such as `C:\\` and `D:\\`. Only include paths that were
- actually accessed/searched, not paths merely suggested or planned;
- [] if none apply.
-
-═══════════════════════════════════════════════════════════════════
-HOST CONTEXT (given by SDK)
-═══════════════════════════════════════════════════════════════════
-- workspace_id present: {workspace_present}
-- branch present: {branch_present}
-
-When no workspace_id is present, the solution cannot rely on unstated
-project-local context — spell out any repo / path / service it needs inside
-`solution` or `boundary_envs` so the memory stays usable on its own.
-
-═══════════════════════════════════════════════════════════════════
-CONVERSATION
-═══════════════════════════════════════════════════════════════════
-{conversation_block}
-
-═══════════════════════════════════════════════════════════════════
-OUTPUT (strict JSON only, no markdown)
-═══════════════════════════════════════════════════════════════════
-{{
- "experiences": [
- {{
- "task": "...",
- "search_keys": ["...", "..."],
- "solution": "...",
- "boundary_envs": "...",
- "confidence": 0.9
- }}
- ],
- "fact": {{
- "statement": "...",
- "files": ["..."]
- }}
-}}
-
-MANDATORY: You MUST output at least ONE experience. Do NOT return an empty list.
-Even if the task looks simple or is a one-shot success, still capture the
-reusable essence of what was done (the method / command / how-to). Only the
-single most valuable experience is required when the session is thin — but never
-output an empty "experiences" array.
-
-"fact" is a SINGLE object, never a list — one record per session. Use
-"fact": null only when the segment is pure chatter that established nothing.
-"""
+from ..prompts.en import CODING_EXTRACT_PROMPT_CODING as EXTRACT_PROMPT_CODING # noqa: E402,F401 (re-export)
# ================================================================
@@ -839,15 +176,22 @@ class CodingMemoryExtractor:
if str(message.content or "").strip()
)
- def _select_prompt_template(self, messages: List[ChatMessage]) -> Tuple[str, str]:
- """Return (template, language) for this write's new messages."""
- if not is_chinese(self._language_text(messages)):
- return self._prompt_tmpl, "en"
+ def _select_prompt_template(
+ self, messages: List[ChatMessage], language: Optional[str] = None,
+ ) -> Tuple[str, str]:
+ """Return (template, language code) for this write's new messages.
- from .prompts_zh import EXTRACT_PROMPT_CODING_ZH, EXTRACT_PROMPT_ZH
-
- prompt = EXTRACT_PROMPT_CODING_ZH if self.scene == "coding" else EXTRACT_PROMPT_ZH
- return prompt, "zh"
+ Explicit ``language`` wins; otherwise zh/en auto-detection over the new
+ user text (unchanged behaviour).
+ """
+ code = resolve_language(language, self._language_text(messages))
+ if code == "en":
+ return self._prompt_tmpl, code
+ name = (
+ "CODING_EXTRACT_PROMPT_CODING" if self.scene == "coding"
+ else "CODING_EXTRACT_PROMPT"
+ )
+ return get_prompt(name, code), code
async def extract(
self,
@@ -861,12 +205,14 @@ class CodingMemoryExtractor:
branch: Optional[str] = None,
session_id: Optional[str] = None,
request_id: str = "",
+ language: Optional[str] = None,
) -> Tuple[List[CodingMemoryDraft], List[WorkingFactDraft]]:
"""
Args:
messages: 本次 write 的完整新消息;只做单条限长,不裁 turn
history_messages: 之前 write 的历史消息;仅取最近 5 个 user-turn 作消解上下文
user_id / agent_id / workspace_id / branch / session_id: SDK 注入
+ language: 显式 prompt 语言码;None 时按新 user 文本做 zh/en 自动检测
Returns:
(经验草稿, 事实草稿)。两层都可能为空。只有显式启用
@@ -892,27 +238,26 @@ class CodingMemoryExtractor:
history_block = self._format_conversation(history_window).strip()
new_block = self._format_conversation(new_messages).strip()
- prompt_tmpl, prompt_language = self._select_prompt_template(new_messages)
- if prompt_language == "zh":
- conversation_block = (
- "最近 5 个用户轮次(仅作上下文,不要重复抽取):\n"
- + (history_block or "(无)")
- + "\n\n本次新增消息(只从这次完整写入中抽取):\n"
- + (new_block or "(无)")
- )
- else:
- conversation_block = (
- "LAST 5 USER TURNS (CONTEXT ONLY; do not extract them again):\n"
- + (history_block or "(none)")
- + "\n\nNEW MESSAGES (extract only from this complete write):\n"
- + (new_block or "(none)")
- )
+ explicit_language = normalize_language(language)
+ prompt_tmpl, prompt_language = self._select_prompt_template(
+ new_messages, explicit_language,
+ )
+ empty_block = get_prompt("CODING_EMPTY_BLOCK", prompt_language)
+ conversation_block = get_prompt(
+ "CODING_CONVERSATION_BLOCK", prompt_language,
+ ).format(
+ history=history_block or empty_block,
+ new=new_block or empty_block,
+ )
prompt = prompt_tmpl.format(
workspace_present=str(bool(workspace_id)).lower(),
branch_present=str(bool(branch)).lower(),
conversation_block=conversation_block,
)
+ prompt = with_output_language(
+ prompt, prompt_language, explicit=explicit_language is not None,
+ )
_t0 = time.perf_counter()
try:
diff --git a/hy_memory/coding/fact_reconciler.py b/hy_memory/coding/fact_reconciler.py
index 9cc946e..7e0e6dc 100644
--- a/hy_memory/coding/fact_reconciler.py
+++ b/hy_memory/coding/fact_reconciler.py
@@ -23,7 +23,12 @@ from typing import Any, Dict, List, Optional, Tuple
from ..agent.llm_provider import LLMProvider
from ..core.embed_service import EmbedService
-from ..utils.lang_detect import is_chinese
+from ..prompts import (
+ get_prompt,
+ normalize_language,
+ resolve_language,
+ with_output_language,
+)
from .store import CodingMemoryStore
from .types import (
@@ -206,143 +211,10 @@ def _subject_conflict(new_subject: str, old_subject: str) -> bool:
# General subject-isolation rules belong in the prompt; lookalike examples
# encourage pattern matching instead of teaching the rule.
-FACT_RECONCILE_PROMPT = """\
-You maintain session-level WORKING FACTS. Each statement summarizes one whole
-trace/session: the user's task, the rough approach, and the result. It is not an
-atomic claim.
-
-Every new session fact below WILL be stored; that is not your decision. Your only
-job is to detect task continuation: is the new session continuing to advance the
-SAME user task as an existing session fact? If so, SUPERSEDE the older fact so
-the links form a cross-session progress chain for that task.
-
-Mark an existing fact as superseded ONLY when there is strong evidence that:
- - The subjects match: both records are about the SAME entity — the same
- person, the same file/module, the same host/service. A shared subject is
- necessary but not sufficient; AND
- - The user goal is materially the SAME, not merely in the same topic/project;
- AND
- - The new trace continues, retries, extends, verifies, or finishes the work
- recorded by the existing trace.
-
-Do NOT supersede when:
- - The two records name different subjects. Two people in one group, two files
- in one module, two hosts in one cluster are PARALLEL, not successive: one
- person's state is not a newer version of another's. Where a subject is shown
- as (unspecified), fall back to judging by the statement alone.
- - The sessions merely mention the same file, symbol, component, repository,
- error, or technology but pursue different user goals.
- - One task only supplies context or a technique for another task.
- - The relationship is uncertain. Be conservative: INSERT is the safe default;
- merging unrelated sessions destroys their separate task history.
-
-Treat each statement as evidence-bounded text. Do not reinterpret an inference
-inside it as an established cause or use a shared conjecture/error as proof that
-the user goals are the same. Your decision is only about task continuation; do
-not "correct", complete, or embellish either session record.
-
-Examples:
- existing: "The user needed to fix CI's npm run build; traced it to
- ERR_OSSL_EVP_UNSUPPORTED under Node 18, workflow not yet changed."
- new: "The user continued fixing the same CI build; raised Node in
- .github/workflows/ci.yml to 20 and npm run build passed."
- → SUPERSEDE
-
- existing: "The user needed to fix JWT expiry handling in
- auth/middleware.ts; refresh logic was added."
- new: "The user needed performance logging added to
- auth/middleware.ts; a latency metric was introduced."
- → keep both
- (same file/project, different user goal)
-
-═══════════════════════════════════════════════════════════════════
-NEW SESSION FACTS
-═══════════════════════════════════════════════════════════════════
-{drafts_block}
-
-═══════════════════════════════════════════════════════════════════
-EXISTING SESSION FACTS (per new fact, retrieved by statement similarity)
-═══════════════════════════════════════════════════════════════════
-{candidates_block}
-
-═══════════════════════════════════════════════════════════════════
-OUTPUT (strict JSON only, no markdown)
-═══════════════════════════════════════════════════════════════════
-{{
- "ops": [
- {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "continues the same CI fix task"}},
- {{"draft_idx": 1, "supersedes": []}}
- ]
-}}
-
-Only use fact ids that appear in the candidate list for that same draft_idx.
-If nothing is superseded anywhere, output {{"ops": []}}.
-"""
+from ..prompts.en import CODING_FACT_RECONCILE_PROMPT as FACT_RECONCILE_PROMPT # noqa: E402,F401 (re-export)
-CHAIN_SUMMARY_PROMPT = """\
-A user task in a working-memory store has progressed across sessions. Below are
-the session summaries in that task's progress chain, oldest first, ending with
-the current session.
-
-Summarize how the SAME task progressed across sessions to its current state.
-Cover every important stage in chronological order. For each stage, preserve
-where available: the actual action or change, its direct result, and any
-unresolved issue or limiting condition. End with an explicit current status.
-
-Rules:
- - This is compression only. Report ONLY what the entries say; never add or
- complete a command, cause, motive, action, test result, success state, or
- global negative conclusion.
- - Preserve evidence status exactly: attempted is not completed, observed is
- not verified, inferred is not established, and unresolved stays unresolved.
- Keep uncertainty words and search/permission/coverage limits.
- - State the current ending status faithfully (completed, partially completed,
- failed, blocked, or still awaiting verification). Never upgrade it based on
- a plausible causal story or on a later entry that did not verify it.
- - When entries mention a suspected cause and a later result, connect them
- causally only if an entry directly says that cause was verified.
- - Preserve concrete retrieval anchors: file paths, symbols, commands, error
- strings, versions, config keys/values, and important numeric values that
- matter to the progress.
- - For chains of 2-3 generations, do not over-compress the progression into one
- sentence. Prefer 2-4 compact paragraphs when useful, or readable prose with
- a clear task goal, stage-by-stage progression, and current status.
- - Do not mechanically copy the full history. Omit repetition and low-value
- detail while retaining important actions, direct results, and leftovers.
- - Do not invent stage headings or dates. Mention a date only when the entries
- make it meaningful; bare timestamps are noise.
- - If the entries say older revisions were omitted, explicitly state that
- earlier history was omitted; do not imply the supplied entries are complete.
- - Write in the same language the entries are written in.
- - No preamble or enclosing quotes.
-
-Example
- entries:
- (2026-07-20) The user needed to fix CI's npm run build; traced it to
- ERR_OSSL_EVP_UNSUPPORTED under Node 18, workflow not yet
- changed.
- (2026-07-24) The user continued that CI fix; raised Node in
- .github/workflows/ci.yml to 20, but the dependency cache
- still reproduced the old error.
- (now) The user continued verifying the same fix; after clearing the
- npm cache, npm run build passed.
- output:
- The task goal is fixing CI's npm run build. It was first traced to
- ERR_OSSL_EVP_UNSUPPORTED under Node 18, with the workflow not yet changed;
- then .github/workflows/ci.yml was raised to Node 20, but the dependency
- cache kept the old error present. Finally, after clearing the npm cache,
- npm run build passed, so this build fix is currently verified as complete.
-
-═══════════════════════════════════════════════════════════════════
-ENTRIES
-═══════════════════════════════════════════════════════════════════
-{chain_block}
-
-═══════════════════════════════════════════════════════════════════
-OUTPUT (the summary itself, nothing else)
-═══════════════════════════════════════════════════════════════════
-"""
+from ..prompts.en import CODING_CHAIN_SUMMARY_PROMPT as CHAIN_SUMMARY_PROMPT # noqa: E402,F401 (re-export)
def _fact_drafts_language_text(drafts: List[WorkingFactDraft]) -> str:
@@ -357,37 +229,34 @@ def _fact_drafts_language_text(drafts: List[WorkingFactDraft]) -> str:
def build_fact_reconcile_prompt(
drafts: List[WorkingFactDraft],
candidates: List[List[WorkingFact]],
+ language: Optional[str] = None,
) -> Tuple[str, str]:
- """Return the language-matched fact reconcile prompt and language."""
- if is_chinese(_fact_drafts_language_text(drafts)):
- from .prompts_zh import FACT_RECONCILE_PROMPT_ZH
-
- template = FACT_RECONCILE_PROMPT_ZH
- language = "zh"
- else:
- template = FACT_RECONCILE_PROMPT
- language = "en"
- return template.format(
+ """Return the fact reconcile prompt and its language code.
+
+ Explicit ``language`` wins; otherwise zh/en auto-detection over the drafts.
+ """
+ explicit = normalize_language(language)
+ code = resolve_language(explicit, _fact_drafts_language_text(drafts))
+ prompt = get_prompt("CODING_FACT_RECONCILE_PROMPT", code).format(
drafts_block=WorkingFactReconciler._format_drafts(drafts),
candidates_block=WorkingFactReconciler._format_candidates(drafts, candidates),
- ), language
+ )
+ return with_output_language(prompt, code, explicit=explicit is not None), code
def build_chain_summary_prompt(
chain_block: str,
*,
current_statement: str,
+ language: Optional[str] = None,
) -> Tuple[str, str]:
- """Return the language-matched cross-session summary prompt and language."""
- if is_chinese(current_statement or chain_block):
- from .prompts_zh import CHAIN_SUMMARY_PROMPT_ZH
-
- template = CHAIN_SUMMARY_PROMPT_ZH
- language = "zh"
- else:
- template = CHAIN_SUMMARY_PROMPT
- language = "en"
- return template.format(chain_block=chain_block), language
+ """Return the cross-session summary prompt and its language code."""
+ explicit = normalize_language(language)
+ code = resolve_language(explicit, current_statement or chain_block)
+ prompt = get_prompt("CODING_CHAIN_SUMMARY_PROMPT", code).format(
+ chain_block=chain_block,
+ )
+ return with_output_language(prompt, code, explicit=explicit is not None), code
# ================================================================
@@ -455,9 +324,11 @@ class WorkingFactReconciler:
branch: Optional[str] = None,
source: str = "default",
memory_at: Optional[datetime] = None,
+ language: Optional[str] = None,
) -> Tuple[List[WorkingFact], List[FactReconcileOp]]:
"""
执行 reconcile + 持久化。memory_at 是这段对话的时间,记到新事实上。
+ language 为显式 prompt 语言码(None → zh/en 自动检测),同时用于演变总结。
Returns:
(真正落库的新事实, 执行过的 ops)。LLM 挂掉时退化为全 INSERT 不覆盖,
@@ -477,7 +348,7 @@ class WorkingFactReconciler:
)
try:
- supersedes = await self._llm_decide(drafts, candidates)
+ supersedes = await self._llm_decide(drafts, candidates, language=language)
except Exception as e:
logger.warning(
f"[fact-reconcile] LLM decide failed, insert without supersede: {e}"
@@ -495,6 +366,7 @@ class WorkingFactReconciler:
branch=branch,
source=source,
memory_at=memory_at,
+ language=language,
)
logger.info(
f"[fact-reconcile] drafts={len(drafts)} inserted={len(facts)} "
@@ -588,13 +460,14 @@ class WorkingFactReconciler:
self,
drafts: List[WorkingFactDraft],
candidates: List[List[WorkingFact]],
+ language: Optional[str] = None,
) -> Dict[int, List[str]]:
"""返回 {draft_idx: [被它覆盖的旧 fact_id, ...]}。"""
# 一条候选都没有就没得判,省一次 LLM 调用
if not any(candidates):
return {}
- prompt, _ = build_fact_reconcile_prompt(drafts, candidates)
+ prompt, _ = build_fact_reconcile_prompt(drafts, candidates, language=language)
resp = await self.llm_provider.complete(
prompt=prompt,
max_tokens=self.max_tokens,
@@ -638,7 +511,8 @@ class WorkingFactReconciler:
return ordered[-MAX_FACT_CHAIN_ENTRIES:], truncated
async def _summarize_chain(
- self, history: List[WorkingFact], current: str, *, truncated: bool = False
+ self, history: List[WorkingFact], current: str, *, truncated: bool = False,
+ language: Optional[str] = None,
) -> str:
"""让 LLM 把同一任务的跨 session 进展写成简短摘要。
@@ -659,6 +533,7 @@ class WorkingFactReconciler:
prompt, _ = build_chain_summary_prompt(
"\n".join(rows),
current_statement=current,
+ language=language,
)
try:
@@ -790,6 +665,7 @@ class WorkingFactReconciler:
branch: Optional[str] = None,
source: str = "default",
memory_at: Optional[datetime] = None,
+ language: Optional[str] = None,
) -> Tuple[List[WorkingFact], List[FactReconcileOp]]:
inserted: List[WorkingFact] = []
ops: List[FactReconcileOp] = []
@@ -873,7 +749,8 @@ class WorkingFactReconciler:
retired, user_id=user_id
)
new_fact.fact_chain_summary = await self._summarize_chain(
- history, new_fact.statement, truncated=truncated
+ history, new_fact.statement, truncated=truncated,
+ language=language,
)
# 摘要之外再把历代自己的 details 原样过继一份。摘要保叙事,过继保数值,
# 两者不重复:details 本来就不进摘要(_collect_history 只读 statement)。
diff --git a/hy_memory/coding/prompts_zh.py b/hy_memory/coding/prompts_zh.py
index 823ba26..353d163 100644
--- a/hy_memory/coding/prompts_zh.py
+++ b/hy_memory/coding/prompts_zh.py
@@ -1,745 +1,13 @@
# -*- coding: utf-8 -*-
-"""HY Memory working/coding 链路使用的中文提示词模板。"""
+"""HY Memory working/coding 链路使用的中文提示词模板(兼容入口)。
-
-EXTRACT_PROMPT_ZH = """\
-你需要从一段任务执行会话中抽取可长期保留的 WORKING 记忆。
-“working”会话是指用户通过工具操作计算机或系统的任何实操任务——既包括软件/代码
-工作(编写、调试、重构、构建、部署、API/library 使用),也包括系统与运维工作
-(运行 shell/PowerShell 命令、磁盘/存储分析或清理、文件与文件夹操作、安装/配置
-软件、环境/设备设置、硬件/磁盘健康检查、备份、调度/自动化、数据处理)。
-
-你需要从同一段会话中产出两个层次:
-
- EXPERIENCES(过程性,“如何做”)——可复用的方法;只有达到下述 VALUE BAR 时才
- 抽取。每条是一个 (task, search_keys, solution, boundary_envs) 组合。
-
- FACT(情节性,“这次发生了什么”)——关于本次会话的恰好一条记录:用户想做什么、
- 大致如何推进、最终结果如何。它不受价值门槛限制,但绝不能超过一条。
-
-这两个层次回答不同问题,并分别存储。可泛化的方法放入 EXPERIENCES;只对这个系统、
-这个项目、此时此刻成立的本次会话经历放入 FACT。
-
-═══════════════════════════════════════════════════════════════════
-VALUE BAR(仅适用于 EXPERIENCES)——不要轻易越过此门槛。
-═══════════════════════════════════════════════════════════════════
-一条记忆必须同时满足以下全部条件:
- (a) 解决了同一用户以后很可能再次遇到的问题
- (b) 解决方案并非琐碎操作:它组合了多项信息/多个步骤,或者包含决策理由,或者记录了
- 来之不易的 workaround,或者是某项运维任务的可复用流程/配方(例如如何分析并
- 清理磁盘占用、如何批量整理文件、如何检查硬件健康、如何设置 scheduled job)
- (c) 未来的 agent / 用户会更愿意查阅它,而不是重新摸索
-
-重要——分析、诊断、调查任务也算:
-一项任务不必实际修改或“修复”任何东西才值得记忆。只读、分析、故障排查工作,只要其
-流程或结论可复用,就有价值。明确抽取:
- - 分析/诊断配方:可复用的流程以及它揭示的结果(例如“如何分析哪些文件夹占用了
- C-drive 空间”——扫描命令、遇到的坑和最终发现)。“只生成了报告,没有修改”
- 不是跳过理由——可复用的方法本身就是记忆。
- - 调查结果,包括否定结果或未找到结果(例如“使用 rg / fs_search / SQL index
- 在 C: 和 D: 中搜索 folder X——任何位置都未找到”)。记录一条死路可以避免下一个
- agent 重复同样无果的搜索,因此达到了价值门槛。
-不要仅仅因为“assistant 可以重新生成这些命令”或“实际上没有修改任何东西”就拒绝
-一条记忆。只要流程或结论能节省未来的工作,就保留它。
-
-不要抽取:
- - 没有可复用流程、真正琐碎的单步操作(“rename one file”、“git status”、
- “run ls once”)
- - 已经解决且没有可迁移经验的一次性问题
- - repo/system 中已经存在的信息(不要重复 package.json)
- - 每个 PR / 每次会话的一次性任务,除非其中编码了可复用模式
- - 向用户询问缺失信息这一行为。请求参数、列出未知项或引导用户提供必填字段属于
- 对话行为,不是方法:每个 agent 都知道如何提问,因此以后没有任何值得查阅的内容。
- 绝不要产出 task 或 search_keys 形如“how to ask for X”、“gather the missing Y”、
- “eliciting required fields”、“what to clarify before starting”的 experience。
- 注意,这条限制只适用于 EXPERIENCES——会话最终停在等待用户的状态是真实状态,
- 应写入 FACT。
-
-如果该段会话因为等待用户而没有取得任何实质进展——assistant 只是询问参数,或者在
-开展任何实际工作前就被阻塞——输出 "experiences": [],只写 FACT。此时尚未学到任何
-东西,因此没有方法可存。这一点比看起来更重要:从停滞中提炼出的 experience 在检索时
-会像一项真正的技能;同一任务的后续片段会匹配它,再次向用户提问而不是继续推进,导致
-这种停滞在余下会话中不断自我复制。应根据工具实际做了什么判断是否有实质进展,而不是
-根据该轮是否生成了流畅文本。
-
-启发式标准:如果用户(或未来执行同类任务的 agent)希望把它记下来,而不是以后再重新
-摸索,就保留。多步骤运维流程通常符合条件——包括 system/ops 或只读分析/搜索流程,
-不局限于代码。只有当它只是任何用户都能在 30 秒内通过 `--help` 找到的单条命令,并且
-不包含值得记忆的决策或坑点时,才丢弃。
-
-═══════════════════════════════════════════════════════════════════
-EXPERIENCE 字段
-═══════════════════════════════════════════════════════════════════
-
-task — 采用查询式名称;写成用户以后会如何提问。
- 使用“publish a release to the xx platform”,不要使用
- “publish_release_internal”。
- 必须自包含(不要使用“this”、“the file”、“we”)。
-
-search_keys — 0 到 5 种替代表述,用来覆盖仅靠 `task` 无法匹配、但对 solution 很
- 重要的方面。写成未来用户会询问的问题或主题,且必须与 task 有区别。
- 如果 task 已覆盖全部内容,则省略。
-
-solution — 用户实际需要的完整、自包含内容:命令、凭据位置(不是凭据值)、
- 文件路径、有序步骤、坑点、决策理由。如果多轮端到端工作构成一个连贯
- 任务,应聚合成一个 solution;只有用户执行了互不相关的任务时才拆成
- 多条记忆。
-
-boundary_envs — solution 所依赖的具体限定条件,使用多行“key: value”:
- runtime / SDK / library + version
- API endpoint 或 method signature
- external service / middleware version
- env var NAME(不是值)
- config file path
- host / cluster / region identifier
- 如果 solution 与环境无关,填写 ""(空字符串)。
- 目的:底层 SDK/middleware 升级后,未来使用者可以据此判断 solution
- 是否仍然适用。
-
-confidence — 0.0 到 1.0
- 1.0 用户明确将其陈述为规则/指令
- 0.7 根据工具操作及充分证据推断
- 0.5 弱推断;只有一次观察;不确定
-
-═══════════════════════════════════════════════════════════════════
-FACT 字段——每段会话恰好一条,无价值门槛
-═══════════════════════════════════════════════════════════════════
-
-你要为整段会话写一条 FACT——它是本次会话可恢复的状态记录,不是精心润色的回顾,也
-绝不是分散发现的列表。未来 agent 必须能够从中继续推进,且不会把建议、推断或局部搜索
-误认为已经验证的事实。
-
-subject — 本次会话围绕谁或什么展开:工作所针对或服务的单一实体。使用简短名词
- 短语,不要写句子,不要使用动词。选择会话真正围绕的最具体实体,而不是
- 所使用的工具:
- 会话服务于某个具名人员时,使用人名
- (“Dylan”、“Matthew”)
- 工作针对代码时,使用 file / module / symbol
- (“auth/middleware.ts”、“parse_plan_text”)
- 运维工作使用 service / host / device / drive
- (“D:\\WXWork”、“redis-cache-prod”、“ci.yml”)
- 这是 HARD KEY,不是散文:关于不同人员或不同文件的两次会话必须得到不同
- subject;关于同一实体的两次会话必须得到拼写完全一致的同一字符串。
- 优先使用 trace 中出现的精确标识符,而不是对它的描述。如果该段确实没有
- 单一 subject,输出 ""。
-
- 这很重要:subject 是决定后续会话是否可以按“同一任务的继续”覆盖本条
- 记录的闸门。填错后,一个人的状态可能静默替换另一个人的状态。
-
-statement — 本次会话的紧凑记录。它分为两部分,而第二部分最容易丢失。
- 保留任务范围内的给定量和具体约束,不要用泛泛的结果评价取代它们。
- 每条规则只写一次:重复的指令文字会挤占记忆真正需要保留的数据。
-
- PART 1——发生了什么,约 300 个拉丁字符(约 150 个 CJK 字符)。
- 从具体目标和对象开始(“reclaim disk space taken by D:\\WXWork”、
- “locate the new_file_search folder”),不要写泛泛的“fix a bug”/
- “find a file”。然后概述检查、尝试或修改了什么。最后说明结束状态,
- 且语义必须精确对应以下之一:completed、partially completed、failed、
- blocked、still awaiting verification。纳入否定结果和死路,但不要夸大。
-
- PART 2——TASK-SCOPED GIVENS:整个任务赖以运行的全部给定信息,即使并非
- 本段会话建立,或看起来基础到不值得写。包括绑定关系(每个 name/symbol/
- label 代表什么)、任务提供而不是推导出的固定值、采用的约定(indexing
- base、units、timezone、defaults),以及本段自己的结果和值(写“x = 7”,
- 不要只写“the value was computed”)。
-
- 将 PART 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
- 每一行几乎都应由值构成。保留 trace 的 notation——symbols、units、
- numbers、spellings——删掉其句子外壳:去掉那些只是宣告“这是给定量”的
- 短语,而非给定量本身(“I would prefer”、“it should be somewhere
- between … and …”)。这些短语会在每项重复;一个 15 项列表会为它们
- 支付 15 次空间成本。
- 每一条 FACT 都要携带这些信息;绝不要写“as above”或“same as the
- previous session”——检索只会按相似度返回少量 facts,被指代项可能不在
- 其中。
-
- 总长度尽量控制在 1200 字符以内。如果 PART 2 放不下,应优化 notation,
- 绝不能削减覆盖范围:statement 是 retrieval vector,也是后续 segment
- 唯一能读到的字段(details 既不做 embedding,也不会被注入),因此从中
- 删除的内容就永久丢失。压缩给定量周围的措辞,绝不要压缩给定量本身。
-
- 检验标准:如果下一段看不到原始材料,能否仅凭此记录继续任务?只有肯定
- 答案才合格。缺失 binding 不会明显报错——该名称仍看起来有意义,于是会
- 按其通用含义被理解,后续答案可以很流畅,却回答了另一个问题。
-
- LANGUAGE——使用与 session trace 相同的语言:statement 是 retrieval
- vector,而查询会使用用户的工作语言;改用另一种语言会让每次检索都付出
- 跨语言匹配损失。
-
- EVIDENCE FIDELITY——只记录 trace 中实际执行的操作和明确存在的证据。
- 对关键命令、flags、arguments、errors、numbers 保持原样。
- 绝不要按惯例补全命令 flags,也不要把建议或计划写成已经执行的动作:
- “ran Get-ChildItem -Force” → “ran Get-ChildItem”
- (trace 中没有 `-Force`,不要杜撰)
- 每个否定发现都必须限定在实际搜索范围内,并逐一列出可能使其失效的所有
- 明确覆盖限制,尤其是 permission failures 和 depth limits:保留当时的
- roots、filters、depth(“not found under C:\\ and D:\\ at depth 3;
- some directories were not covered due to Access denied”),绝不要扩大为
- “does not exist”。不要为了让记录更漂亮而漏掉任何限制。
- 绝不要把局部搜索提升为全局不存在。
- 被阻塞的尝试必须保留其 blocker。
- 保留 attempted、observed、verified、inferred、unresolved 之间的区别;
- 用自然语言表达(“tried … but was blocked by Access denied”、
- “suspected …, not yet verified”),不要把它们当标签。没有工具输出或
- 明确确认时,绝不要声称修复已成功、原因已确定或路径不存在。
-
- 不要记录问候或纯闲聊——只有这种情况才输出 "fact": null。仅仅陈述了
- 要求,或尚未开展工作就停滞的会话,仍然建立了信息。
-
-details — 本次会话的具体 OUTPUT,逐字复制。`statement` 是摘要,而摘要必然会
- 丢掉各个具体值;后续检索几乎总是在寻找某个具体值,而非大意。因此,只要
- 会话产出了可寻址的结果,就以原始形式和结构复现在这里:
- plan / schedule / itinerary → 每一行、每一天、每个 slot、每个 price
- 都严格按原文保留
- config 或 code block → 保留整个 block
- command 的关键 output → 保留承载发现的行(sizes、counts、versions、
- error text)
- structured result(table、records list)→ 保留各行
- 保留原始布局——line breaks、`Day 1:` / key: value prefixes、units、
- currency symbols、ids。不要再次概括,不要重排,不要舍入数字,不要翻译。
-
- 只复制 trace 中实际存在的内容。绝不要填补空缺:如果某个 slot 没有填,
- 就保持未填或明确说明——杜撰的值比缺失的值更糟,因为它会被检索并使用。
- 长度控制在约 4000 字符;如果输出更长,保留承载具体值的部分,删去装饰性
- 文字,并注明删掉了什么。
-
- 如果本次会话未产生此类 artifact(尚无发现的纯调查,或等待用户导致的
- 停滞),填写 ""。
-
- 此字段不属于 retrieval vector——`statement` 和 `subject` 负责找到
- 记录,`details` 在找到后提供具体值。因此不要在此堆砌检索诱饵,也不要
- 重复摘要;只写原始内容。
-
-files — 0..N 个本次会话中实际操作或调查过的绝对或 repo-relative FILE OR
- DIRECTORY paths。保留调查过的 roots,例如 `C:\\` 和 `D:\\`。只包含
- 实际访问/搜索过的路径,不包含仅建议或计划访问的路径;不适用时填写 []。
-═══════════════════════════════════════════════════════════════════
-HOST CONTEXT(由 SDK 提供)
-═══════════════════════════════════════════════════════════════════
-- workspace_id present: {workspace_present}
-- branch present: {branch_present}
-
-没有 workspace_id 时,solution 不能依赖未声明的项目本地上下文——必须在 `solution`
-或 `boundary_envs` 中明确写出其所需的 repo / path / service,使记忆能够独立使用。
-
-═══════════════════════════════════════════════════════════════════
-CONVERSATION
-═══════════════════════════════════════════════════════════════════
-{conversation_block}
-
-═══════════════════════════════════════════════════════════════════
-OUTPUT(仅输出严格 JSON,不要 markdown)
-═══════════════════════════════════════════════════════════════════
-{{
- "experiences": [
- {{
- "task": "...",
- "search_keys": ["...", "..."],
- "solution": "...",
- "boundary_envs": "...",
- "confidence": 0.9
- }}
- ],
- "fact": {{
- "subject": "...",
- "statement": "...",
- "files": ["..."],
- "details": "..."
- }}
-}}
-
-默认应进行抽取。当该段会话确实完成了实际工作时,必须输出至少一条 experience——即使
-任务看似简单或一次成功,也要记录所做工作的可复用本质(method / command / how-to)。
-会话内容较少时,只保留最有价值的一条 experience 即可。
-
-唯一例外是上述停滞情况:如果该段因为缺少信息、被阻塞在向用户提问而没有开展实际工作,
-输出 "experiences": [],只写 fact。不要为了满足本指令而杜撰 experience——杜撰的
-“how to ask for the departure city”比没有记忆更糟,因为以后会被检索并照做。只有这个
-原因允许空数组;实际开展过工作时,绝不能把空数组当捷径。
-
-"fact" 是单个对象,绝不是列表——每次会话一条记录。
-
-始终写 fact。fact 的门槛不是“这是否有价值”,而是“是否发生了任何事情”;能够到达
-你的 segment 已经越过这条门槛。这包括看起来只是 setup 而非工作的片段:仅有一条用户
-消息陈述 requirements、parameters 或 starting state,即使没有运行工具,也恰恰是后续
-会话无法自行重建的材料——把需求、参数、起始状态连同情形一起写进 `statement`(紧凑
-记法,不要照抄对话原句),不要推给 `details`(`details` 不进检索向量,读取侧也不再
-注入它)。只有完全没有内容的问候和纯闲聊才使用 "fact": null。有疑问时应写 fact:
-多余记录只多占一行,而漏掉记录会伤害每一次需要它、却无从知道它曾存在的后续会话。
-"""
-
-
-EXTRACT_PROMPT_CODING_ZH = """\
-╔═══════════════════════════════════════════════════════════════════════════╗
-║ HARD CONSTRAINT——先阅读本节;它覆盖本提示词后文任何看似要求叙事的措辞。 ║
-║ ║
-║ 你不是在撰写某个人做过什么的报告。你要写的是 FUTURE AGENT 为采取行动所需要 ║
-║ 的信息。该 agent 已有自己的任务;它不关心这个用户想要什么。它需要知道:此处 ║
-║ 做出了什么决定、位于哪些代码坐标、尝试并否决了什么,以及是否经过验证。 ║
-║ ║
-║ 具体来说,每个 `statement` 和每个 `solution` 都必须遵守: ║
-║ · 语法主语必须是 CODE 或 THE DECISION——绝不能是“the user”,也绝不能是 ║
-║ “the agent”。不要写“The user attempted to…”、“The user wanted…”、 ║
-║ “The agent then checked…”。 ║
-║ · 绝不要用“the session was completed”、“the error was noted”、 ║
-║ “no solution was found yet”之类流水账短语收尾。结尾应写决定及其验证 ║
-║ 状态。如果没有做出决定,就以已排除的内容和下一条尚未探索的线索收尾——这才 ║
-║ 是可复用部分。 ║
-║ · 保留具体症状(error string、failing command、wrong output)——未来搜索 ║
-║ 正是通过这些内容命中。 ║
-║ ║
-║ bad: “The user attempted to write a QTable to RST with header_rows and ║
-║ hit a TypeError. The session was completed with the error noted.” ║
-║ good: “ascii.rst's RST writer rejects header_rows: ║
-║ `tbl.write(..., format='ascii.rst', header_rows=['name','unit'])` ║
-║ raises TypeError because RST.__init__ does not forward it, unlike ║
-║ ascii.fixed_width which accepts it. No fix written — the writer ║
-║ needs the same header_rows plumbing as fixed_width.” ║
-╚═══════════════════════════════════════════════════════════════════════════╝
-
-你需要从一段任务执行会话中抽取可长期保留的 WORKING 记忆。
-“working”会话是指用户通过工具操作计算机或系统的任何实操任务——既包括软件/代码
-工作(编写、调试、重构、构建、部署、API/library 使用),也包括系统与运维工作
-(运行 shell/PowerShell 命令、磁盘/存储分析或清理、文件与文件夹操作、安装/配置
-软件、环境/设备设置、硬件/磁盘健康检查、备份、调度/自动化、数据处理)。
-
-你需要从同一段会话中产出两个层次:
-
- EXPERIENCES(过程性,“如何做”)——可复用的方法;只有达到下述 VALUE BAR 时才
- 抽取。每条是一个 (task, search_keys, solution, boundary_envs) 组合。
-
- FACT(情节性,“这次确立了什么”)——关于本次会话的恰好一条记录。它不是用户做了
- 什么的叙事,而要按以下顺序记录:任务及其具体症状(使它以后能被检索到)、代码坐标、
- 最终采用了什么以及拒绝了什么、验证推进到什么程度。它不受价值门槛限制,但绝不能
- 超过一条。
-
-这两个层次回答不同问题,并分别存储。可泛化的方法放入 EXPERIENCES;只对这个系统、
-这个项目、此时此刻成立的本次会话经历放入 FACT。
-
-═══════════════════════════════════════════════════════════════════
-VALUE BAR(仅适用于 EXPERIENCES)——不要轻易越过此门槛。
-═══════════════════════════════════════════════════════════════════
-一条记忆必须同时满足以下全部条件:
- (a) 解决了同一用户以后很可能再次遇到的问题
- (b) 解决方案并非琐碎操作:它组合了多项信息/多个步骤,或者包含决策理由,或者记录了
- 来之不易的 workaround,或者是某项运维任务的可复用流程/配方(例如如何分析并
- 清理磁盘占用、如何批量整理文件、如何检查硬件健康、如何设置 scheduled job)
- (c) 未来的 agent / 用户会更愿意查阅它,而不是重新摸索
-
-重要——分析、诊断、调查任务也算:
-一项任务不必实际修改或“修复”任何东西才值得记忆。只读、分析、故障排查工作,只要其
-流程或结论可复用,就有价值。明确抽取:
- - 分析/诊断配方:可复用的流程以及它揭示的结果(例如“如何分析哪些文件夹占用了
- C-drive 空间”——扫描命令、遇到的坑和最终发现)。“只生成了报告,没有修改”
- 不是跳过理由——可复用的方法本身就是记忆。
- - 调查结果,包括否定结果或未找到结果(例如“使用 rg / fs_search / SQL index
- 在 C: 和 D: 中搜索 folder X——任何位置都未找到”)。记录一条死路可以避免下一个
- agent 重复同样无果的搜索,因此达到了价值门槛。
-不要仅仅因为“assistant 可以重新生成这些命令”或“实际上没有修改任何东西”就拒绝
-一条记忆。只要流程或结论能节省未来的工作,就保留它。
-
-不要抽取:
- - 没有可复用流程、真正琐碎的单步操作(“rename one file”、“git status”、
- “run ls once”)
- - 已经解决且没有可迁移经验的一次性问题
- - repo/system 中已经存在的信息(不要重复 package.json)
- - 每个 PR / 每次会话的一次性任务,除非其中编码了可复用模式
-
-启发式标准:如果用户(或未来执行同类任务的 agent)希望把它记下来,而不是以后再重新
-摸索,就保留。多步骤运维流程通常符合条件——包括 system/ops 或只读分析/搜索流程,
-不局限于代码。只有当它只是任何用户都能在 30 秒内通过 `--help` 找到的单条命令,并且
-不包含值得记忆的决策或坑点时,才丢弃。
-
-═══════════════════════════════════════════════════════════════════
-CODE WORK——未来 agent 无法重新推导的信息,因此必须捕获
-═══════════════════════════════════════════════════════════════════
-当该段是针对 repository 的软件工作时,可复用方法只占一半。另一半是工作位于哪里,
-以及哪个版本胜出。这些无法通过以后阅读代码恢复——代码只能展示当前状态,无法说明它
-位于哪个 branch,也无法说明哪些方案已被否决。
-
-本节不是要求写得更长,而是要求把相同预算花在价值更高的 token 上:删掉重复目标、
-assistant“随后决定”做什么的叙事,以及只是复述的粘贴代码;把这些字符用于下面四项。
-一条遗漏 branch、却引用 30 行 diff 的记录是糟糕的取舍。
-
-1. BRANCH / WORKING LOCATION——逐字写入 fact `statement`。如果该段提到或 checkout
- 了 `feat/x` / `fix/y`,这个 token 必须出现。在错误 branch 上恢复工作的 agent
- 会产生随后被静默丢弃的改动,因此这一个 token 的优先级高于其他任何细节。
-
-2. WHICH VERSION WON——当用户改变主意时,用一个分句指出胜出者并标记落败者:
- “settled on A; the interim B was dropped”。不要完整保留两个版本,只需一个分句。
- 只保留最新版本是错误的:以后遇到被否决代码的 agent 必须识别它,否则会把代码
- “修复”回已经丢弃的变体。`scratch that / go back to / actually, let's / no, not that`
- 之类措辞就是标志:后面的内容才是正式结论,前面的内容已被 superseded。
-
-3. EXACT COORDINATES, NOT PASTED CODE——使用 repo-relative path
- (`qutebrowser/utils/debug.py`,绝不要只写 `debug.py`)以及触及的 function /
- class。如果 signature 发生变化,给出新的 signature。如果决定的是 constant、regex
- 或 literal,逐字引用它——但只引用这一项,不要引用周围 block。准确的一行胜过一段
- 近似描述。
-
-4. VERIFIED vs MERELY WRITTEN——四个词就足够(“tests run and passing”/
- “confirmed by git diff only, tests not run”)。“the edit is in”和“the edit is in
- and tested”会让未来 agent 采取完全不同的下一步。
-
-反例——只总结目标,却丢掉坐标:
- bad: “refactored the colour parsing logic to be cleaner.”
- good: “on feat/q4, in qutebrowser/config/configtypes.py QtColor._parse_value:
- settled on `mult = 360.0 if kind == 'h' else 255.0`; the interim version that
- used 255.0 for everything was dropped. Tests not run.”
- (good 往往比 bad 还短——它只是把每个字符都用在无法重新推导的信息上)
-
-═══════════════════════════════════════════════════════════════════
-EXPERIENCE 字段
-═══════════════════════════════════════════════════════════════════
-
-task — 采用查询式名称;写成用户以后会如何提问。
- 使用“publish a release to the xx platform”,不要使用
- “publish_release_internal”。
- 必须自包含(不要使用“this”、“the file”、“we”)。
-
-search_keys — 0 到 5 种替代表述,用来覆盖仅靠 `task` 无法匹配、但对 solution 很
- 重要的方面。写成未来用户会询问的问题或主题,且必须与 task 有区别。
- 如果 task 已覆盖全部内容,则省略。
-
-solution — 用户实际需要的完整、自包含内容:命令、凭据位置(不是凭据值)、
- 文件路径、有序步骤、坑点、决策理由。如果多轮端到端工作构成一个连贯
- 任务,应聚合成一个 solution;只有用户执行了互不相关的任务时才拆成
- 多条记忆。
-
-boundary_envs — solution 所依赖的具体限定条件,使用多行“key: value”:
- runtime / SDK / library + version
- API endpoint 或 method signature
- external service / middleware version
- env var NAME(不是值)
- config file path
- host / cluster / region identifier
- 如果 solution 与环境无关,填写 ""(空字符串)。
- 目的:底层 SDK/middleware 升级后,未来使用者可以据此判断 solution
- 是否仍然适用。
-
-confidence — 0.0 到 1.0
- 1.0 用户明确将其陈述为规则/指令
- 0.7 根据工具操作及充分证据推断
- 0.5 弱推断;只有一次观察;不确定
-
-═══════════════════════════════════════════════════════════════════
-FACT 字段——每段会话恰好一条,无价值门槛
-═══════════════════════════════════════════════════════════════════
-
-你要为整段会话写一条 FACT——它是本次会话可恢复的状态记录,不是精心润色的回顾,也
-绝不是分散发现的列表。未来 agent 必须能够从中继续推进,且不会把建议、推断或局部搜索
-误认为已经验证的事实。
-
-statement — 本次会话的紧凑摘要。它同时承担两个职责,且两者都必须完成:它既是
- retrieval vector(未来 agent 用一份新 issue report 搜索它;措辞方式
- 与用户报告问题的方式一致),也是该 agent 找到后要据以行动的 payload。
- 因此:
-
- 开头写任务和症状,使用用户会使用的措辞。
- 这是保证可检索性的关键——表述应尽量贴近问题被报告时的表面形式。
- 点明具体目标和对象(“reclaim disk space under D:\\WXWork”、
- “adjust the hue multiplier in QtColor._parse_value on feat/q4”、
- “locate the new_file_search folder”),绝不要写泛泛的“fix a bug”/
- “look for a file”。包含具体症状:error string、failing command、
- wrong output。
-
- 然后给出坐标和决定。
- 对代码工作写 repo-relative path、symbol 和 branch。说明最终 SETTLED ON
- 什么,并在同一分句标记丢弃了什么(“settled on X; the interim Y was
- dropped”)。这部分无法通过阅读代码重新推导——代码只展示胜出者,从不
- 展示 Y 曾被尝试后否决。以后遇到被否决变体的 agent 必须能识别它,
- 否则会把代码“修复”回已丢弃版本。
-
- 结尾写证据状态。
- 必须精确对应以下之一:completed、partially completed、failed、blocked、
- still awaiting verification;还要写明如何检查(“tests run and passing”/
- “confirmed by git diff only, tests not run”)。纳入否定结果和死路,
- 但不要夸大。
-
- ⚠️ 绝不要停留在叙事层。“The user tried X and hit error Y; no solution found
- yet”是一条浪费的记录:它容易被检索到,却不能指导未来 agent 行动。如果
- 本次确实没有得出决定,就说明排除了什么、下一条尚未探索的线索是什么——
- 这才是可复用部分。
-
- 句子的主语应是 code 和 decision,而不是“the user”。使用 2 到 4 个连贯
- 句子,不要写带标签的小节。硬上限约 400 个拉丁字符(约 200 个 CJK 字符)。
-
- EVIDENCE FIDELITY——强制要求:
- - 只记录 trace 中实际执行的操作和明确存在的证据。对关键 commands、flags、
- arguments、errors、numbers 保持原样。绝不要按惯例补全 command flags,
- 也不要把 advice/plans 写成已执行的动作。
- - 保留 attempted、observed、verified、inferred、unresolved 之间的区别。
- 不要把这些词作为标签写进正文;自然表达其含义,例如“tried … but was
- blocked by Access denied”或“suspect …, not yet verified”。
- - 没有工具输出或明确确认时,绝不要声称修复成功、原因已经确定、file/folder
- 不存在或 tests passed。
- - 每个否定发现都必须限定在实际搜索范围内,并逐一列出可能使其失效的所有
- 明确覆盖限制,尤其是 permission failures 和 maximum search depth:
- “not found within the searched parts of C:\\ and D:\\; some directories
- were skipped on Access denied, and the search was also depth-limited”。
- 不要为了摘要更漂亮而漏掉任何限制。绝不要把局部搜索提升为全局不存在。
- - 只有 trace 直接验证了因果关系时,才能确定地陈述因果。否则保留限定词
- (“suspected”/“inferred”/“not yet verified”);不要把错误的测试假设
- 改写成系统的 root cause。
-
- 关键——这段文字就是 retrieval vector,也是未来 query 唯一会匹配的内容。
- 泛泛摘要毫无价值,因为每次会话看起来都像泛泛摘要:它会匹配所有查询,
- 却无法回答任何一个。因此必须写出使本次会话可检索的具体 anchors——真实
- file paths、function / symbol names、branch names、commands、error strings、
- versions、config keys and values、host / service names。以后有人搜索其中任一
- 具体项时,本摘要必须能被返回。
- good: “fixing a failing `npm run build` in CI. Read
- .github/workflows/ci.yml and package.json; traced it to webpack
- 5.74 hitting ERR_OSSL_EVP_UNSUPPORTED under node 18. Bumping the
- workflow's node to 20 made the build pass; node 18 still
- reproduces locally.”
- good: “on branch feat/q0, in qutebrowser/utils/debug.py signal_name:
- PyQt<5.11 only exposes the name via repr(sig), and repr comes in
- both a bracketed and a parenthesised form. Settled on two patterns
- tried in order with fullmatch, breaking on the first hit; the
- single-regex version was dropped. Confirmed by git diff, tests not
- run.”
- bad: “user wanted a build bug fixed, the agent looked at some config
- files, changed some code, and fixed it.”
- (没有 path、command、error string、version——没有任何可检索锚点;
- 每次会话都可以写成这样)
- bad: “fixed the signal-name parsing compatibility issue on a feature
- branch.”
- (哪个 branch?哪个 file?哪个 function?两个竞争版本中谁胜出?
- 一周后检索到它时,没有任何信息仍然有用)
- 忠实度示例(bad → good):
- “ran Get-ChildItem -Force” → “ran Get-ChildItem”
- (trace 中没有 `-Force`,不要杜撰)
- “confirmed new_file_search does not exist” →
- “new_file_search was not found within the searched parts of C:\\ and
- D:\\; some directories were skipped on Access denied or by the depth
- limit, so the investigation is only partly done”
- “identical payloads cause a spurious lock error” →
- “the verification script assumed the last writer is always a fixed
- rank; that assumption does not hold, so whether there is a lock bug
- is still unverified”
-
- 不要记录问候或纯闲聊。如果该段完全没有建立任何信息,输出 "fact": null。
-
-files — 0..N 个本次会话中实际操作或调查过的绝对或 repo-relative FILE OR
- DIRECTORY paths。保留调查过的 roots,例如 `C:\\` 和 `D:\\`。只包含
- 实际访问/搜索过的路径,不包含仅建议或计划访问的路径;不适用时填写 []。
-
-═══════════════════════════════════════════════════════════════════
-HOST CONTEXT(由 SDK 提供)
-═══════════════════════════════════════════════════════════════════
-- workspace_id present: {workspace_present}
-- branch present: {branch_present}
-
-没有 workspace_id 时,solution 不能依赖未声明的项目本地上下文——必须在 `solution`
-或 `boundary_envs` 中明确写出其所需的 repo / path / service,使记忆能够独立使用。
-
-═══════════════════════════════════════════════════════════════════
-CONVERSATION
-═══════════════════════════════════════════════════════════════════
-{conversation_block}
-
-═══════════════════════════════════════════════════════════════════
-OUTPUT(仅输出严格 JSON,不要 markdown)
-═══════════════════════════════════════════════════════════════════
-{{
- "experiences": [
- {{
- "task": "...",
- "search_keys": ["...", "..."],
- "solution": "...",
- "boundary_envs": "...",
- "confidence": 0.9
- }}
- ],
- "fact": {{
- "statement": "...",
- "files": ["..."]
- }}
-}}
-
-强制要求:必须输出至少一条 experience,不要返回空列表。即使任务看似简单或一次成功,
-也要记录所做工作的可复用本质(method / command / how-to)。会话内容较少时,只需要
-最有价值的一条 experience——但绝不能输出空的 "experiences" array。
-
-"fact" 是单个对象,绝不是列表——每次会话一条记录。只有该段是没有建立任何信息的
-纯闲聊时,才使用 "fact": null。
+文本已迁到 ``hy_memory/prompts/zh_hans.py``(``CODING_*``),这里保留旧名字。
"""
-
-RECONCILE_PROMPT_ZH = """\
-你需要决定如何将新的 coding memory drafts 与用户已有的 memories 合并。
-
-对每条新 draft,选择以下一种 action:
- ADD — 没有已有 memory 描述相同的任务/方面
- UPDATE — 某条已有 memory 描述相同任务;用新 draft 替换它
- (solution 可能已经变化,env 可能已经升级,等等)
- SKIP — 与已有内容重复;没有新信息
-
-此外,当新内容使已有候选失效或作废时,可以针对已有 candidates 输出 DELETE ops:
- DELETE — 新 conversation 明确 supersedes/cancels/invalidates 某条已有 memory,
- 且无法通过 UPDATE 修复。示例:
- * 用户说“don't use X anymore”,而 X 只存在于另一条独立 memory 中
- (不是本次正在 ADD/UPDATE 的那条)
- * candidate 的 boundary_envs(service / endpoint / SDK)已经消失,
- 且新 conversation 确认其已 deprecated
-
-规则:
-- “Same task”是指已有 memory 和新 draft 都可以作为同一个未来用户查询的有效答案。
-- 如果 solution 不同,优先 UPDATE(不保留历史版本)。
-- 如果 task 和 solution 都高度一致,选择 SKIP。
-- 只有在存在明确证据表明 candidate 已 invalid/obsolete 时才 DELETE。绝不要仅仅因为
- candidate 看起来“stale”就 DELETE。
-- 产生 DELETE 时,输出的 ops 数量可以超过 drafts 数量。
-
-═══════════════════════════════════════════════════════════════════
-NEW DRAFTS
-═══════════════════════════════════════════════════════════════════
-{drafts_block}
-
-═══════════════════════════════════════════════════════════════════
-EXISTING CANDIDATES(按每条 draft 的 task similarity 检索)
-═══════════════════════════════════════════════════════════════════
-{candidates_block}
-
-═══════════════════════════════════════════════════════════════════
-OUTPUT(仅输出严格 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": "user explicitly deprecated Y"}},
- {{"draft_idx": 2, "action": "SKIP", "reason": "duplicate"}}
- ]
-}}
-
-如果没有 drafts,输出 {{"ops": []}}。
-"""
-
-
-FACT_RECONCILE_PROMPT_ZH = """\
-你负责维护 session-level WORKING FACTS。每条 statement 都概括一整段 trace/session:
-用户的任务、大致方法和结果。它不是一条 atomic claim。
-
-下面每条新的 session fact 都一定会被存储;这不是你要决定的事情。你的唯一任务是识别
-task continuation:新 session 是否在继续推进某条已有 session fact 所记录的同一个用户
-任务?如果是,就将较旧 fact 标记为 SUPERSEDE,使这些链接为该任务构成跨 session 的
-进展链。
-
-只有在存在充分证据同时满足以下条件时,才将已有 fact 标记为 superseded:
- - subjects 匹配:两条记录围绕同一个实体——同一个 person、同一个 file/module、
- 同一个 host/service。subject 相同是必要条件,但不是充分条件;并且
- - 用户目标在实质上相同,而不只是处于同一 topic/project;并且
- - 新 trace 在继续、重试、扩展、验证或完成已有 trace 所记录的工作。
-
-以下情况不要 supersede:
- - 两条记录的 subjects 不同。同一 group 中的两个人、同一 module 中的两个 files、
- 同一 cluster 中的两个 hosts 是并行关系,不是先后关系:一个人的状态不是另一个人
- 状态的新版本。如果 subject 显示为 (unspecified),退回到只根据 statement 判断。
- - 两次 session 只是提到了相同 file、symbol、component、repository、error 或
- technology,但追求不同的用户目标。
- - 一个任务只是为另一个任务提供 context 或 technique。
- - 关系不确定。应保守判断:INSERT 是安全默认值;合并无关 session 会毁掉它们各自
- 独立的任务历史。
-
-把每条 statement 当作有证据边界的文本。不要把其中的 inference 重新解释为已经确定的
-cause,也不要把共同的 conjecture/error 当作用户目标相同的证据。你的判断仅涉及 task
-continuation;不要“纠正”、补全或润色任何一条 session 记录。
-
-示例:
- existing: “需要修复 CI 的 npm run build;已追踪到 Node 18 下的
- ERR_OSSL_EVP_UNSUPPORTED,workflow 尚未修改。”
- new: “继续修复同一个 CI build;已将 .github/workflows/ci.yml 中的 Node
- 提升到 20,且 npm run build 通过。”
- → SUPERSEDE
-
- existing: “需要修复 auth/middleware.ts 中的 JWT expiry handling;已添加
- refresh logic。”
- new: “需要在 auth/middleware.ts 中添加 performance logging;已引入
- latency metric。”
- → 两者都保留
- (同一 file/project,不同用户目标)
-
-═══════════════════════════════════════════════════════════════════
-NEW SESSION FACTS
-═══════════════════════════════════════════════════════════════════
-{drafts_block}
-
-═══════════════════════════════════════════════════════════════════
-EXISTING SESSION FACTS(按每条新 fact 的 statement similarity 检索)
-═══════════════════════════════════════════════════════════════════
-{candidates_block}
-
-═══════════════════════════════════════════════════════════════════
-OUTPUT(仅输出严格 JSON,不要 markdown)
-═══════════════════════════════════════════════════════════════════
-{{
- "ops": [
- {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "continues the same CI fix task"}},
- {{"draft_idx": 1, "supersedes": []}}
- ]
-}}
-
-只能使用同一个 draft_idx 的 candidate list 中实际出现的 fact ids。
-如果任何位置都没有 fact 被 superseded,输出 {{"ops": []}}。
-"""
-
-
-CHAIN_SUMMARY_PROMPT_ZH = """\
-working-memory store 中的某个用户任务已跨多个 sessions 推进。下面是该任务进展链中的
-session summaries,按从最早到最新排列,最后一条是当前 session。
-
-总结同一个任务如何跨 sessions 推进到当前状态。按时间顺序覆盖每个重要阶段。对每个
-阶段,在有信息时保留:实际 action 或 change、其 direct result,以及任何 unresolved
-issue 或 limiting condition。最后明确写出当前状态。
-
-规则:
- - 这只是压缩。只能报告 entries 实际陈述的内容;绝不要新增或补全 command、cause、
- motive、action、test result、success state 或 global negative conclusion。
- - 精确保留证据状态:attempted 不等于 completed,observed 不等于 verified,inferred
- 不等于 established,unresolved 必须保持 unresolved。保留 uncertainty words 以及
- search/permission/coverage limits。
- - 忠实陈述当前结束状态(completed、partially completed、failed、blocked 或
- still awaiting verification)。绝不要因为某个看似合理的因果故事,或后续 entry
- 并未验证的内容而提升状态。
- - 如果 entries 提到 suspected cause 和后续 result,只有某条 entry 直接说明该 cause
- 已被 verified 时,才可在两者之间建立因果联系。
- - 保留具体 retrieval anchors:file paths、symbols、commands、error strings、versions、
- config keys/values,以及对进展重要的 numeric values。
- - 对 2-3 代的 chains,不要把进展过度压缩成一句话。适合时优先使用 2-4 个紧凑段落,
- 或使用可读性良好的 prose,清楚呈现 task goal、逐阶段 progression 和 current status。
- - 不要机械复制完整 history。在保留重要 actions、direct results 和 leftovers 的同时,
- 省略重复及低价值细节。
- - 不要杜撰 stage headings 或 dates。只有 entries 使日期有实际意义时才提及日期;
- 单独的 timestamps 是噪声。
- - 如果 entries 说明更早 revisions 已被省略,必须明确指出 earlier history was omitted;
- 不要暗示所提供的 entries 是完整历史。
- - 使用与 entries 相同的语言。
- - 不要写前言,也不要用引号包裹输出。
-
-示例
- entries:
- (2026-07-20) 需要修复 CI 的 npm run build;已追踪到 Node 18 下的
- ERR_OSSL_EVP_UNSUPPORTED,workflow 尚未修改。
- (2026-07-24) 继续修复同一个 CI 问题;已将 .github/workflows/ci.yml 中的 Node
- 提升到 20,但 dependency cache 仍复现旧错误。
- (now) 继续验证同一修复;清除 npm cache 后,npm run build 通过。
- output:
- 任务目标是修复 CI 的 npm run build。最初将问题追踪到 Node 18 下的
- ERR_OSSL_EVP_UNSUPPORTED,当时尚未修改 workflow;随后将
- .github/workflows/ci.yml 提升到 Node 20,但 dependency cache 仍使旧错误继续
- 出现。最后,清除 npm cache 后 npm run build 通过,因此该 build 修复目前已验证完成。
-
-═══════════════════════════════════════════════════════════════════
-ENTRIES
-═══════════════════════════════════════════════════════════════════
-{chain_block}
-
-═══════════════════════════════════════════════════════════════════
-OUTPUT(只输出 summary 本身,不要其他内容)
-═══════════════════════════════════════════════════════════════════
-"""
+from ..prompts.zh_hans import ( # noqa: F401
+ CODING_CHAIN_SUMMARY_PROMPT as CHAIN_SUMMARY_PROMPT_ZH,
+ CODING_EXTRACT_PROMPT as EXTRACT_PROMPT_ZH,
+ CODING_EXTRACT_PROMPT_CODING as EXTRACT_PROMPT_CODING_ZH,
+ CODING_FACT_RECONCILE_PROMPT as FACT_RECONCILE_PROMPT_ZH,
+ CODING_RECONCILE_PROMPT as RECONCILE_PROMPT_ZH,
+)
diff --git a/hy_memory/coding/reconciler.py b/hy_memory/coding/reconciler.py
index 7cfff82..59a506a 100644
--- a/hy_memory/coding/reconciler.py
+++ b/hy_memory/coding/reconciler.py
@@ -21,7 +21,12 @@ from typing import Any, Dict, List, Optional, Tuple
from ..agent.llm_provider import LLMProvider
from ..core.embed_service import EmbedService
-from ..utils.lang_detect import is_chinese
+from ..prompts import (
+ get_prompt,
+ normalize_language,
+ resolve_language,
+ with_output_language,
+)
from .judge import _store_coding_log
from .store import CodingMemoryStore
from .types import CodingMemory, CodingMemoryDraft, ReconcileOp
@@ -50,57 +55,7 @@ def _resolve_configured_temperature(llm_provider) -> Optional[float]:
# Prompt
# ================================================================
-RECONCILE_PROMPT = """\
-You decide how to merge new coding memory drafts with the user's existing memories.
-
-For each new draft, decide one of:
- ADD — no existing memory describes the same task/aspect
- UPDATE — an existing memory describes the same task; the new draft replaces it
- (solution may have changed, env may have upgraded, etc.)
- SKIP — duplicate of existing; nothing new
-
-Additionally, you may emit DELETE ops on existing candidates when the new
-content makes them obsolete or invalid:
- DELETE — the new conversation EXPLICITLY supersedes/cancels/invalidates an
- existing memory that cannot be repaired via UPDATE. Examples:
- * user says "don't use X anymore" and X is only present as a
- separate memory (not the one being added/updated)
- * candidate's boundary_envs (service / endpoint / SDK) is gone
- and the new conversation confirms the deprecation
-
-Rules:
-- "Same task" means the existing memory and the new draft would both be valid
- answers to the same future user query.
-- If solution differs, prefer UPDATE (we don't keep history).
-- If both task and solution match closely, SKIP.
-- DELETE only when there is EXPLICIT evidence the candidate is invalid/obsolete.
- Never DELETE just because a candidate looks "stale".
-- Output ops can outnumber drafts when DELETEs are produced.
-
-═══════════════════════════════════════════════════════════════════
-NEW DRAFTS
-═══════════════════════════════════════════════════════════════════
-{drafts_block}
-
-═══════════════════════════════════════════════════════════════════
-EXISTING CANDIDATES (per draft, retrieved by task similarity)
-═══════════════════════════════════════════════════════════════════
-{candidates_block}
-
-═══════════════════════════════════════════════════════════════════
-OUTPUT (strict JSON only, no 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": "user explicitly deprecated Y"}},
- {{"draft_idx": 2, "action": "SKIP", "reason": "duplicate"}}
- ]
-}}
-
-If there are no drafts, output {{"ops": []}}.
-"""
+from ..prompts.en import CODING_RECONCILE_PROMPT as RECONCILE_PROMPT # noqa: E402,F401 (re-export)
def _drafts_language_text(drafts: List[CodingMemoryDraft]) -> str:
@@ -119,24 +74,23 @@ def _drafts_language_text(drafts: List[CodingMemoryDraft]) -> str:
def build_experience_reconcile_prompt(
drafts: List[CodingMemoryDraft],
candidates_per_draft: List[List[CodingMemory]],
+ language: Optional[str] = None,
) -> Tuple[str, str]:
- """Return the language-matched experience reconcile prompt and language."""
+ """Return the experience reconcile prompt and its language code.
+
+ Explicit ``language`` wins; otherwise zh/en auto-detection over the drafts.
+ """
drafts_block = CodingMemoryReconciler._format_drafts(drafts)
candidates_block = CodingMemoryReconciler._format_candidates(
drafts, candidates_per_draft,
)
- if is_chinese(_drafts_language_text(drafts)):
- from .prompts_zh import RECONCILE_PROMPT_ZH
-
- template = RECONCILE_PROMPT_ZH
- language = "zh"
- else:
- template = RECONCILE_PROMPT
- language = "en"
- return template.format(
+ explicit = normalize_language(language)
+ code = resolve_language(explicit, _drafts_language_text(drafts))
+ prompt = get_prompt("CODING_RECONCILE_PROMPT", code).format(
drafts_block=drafts_block,
candidates_block=candidates_block,
- ), language
+ )
+ return with_output_language(prompt, code, explicit=explicit is not None), code
# ================================================================
@@ -186,6 +140,7 @@ class CodingMemoryReconciler:
user_id: str = "",
agent_id: str = "default_agent",
session_id: str = "",
+ language: Optional[str] = None,
) -> List[ReconcileOp]:
"""
执行 reconcile + 持久化。返回执行的 ReconcileOp[](含成功执行的 ADD/UPDATE/DELETE/SKIP)。
@@ -214,7 +169,7 @@ class CodingMemoryReconciler:
_decide_resp = None
try:
ops, _decide_prompt, _decide_raw, _decide_resp = await self._llm_decide(
- drafts, candidates_per_draft
+ drafts, candidates_per_draft, language=language,
)
except Exception as e:
logger.warning(f"[coding-reconcile] LLM decide failed, fallback to ADD-all: {e}")
@@ -311,9 +266,12 @@ class CodingMemoryReconciler:
self,
drafts: List[CodingMemoryDraft],
candidates_per_draft: List[List[CodingMemory]],
+ language: Optional[str] = None,
) -> Tuple[List[ReconcileOp], str, str, Any]:
"""返回 (ops, prompt, raw_response, llm_resp),供上层打 CODING_RECONCILE log。"""
- prompt, _ = build_experience_reconcile_prompt(drafts, candidates_per_draft)
+ prompt, _ = build_experience_reconcile_prompt(
+ drafts, candidates_per_draft, language=language,
+ )
resp = await self.llm_provider.complete(
prompt=prompt,
diff --git a/hy_memory/coding/writer.py b/hy_memory/coding/writer.py
index f4afcd3..77d9aae 100644
--- a/hy_memory/coding/writer.py
+++ b/hy_memory/coding/writer.py
@@ -81,10 +81,13 @@ class CodingWriter:
request_id: Optional[str] = None,
source: str = "default",
memory_at: Optional[datetime] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""
working/coding 段写入端到端。memory_at 是对话时间,记到这次写出的经验和
- 事实上;不传则用收到请求的时间(与 chat 链路一致)。返回响应 dict(兼容 client.add 返回结构):
+ 事实上;不传则用收到请求的时间(与 chat 链路一致)。language 是显式 prompt
+ 语言码,透传给抽取、经验 reconcile、事实 reconcile 与演变总结;None 时各步
+ 沿用 zh/en 自动检测。返回响应 dict(兼容 client.add 返回结构):
{
"success": True,
"scene": "productivity",
@@ -151,6 +154,7 @@ class CodingWriter:
branch=branch,
session_id=session_id,
request_id=request_id,
+ language=language,
)
finally:
# 历史服务于下一次 write;即使本次没跨过价值门槛,也不能丢掉上下文。
@@ -187,6 +191,7 @@ class CodingWriter:
user_id=user_id,
agent_id=agent_id,
session_id=session_id or "",
+ language=language,
)
if drafts else []
)
@@ -204,6 +209,7 @@ class CodingWriter:
branch=branch,
source=source,
memory_at=memory_at,
+ language=language,
)
experience_ids = [op.target_experience_id for op in ops
diff --git a/hy_memory/config.py b/hy_memory/config.py
index 828f0e7..cfea7e0 100644
--- a/hy_memory/config.py
+++ b/hy_memory/config.py
@@ -1264,6 +1264,12 @@ class MemoryConfig:
enable_agent: bool = False
debug: bool = False
metrics_enabled: bool = True
+ # LLM prompt 语言(client 默认值;env: MEMORY_LANGUAGE)。canonical 码见
+ # hy_memory.prompts.SUPPORTED_LANGUAGES(en / zh-Hans / zh-Hant / ja / es / de /
+ # pt / fr / ko / ru / id),也接受别名 zh、zh-CN → zh-Hans,zh-TW、zh-HK →
+ # zh-Hant,pt-BR → pt。add() 等的 per-call language 优先于它。None(默认)=
+ # 沿用 zh/en 自动检测。显式指定时记忆正文用该语言书写。未知码抛 ValueError。
+ language: Optional[str] = None
# Runtime-only HTTP transport factory. MemHub uses this for request-cost
# budgeting without restricting the embedded SDK's local store access.
http_transport_factory: Optional[Callable[[], Any]] = field(
@@ -1278,6 +1284,11 @@ class MemoryConfig:
self.enable_agent = _get_env_bool("MEMORY_ENABLE_AGENT", False)
self.debug = _get_env_bool("MEMORY_DEBUG", False)
self.metrics_enabled = _get_env_bool("MEMORY_METRICS", True)
+ if self.language is None:
+ self.language = os.getenv("MEMORY_LANGUAGE", "").strip() or None
+ from .prompts import normalize_language
+
+ self.language = normalize_language(self.language)
@classmethod
def from_env(cls) -> "MemoryConfig":
@@ -1328,6 +1339,10 @@ class MemoryConfig:
config.metrics_enabled = config_dict.get(
"metrics_enabled", config.metrics_enabled
)
+ if config_dict.get("language") is not None:
+ from .prompts import normalize_language
+
+ config.language = normalize_language(config_dict["language"])
return config
@@ -1386,6 +1401,7 @@ class MemoryConfig:
"enable_graph": self.enable_graph,
"enable_agent": self.enable_agent,
"metrics_enabled": self.metrics_enabled,
+ "language": self.language,
}
def print_config(self) -> None:
diff --git a/hy_memory/pipelines/_graph/topic_summary.py b/hy_memory/pipelines/_graph/topic_summary.py
index c18fbfa..e53debc 100644
--- a/hy_memory/pipelines/_graph/topic_summary.py
+++ b/hy_memory/pipelines/_graph/topic_summary.py
@@ -64,59 +64,15 @@ def _topic_lock(graph_store, isolation_key: str, topic_id: str) -> asyncio.Lock:
return lock
-TOPIC_SUMMARY_PROMPT = """You are summarizing everything known about ONE topic.
-
-## Topic
-
-{topic_name}
-
-## Memories under this topic (oldest → newest)
-
-{memories}
-
----
-
-Write a single dense summary of what is known about the user with respect to this
-topic.
-
-Rules:
-
-* 2–4 sentences, third person, starting with "The user ..." (or the named person
- if the memories are about someone else).
-* Cover the topic as a whole — state the current situation, and mention how it
- developed only when the change matters.
-* Preserve concrete details: names, places, numbers, dates.
-* Do NOT invent anything that is not in the memories.
-* Do NOT enumerate the memories one by one; synthesize them.
-* Output language must match the language of the memories.
-
-Return ONLY the summary text, no preamble, no JSON, no quotes."""
-
-
-TOPIC_SUMMARY_PROMPT_ZH = """你在为**一个主题**总结已知的全部信息。
-
-## 主题
-
-{topic_name}
-
-## 该主题下的记忆(时间正序)
-
-{memories}
-
----
-
-写一段关于用户在这个主题上的高密度摘要。
-
-要求:
-
-* 2–4 句,第三人称,以"用户…"开头(若记忆讲的是别人,则以那个人的名字开头)。
-* 覆盖整个主题 —— 说明当前状况;只在变化本身重要时才提它是怎么演变过来的。
-* 保留具体细节:人名、地点、数字、日期。
-* 绝不编造记忆里没有的内容。
-* 不要逐条罗列记忆,要综合成一段。
-* 输出语言与记忆的语言一致。
-
-只返回摘要正文,不要任何前言、不要 JSON、不要引号。"""
+# 多语言版本见 hy_memory/prompts/<language>.py;旧名字保留为别名。
+from ...prompts import ( # noqa: E402
+ get_prompt,
+ normalize_language,
+ resolve_language,
+ with_output_language,
+)
+from ...prompts.en import TOPIC_SUMMARY_PROMPT # noqa: E402,F401 (re-export)
+from ...prompts.zh_hans import TOPIC_SUMMARY_PROMPT as TOPIC_SUMMARY_PROMPT_ZH # noqa: E402,F401 (re-export)
async def find_latest_topic_summary(
@@ -193,9 +149,13 @@ async def maybe_summarize_topics(
max_concurrency: int = 3,
temperature: Optional[float] = None,
trace=None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""对本次写入触达的 Topic,按需有界并发生成 / 刷新 summary。
+ language 为显式 prompt 语言码(随触发本次写入的请求);None 时按记忆内容
+ 做 zh/en 自动检测。
+
触发条件:Topic 下 active 记忆数 ≥ `min_memories`,且比上次总结时多了 ≥ `step` 条。
这样既不会每写一条就重算(贵),也不会一直不更新(陈旧)。
@@ -254,6 +214,7 @@ async def maybe_summarize_topics(
topic_name=topic_names.get(topic_id) or topic_id,
memories=[m.get("content") or "" for m in mems],
temperature=temperature,
+ language=language,
)
if trace is not None:
await trace(
@@ -317,15 +278,18 @@ async def maybe_summarize_topics(
async def _generate(
*, llm_provider, topic_name: str, memories: List[str],
temperature: Optional[float] = None,
+ language: Optional[str] = None,
) -> tuple:
"""返回 (摘要文本, 实际 prompt, token 用量) —— 后两个供埋点,线上要能复盘。"""
- from ...utils.lang_detect import is_chinese
-
body = "\n".join(f"- {c}" for c in memories if c)
if not body:
return "", "", {}
- tpl = TOPIC_SUMMARY_PROMPT_ZH if is_chinese(body) else TOPIC_SUMMARY_PROMPT
- prompt = tpl.format(topic_name=topic_name, memories=body)
+ explicit = normalize_language(language)
+ code = resolve_language(explicit, body)
+ prompt = get_prompt("TOPIC_SUMMARY_PROMPT", code).format(
+ topic_name=topic_name, memories=body,
+ )
+ prompt = with_output_language(prompt, code, explicit=explicit is not None)
resp = await llm_provider.complete(
prompt=prompt,
max_tokens=400,
diff --git a/hy_memory/pipelines/base.py b/hy_memory/pipelines/base.py
index 427f3a3..f6ae3c8 100644
--- a/hy_memory/pipelines/base.py
+++ b/hy_memory/pipelines/base.py
@@ -95,21 +95,48 @@ class ToolCall:
# [John]: 我也喜欢茶
# 名字单独占一行、整段只出现一次;[user] 标签**不换成名字**,视角信息留在标签里。
# extract 用这一行给 L0 basic_info 取 name(用户不必在对话里自报姓名)。
+# 各语言的模板在 hy_memory/prompts/<language>.py 的 USER_NAME_LINE;这两个旧名字保留。
_USER_NAME_LINE_ZH = "用户名叫{name}"
_USER_NAME_LINE_EN = "The user's name is {name}"
-_USER_NAME_LINE_RE = re.compile(
- r"^(?:用户名叫|The user's name is)\s*(.+?)\s*$"
-)
+_user_name_line_res: Optional[List["re.Pattern"]] = None
-def render_user_name_line(name: str, is_zh: bool) -> str:
- """渲染文首的用户名字行;name 为空返回空串。"""
+def _user_name_line_patterns() -> List["re.Pattern"]:
+ """每种语言一个匹配名字行的正则(L1_RAW 里可能存着任意语言的名字行)。"""
+ global _user_name_line_res
+ if _user_name_line_res is None:
+ from ..prompts import SUPPORTED_LANGUAGES, get_prompt
+
+ patterns = []
+ for code in SUPPORTED_LANGUAGES:
+ try:
+ tpl = get_prompt("USER_NAME_LINE", code)
+ except (ImportError, AttributeError):
+ continue
+ prefix, _, suffix = tpl.partition("{name}")
+ patterns.append(re.compile(
+ r"^" + re.escape(prefix.strip()) + r"\s*(.+?)\s*"
+ + re.escape(suffix.strip()) + r"$"
+ ))
+ _user_name_line_res = patterns
+ return _user_name_line_res
+
+
+def render_user_name_line(
+ name: str, is_zh: bool = False, *, language: Optional[str] = None,
+) -> str:
+ """渲染文首的用户名字行;name 为空返回空串。
+
+ language(语言码)优先;未给时按 is_zh 在 zh-Hans / en 间选(旧行为)。
+ """
name = (name or "").strip()
if not name:
return ""
- tpl = _USER_NAME_LINE_ZH if is_zh else _USER_NAME_LINE_EN
- return tpl.format(name=name)
+ from ..prompts import get_prompt
+
+ code = language or ("zh-Hans" if is_zh else "en")
+ return get_prompt("USER_NAME_LINE", code).format(name=name)
def parse_user_name_line(line: str) -> Optional[str]:
@@ -118,8 +145,12 @@ def parse_user_name_line(line: str) -> Optional[str]:
L1_RAW 存的就是 get_flat_content() 的产物,回读历史时要靠这个把名字行识别出来,
否则它会被当成一条无前缀的裸消息(见 MemoryWriter._get_recent_history)。
"""
- m = _USER_NAME_LINE_RE.match((line or "").strip())
- return m.group(1) if m else None
+ text = (line or "").strip()
+ for pattern in _user_name_line_patterns():
+ m = pattern.match(text)
+ if m:
+ return m.group(1)
+ return None
@dataclass
@@ -257,6 +288,11 @@ class WriteRequest:
branch: Optional[str] = None
# 分支名。同 workspace_id。
+ # 显式 prompt 语言码(canonical,见 hy_memory.prompts.SUPPORTED_LANGUAGES)。
+ # 由 client 入口按「per-call > MemoryConfig.language」解析后注入;None 时
+ # 抽取 / reconcile / 画像等各步沿用 zh/en 自动检测。
+ language: Optional[str] = None
+
# ---- 便捷方法 ----
def has_messages(self) -> bool:
@@ -286,8 +322,8 @@ class WriteRequest:
[John]: 我也喜欢茶
无 name 时与历史行为完全一致(`[user]: ...` / `[assistant]: ...`)。
- 名字行只在 role=user 带 name 时出现,且整段只出现一次;语言按消息内容判定
- (与 extractor 选 zh/en prompt 同一套判据)。
+ 名字行只在 role=user 带 name 时出现,且整段只出现一次;语言取显式
+ language,未指定时按消息内容判定(与 extractor 选 zh/en prompt 同一套判据)。
"""
if not self.messages:
return self.content or ""
@@ -296,11 +332,14 @@ class WriteRequest:
name = self.user_name()
if name:
- from ..utils.lang_detect import is_chinese
-
- name_line = render_user_name_line(
- name, is_chinese(messages=self.messages)
- )
+ if self.language:
+ name_line = render_user_name_line(name, language=self.language)
+ else:
+ from ..utils.lang_detect import is_chinese
+
+ name_line = render_user_name_line(
+ name, is_chinese(messages=self.messages)
+ )
if name_line:
lines.insert(0, name_line)
diff --git a/hy_memory/pipelines/system2_agent.py b/hy_memory/pipelines/system2_agent.py
index 2ace7a8..11eaad9 100644
--- a/hy_memory/pipelines/system2_agent.py
+++ b/hy_memory/pipelines/system2_agent.py
@@ -979,171 +979,16 @@ def s2_agent_skip_reason(materials: Dict[str, Any]) -> Optional[str]:
return None
# ====================================================================
-# System Prompt (dual language)
+# System Prompt (multilingual: hy_memory/prompts/<language>.py)
# ====================================================================
-SYSTEM2_AGENT_PROMPT_ZH = """你是一个认知加工 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(洞察)**:底层心理驱动力或心智模型。
-
-### 内容格式
-行为模式用一句话组合三要素:
-"当[场景]时,用户[模式]——反映了[洞察]。"
-
-对与情绪、治疗、压力、哀伤或创伤有关的长期模式,不要把具体人生背景压缩成
-空泛人格词。优先保留这三部分:
-"Trigger/background(持久触发背景) → emotional response(反复情绪反应) → observed coping resource(用户已实际使用的应对资源)。"
-只能写入 user-owned 证据中出现的触发背景、反应和应对方式;助手建议不是用户已观察到的应对资源。
-
-### 规则
-- **原子化**:一个 Schema 只包含一个模式。两个不同模式 → 两个 Schema。
-- **不可变**:Schema 创建后内容永远不变。不要修改已有 Schema 的内容。
-- **累积证据**:新事实只是在支持已有表述 → 调 `add_evidence`。如果新证据会让旧画像的当前状态产生实质遗漏、错误或误导,使用 `revise_schema` 创建新版本,让旧版本保留审计但退出 active 检索。
-- **域内约束**:不要跨域。跨域抽象由系统的其他流程处理。
-- **事实与模式分层**:单条明确身份、健康状态、设备使用、隶属关系、项目或偏好属于 L2 状态,不创建 L6。L6 必须由至少两个独立 raw/session 中的 user-owned 证据支持。
-- **主体安全**:同一原始写入可能包含他人资料或示例。只有材料明确归因于当前用户时才创建用户 Schema;否则对该材料不执行任何操作。
-- **候选覆盖**:source-context 审查时,每条候选事实必须二选一:用于 `create_schema`/`add_evidence` 的 evidence,或用 `skip_fact` 明确跳过。原始上下文只用于确认主体或补回该事实遗漏的细节,不得据此创建无关 Schema。
-- **证据门槛**:创建 L6 必须有 user-owned evidence,且这些证据合计代表至少两个独立 raw/session。
- 一个被 S1 合并的 L2 事实可以代表多次独立写入,应检查它的 `source_raw_memory_ids`,不要只数节点。
- 助手建议不能作为用户模式的独立证据。
-
-## 工作流程
-
-输入材料分两部分(仅当已形成聚类时才会调用你):
-- **聚类结果(Cluster Results)**:主输入,按语义相似度归组的事实
-- **未聚类事实(补充)**:未进入任一聚类的事实,优先级低于聚类结果,酌情审视即可
-
-对于每组事实(无论聚类还是未聚类):
-1. **搜索已有 Schema**:如果已有 Schema 已覆盖该模式,使用 `add_evidence`。只有加入新证据后旧表述会产生实质遗漏、错误或误导时才使用 `revise_schema`。
-2. **创建新 Schema**:仅当没有已有 Schema 覆盖时。一句话,三要素。
-3. **建立关系**:两个 Schema 主题相关 → 用 `add_edge`(RELATED_TO)。
-
-## 原则
-
-- 所有 Graph 操作必须通过 tools 执行
-- Schema 内容创建后不可变——绝不重新创建已存在的 Schema
-- 优先 `add_evidence` 而非创建重复节点
-- 宁可不创建,也不要创建低质量节点
-- 一个 Schema = 一个域内原子模式
-- 打标签时优先使用已有标签列表中的标签"""
-
-
-SYSTEM2_AGENT_PROMPT_EN = """You are a cognitive processing Agent. Your job is to evolve higher-order cognitive structures from a user's raw memory data.
-
-## Memory Architecture
-
-### VDB (Vector Database) — read-only
-| Layer | Description |
-|-------|-------------|
-| L0 BASIC_INFO | User attributes (name, age, occupation) |
-| L1 RAW | Original conversation transcripts |
-| L2 FACT | Atomic facts extracted from conversations |
-| L3 SUMMARY | Session summaries |
-| L4 IDENTITY | Identity traits, preferences, habits |
-| L5 KNOWLEDGE | Domain knowledge |
-
-### Graph (Knowledge Graph) — you are the sole writer
-| Layer | Description |
-|-------|-------------|
-| L6 SCHEMA | Behavioral patterns — domain-bound, atomic, immutable once created |
-
-## What is an L6 Schema?
-
-A Schema is one cross-event behavioral pattern in the long-term user model and
-contains the following three components:
-
-
-- **Circumstance**: The domain/topic/situation where this pattern is observed. A Schema MUST stay within its circumstance — do NOT generalize across domains. Cross-domain abstraction is handled separately by the system.
-- **Pattern**: The user's habitual behavior, thinking style, or action tendency in this circumstance.
-- **Insight**: The underlying psychological driver or mental model.
-
-### Content format
-Use a single sentence combining all three:
-"When [circumstance], the user [pattern] — reflecting [insight]."
-
-For durable emotional, therapy, stress, grief, or trauma-related patterns, do
-not erase the specific autobiographical background into a generic personality
-label. Prefer an anchored structure that preserves:
-"Trigger/background -> recurring emotional response -> observed coping resource."
-Only include triggers, responses, and coping resources present in user-owned
-evidence. Assistant advice is not an observed user coping resource.
-
-### Rules
-- **Atomic**: One pattern per Schema. Two distinct patterns → two Schemas.
-- **Immutable**: Once created, content NEVER changes.
-- **Evidence only**: New facts that merely support existing wording → call
- `add_evidence`. If new evidence materially changes, corrects, or narrows the
- current durable state, use `revise_schema` so the old version is retained for
- audit but removed from active retrieval.
-- **Domain-bound**: Stay within the observed domain. Cross-domain abstraction is handled by a separate system process.
-- **Separate facts from patterns**: A single explicit identity, health state,
- equipment use, affiliation, project, or preference belongs in L2 state memory,
- not L6. L6 requires user-owned evidence representing at least two independent
- raw writes or sessions. One reconciled L2 fact may represent multiple writes;
- inspect its source_raw_memory_ids rather than counting fact nodes.
-- **Subject safety**: Facts sharing a source chunk may describe other people or
- examples. Create a user Schema only when the material explicitly attributes
- the pattern to the user. Otherwise output no operation for that material.
-- **Candidate coverage**: In a source-context review, account for every listed
- candidate fact: either use it as evidence in `create_schema`/`add_evidence`,
- or emit `skip_fact`. Raw context may confirm its subject or restore omitted
- detail, but must not seed unrelated Schemas.
-- **Evidence threshold**: Creating L6 requires one or more user-owned evidence
- facts representing at least two independent raw writes or sessions.
- Assistant advice does not establish a user pattern by itself.
-
-### Good vs Bad examples
-✅ "When cooking, the user strictly follows recipe steps and precisely measures ingredients — reflecting a need for external structure to manage uncertainty."
-✅ "When gaming, the user always checks walkthroughs to achieve 100% completion — driven by low tolerance for incompleteness."
-✅ "After an unexpected mentor loss, mortality reminders can bring grief back suddenly; the user pauses to reflect and takes quiet walks to regain steadiness."
-❌ "The user approaches music as a medium for creative synthesis and cultural bridge-building, consistently blending diverse musical traditions..." (multiple patterns merged, too broad)
-❌ "The user is passionate about many things and values quality." (no circumstance, too vague)
-❌ "The user is meaning-driven and resilient." (erases the durable trigger and observed coping evidence)
-
-## Your Workflow
-
-Input materials (you are only invoked when at least one cluster exists):
-- **Cluster Results**: Primary input — facts grouped by semantic similarity
-- **Unclustered Facts (supplemental)**: Facts not in any cluster; lower priority than cluster results
-
-For each group of facts (clustered or unclustered):
-1. **Search existing Schemas**: If an existing Schema already captures this pattern, call `add_evidence`. Use `revise_schema` only when the old wording would become materially incomplete or misleading after adding the new evidence.
-2. **Create new Schema**: Only if no existing Schema covers this pattern. One sentence, three components.
-3. **Build relationships**: If two Schemas are thematically related, use `add_edge` (RELATED_TO).
-
-## Principles
-
-- All Graph operations MUST go through tools
-- Schema content is IMMUTABLE — never recreate what already exists
-- Prefer `add_evidence` over creating duplicates
-- Prefer not creating over creating low-quality nodes
-- One Schema = one atomic pattern in one domain
-- When tagging, prefer reusing tags from the existing tags list"""
+from ..prompts import ( # noqa: E402
+ get_prompt,
+ normalize_language,
+ with_output_language,
+)
+from ..prompts.zh_hans import SYSTEM2_AGENT_PROMPT as SYSTEM2_AGENT_PROMPT_ZH # noqa: E402,F401 (re-export)
+from ..prompts.en import SYSTEM2_AGENT_PROMPT as SYSTEM2_AGENT_PROMPT_EN # noqa: E402,F401 (re-export)
# backward compat alias
SYSTEM2_AGENT_PROMPT = SYSTEM2_AGENT_PROMPT_ZH
@@ -2095,10 +1940,14 @@ async def run_system2_agent(
tool_executor: System2ToolExecutor,
config: MemoryConfig,
max_iterations: int = 10, # kept for backward compat, unused in single-call mode
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""
Phase 2: System 2 Agent — Single LLM call + JSON output + post-process execution.
+ ``language``: explicit prompt language code (overrides config.language);
+ None and no config default → zh/en detection over the materials.
+
Instead of multi-turn tool-calling loop, this version:
1. Puts all materials (facts + existing graph) into the prompt
2. Asks LLM to output a JSON array of operations
@@ -2120,9 +1969,17 @@ async def run_system2_agent(
# Build LLMProvider from config
llm_provider = LLMProvider(config)
- # Detect language from materials content
- lang = _detect_language(materials)
- system_prompt = _build_single_call_system_prompt(lang)
+ # Prompt language: explicit language (evolve(language=...) or
+ # MemoryConfig.language) wins; otherwise detect zh/en from the materials.
+ explicit_language = normalize_language(language) or normalize_language(
+ getattr(config, "language", None)
+ )
+ lang = explicit_language or _s2_language_code(_detect_language(materials))
+ system_prompt = with_output_language(
+ _build_single_call_system_prompt(lang),
+ lang,
+ explicit=explicit_language is not None,
+ )
user_msg = _build_materials_message(materials, lang=lang)
messages = [
@@ -2393,101 +2250,30 @@ async def run_system2_agent(
}
-def _build_single_call_system_prompt(lang: str) -> str:
- """Build system prompt for single-call mode (includes output format instructions)."""
- base = SYSTEM2_AGENT_PROMPT_ZH if lang == "zh" else SYSTEM2_AGENT_PROMPT_EN
-
+def _s2_language_code(lang: str) -> str:
+ """旧的 "zh" / "en" 标记映射到语言码;其余值按语言码处理。"""
if lang == "zh":
- output_instructions = """
-
-## 输出格式
-
-不要调用 tools。直接输出一个 JSON 数组,包含你决定执行的操作。用 ```json 代码块包裹。
-
-可用操作:
-
-1. **create_schema** — 创建新的 L6 行为 Schema
- ```{"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** — 新证据使已有 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": "关系原因"}```
+ return "zh-Hans"
+ return lang or "en"
-5. **skip_fact** — 明确标记某条候选事实已审查但不创建 Schema。仅用于他人事实、临时事件、不能证明用户特征的助手建议,或已被现有 Schema 完整覆盖的事实。
- ```{"op": "skip_fact", "node_id": "candidate_fact_id", "reason": "不是稳定的用户模式"}```
-## 输出约定
-
-1. 输出必须是 JSON 数组,用 ```json 代码块包裹。
-2. 如果数据不足以得出可靠结论,输出 `[]`。在 source-context review 中,
- `[]` 表示已审查该组全部候选,且都不足以支持稳定 Schema。
-3. 代码块外不要有任何其他文字。
-4. evidence_list 中的 id 必须来自材料中提供的 fact node_id。
-5. add_evidence / revise_schema 的 node_id 必须来自已有 Graph 节点的 id。
-6. 对 source-context 审查,必须让每条候选事实出现在 evidence_list 或 skip_fact 中。"""
- else:
- output_instructions = """
-
-## Output Format
-
-Do NOT call tools. Output a JSON array of operations directly, wrapped in a ```json code block.
-
-Available operations:
-
-1. **create_schema** — Create a new L6 behavioral Schema
- ```{"op": "create_schema", "schema_kind": "behavior_pattern", "content": "concise user-facing pattern", "retrieval_text": "behavior plus relevant situations", "evidence_list": ["fact_node_id_1", "fact_node_id_2"], "tags": ["tag1"]}```
-
-2. **add_evidence** — Add evidence to an existing Schema (content stays immutable)
- ```{"op": "add_evidence", "node_id": "existing_schema_node_id", "evidence_list": ["new_fact_id_1"]}```
-
-3. **revise_schema** — Create a new version when new evidence materially changes the current state and retire the old version from active retrieval. Do not use it for compatible detail.
- ```{"op": "revise_schema", "node_id": "old_schema_id", "schema_kind": "explicit_state", "content": "updated current profile", "retrieval_text": "updated retrieval text", "evidence_list": ["new_fact_id_1"], "tags": ["tag1"], "reason": "why the old wording would mislead"}```
-
-4. **add_edge** — Create a relationship between two Schemas
- ```{"op": "add_edge", "source_id": "schema_id_1", "target_id": "schema_id_2", "reason": "relationship reason"}```
-
-5. **skip_fact** — Explicitly mark a candidate fact as reviewed without creating
- a Schema. Use only for facts about another person, transient events, assistant
- advice that does not establish a user trait, or facts already fully covered.
- ```{"op": "skip_fact", "node_id": "candidate_fact_id", "reason": "not a durable user pattern"}```
-
-## Output Contract
+def _build_single_call_system_prompt(lang: str) -> str:
+ """Build system prompt for single-call mode (includes output format instructions).
-1. Output MUST be a JSON array wrapped in a ```json code block.
-2. If data is insufficient for reliable conclusions, output `[]`. In a
- source-context review, `[]` means every candidate in that review was examined
- and none supports a durable Schema.
-3. NO text outside the code block.
-4. evidence_list IDs must come from the fact node_ids provided in the materials.
-5. add_evidence / revise_schema node_id must come from existing Graph node IDs.
-6. For a source-context review, every candidate fact must appear in an evidence_list or skip_fact."""
+ ``lang`` is a language code (``en`` / ``zh-Hans`` / ``ja`` ...; legacy ``zh``
+ means zh-Hans). Every fragment comes from hy_memory/prompts/<language>.py.
+ """
+ code = _s2_language_code(lang)
+ base = get_prompt("SYSTEM2_AGENT_PROMPT", code)
+ output_instructions = get_prompt("SYSTEM2_OUTPUT_INSTRUCTIONS", code)
if _S2_SCHEMA_EVIDENCE_GATE_ENABLED:
- if lang == "zh":
- output_instructions += """
-
-7. L6 只表示跨事件行为模式。create_schema 必须使用 user-owned 证据,且证据合计代表至少两个独立 raw/session。当 `source_raw_memory_ids` 包含多个独立写入时,一个合并后的 L2 事实也可以满足门槛。
-8. 单条明确身份、健康状态、设备使用、隶属关系、项目或偏好不要创建 L6;这些由 canonical L2 状态通道维护。"""
- else:
- output_instructions += """
-
-7. L6 represents cross-event behavioral patterns only. create_schema must use user-owned evidence representing at least two independent raw writes or sessions. A single reconciled fact can qualify when source_raw_memory_ids contains multiple independent writes.
-8. Do not create L6 for a single explicit identity, health state, equipment use, affiliation, project, or preference. Canonical L2 state projection owns those facts."""
+ output_instructions += get_prompt("SYSTEM2_SCHEMA_EVIDENCE_GATE", code)
- # Remove the old "All Graph operations MUST go through tools" principle
- base = base.replace("- 所有 Graph 操作必须通过 tools 执行\n", "")
- base = base.replace("- All Graph operations MUST go through tools\n", "")
- # Remove old tool-calling instructions from workflow
- base = base.replace("调 `add_evidence` 添加证据", "使用 add_evidence 操作")
- base = base.replace("call `add_evidence`", "use add_evidence operation")
- base = base.replace("调 `add_evidence`", "使用 add_evidence")
- base = base.replace("用 `add_edge`(RELATED_TO)", "使用 add_edge 操作")
- base = base.replace("use `add_edge` (RELATED_TO)", "use add_edge operation")
+ # Remove the old "All Graph operations MUST go through tools" principle and
+ # the tool-calling wording from the workflow (single-call mode has no tools).
+ for old, new in get_prompt("SYSTEM2_SINGLE_CALL_REPLACEMENTS", code):
+ base = base.replace(old, new)
return base + output_instructions
@@ -2554,10 +2340,14 @@ def _detect_language(materials: Dict[str, Any]) -> str:
def _build_materials_message(materials: Dict[str, Any], lang: str = "zh") -> str:
- """将预处理好的 materials 格式化为 Agent 能理解的 user message"""
- is_zh = (lang == "zh")
+ """将预处理好的 materials 格式化为 Agent 能理解的 user message
- parts = [("## 预处理材料\n" if is_zh else "## Preprocessed Materials\n")]
+ ``lang`` 为语言码(旧值 "zh" 视作 zh-Hans);文案见 prompts/<language>.py 的
+ SYSTEM2_MATERIALS。
+ """
+ text = get_prompt("SYSTEM2_MATERIALS", _s2_language_code(lang))
+
+ parts = [text["title"]]
stats = materials.get("stats", {})
fresh = stats.get("fresh_facts", 0)
@@ -2566,55 +2356,35 @@ def _build_materials_message(materials: Dict[str, Any], lang: str = "zh") -> str
graph_total = stats.get("graph_total_schemas", 0)
recalled_schemas = stats.get("graph_schemas_recalled", 0)
- if is_zh:
- parts.append(f"### 统计\n- VDB 事实总数: {stats.get('total_facts_all', 0)}")
- parts.append(f"- 新鲜事实(待处理): {fresh}(已被引用排除={evidenced})")
- parts.append(f"- 聚类数: {stats.get('clusters_found', 0)}")
- parts.append(
- f"- 聚类内事实: {stats.get('clustered_facts_count', 0)},"
- f"未聚类补充: {stats.get('unclustered_facts_count', 0)}"
- )
- parts.append(f"- Graph Schema 总数: {stats.get('graph_total_schemas', 0)}(本次召回={recalled_schemas})")
- if graph_total == 0:
- parts.append("- Graph 状态: **空**(首次认知加工)\n")
- else:
- parts.append("")
+ parts.append(text["stats"].format(
+ total=stats.get('total_facts_all', 0),
+ fresh=fresh,
+ evidenced=evidenced,
+ clusters=stats.get('clusters_found', 0),
+ clustered=stats.get('clustered_facts_count', 0),
+ unclustered=stats.get('unclustered_facts_count', 0),
+ graph_total=stats.get('graph_total_schemas', 0),
+ recalled=recalled_schemas,
+ ))
+ if graph_total == 0:
+ parts.append(text["graph_status_empty"])
else:
- parts.append(f"### Statistics\n- Total VDB facts: {stats.get('total_facts_all', 0)}")
- parts.append(f"- Fresh facts (to process): {fresh} (evidenced_excluded={evidenced})")
- parts.append(f"- Clusters found: {stats.get('clusters_found', 0)}")
- parts.append(
- f"- Facts in clusters: {stats.get('clustered_facts_count', 0)}, "
- f"unclustered supplement: {stats.get('unclustered_facts_count', 0)}"
- )
- parts.append(f"- Graph Schemas total: {stats.get('graph_total_schemas', 0)} (recalled={recalled_schemas})")
- if graph_total == 0:
- parts.append("- Graph status: **EMPTY** (first cognitive processing run)\n")
- else:
- parts.append("")
+ parts.append("")
# Clusters
clusters = materials.get("clusters", [])
clustered_ids = set()
if clusters:
- parts.append(("### 聚类结果\n" if is_zh else "### Cluster Results\n"))
+ parts.append(text["clusters_header"])
for i, c in enumerate(clusters):
n_facts = len(c['facts'])
group_type = c.get("group_type", "semantic_cluster")
if group_type == "holistic_therapy_review":
- label = (
- f"{n_facts} 条跨会话用户事实;只归纳有证据的长期情绪/治疗模式"
- if is_zh else
- f"{n_facts} cross-session user facts; only evidence-backed durable emotional/therapy patterns"
- )
+ label = text["label_holistic"].format(n=n_facts)
elif group_type == "source_context_review":
- label = (
- f"{n_facts} 条候选事实;原始写入仅用于主体与细节核验"
- if is_zh else
- f"{n_facts} candidate facts; raw write is only for subject/detail validation"
- )
+ label = text["label_source_context"].format(n=n_facts)
else:
- label = f"{n_facts} 条,主题" if is_zh else f"{n_facts} facts, topic"
+ label = text["label_topic"].format(n=n_facts)
parts.append(f"**Cluster {i}** ({label}: {c['centroid_text']})")
for f in c["facts"]:
source_ids = list(f.get("source_raw_memory_ids") or [])
@@ -2628,8 +2398,7 @@ def _build_materials_message(materials: Dict[str, Any], lang: str = "zh") -> str
)
clustered_ids.add(f['node_id'])
if group_type == "source_context_review" and c.get("raw_contexts"):
- raw_label = "候选事实对应的原始片段" if is_zh else "Relevant raw excerpt per candidate"
- parts.append(f"\n**{raw_label}:**")
+ parts.append(f"\n**{text['raw_label']}:**")
for item in c["raw_contexts"]:
parts.append(
f"- candidate_id={item.get('node_id')}, "
@@ -2638,30 +2407,12 @@ def _build_materials_message(materials: Dict[str, Any], lang: str = "zh") -> str
)
parts.append("")
if materials.get("holistic_therapy_review"):
- parts.append(
- (
- "这是一次有边界的夜间全局整理。最多创建 "
- f"{_S2_HOLISTIC_THERAPY_MAX_SCHEMAS} 条 anchored therapy Schema。"
- "优先联合不同 raw/session 中的持久 trigger/background、"
- "反复 emotional response 和用户已实际使用的 coping resource/decision constraint。"
- "证据不足时输出 []。\n"
- if is_zh else
- "This is one bounded nightly holistic consolidation pass. Create at most "
- f"{_S2_HOLISTIC_THERAPY_MAX_SCHEMAS} anchored therapy Schemas. "
- "Prefer joining durable trigger/background, recurring emotional response, "
- "and observed coping resource or decision constraint across different raw writes/sessions. "
- "Before create_schema, union raw_sources for its evidence IDs and require at least two "
- "distinct raw source IDs; two facts from one raw write are one event. "
- "Output [] when evidence is insufficient.\n"
- )
- )
+ parts.append(text["holistic_note"].format(
+ max_schemas=_S2_HOLISTIC_THERAPY_MAX_SCHEMAS,
+ ))
companion_hints = materials.get("independent_source_companions") or {}
if companion_hints:
- parts.append(
- "**独立来源 companion 提示(只是候选,不是结论):**"
- if is_zh else
- "**Independent-source companion hints (candidates, not conclusions):**"
- )
+ parts.append(text["companion_header"])
for node_id, companions in companion_hints.items():
parts.append(
f"- {node_id} -> "
@@ -2677,14 +2428,8 @@ def _build_materials_message(materials: Dict[str, Any], lang: str = "zh") -> str
all_facts = materials.get("unprocessed_facts", [])
unclustered = [f for f in all_facts if f["node_id"] not in clustered_ids]
if clusters and unclustered:
- header = "### 未聚类事实(补充,次要)\n" if is_zh else "### Unclustered Facts (supplemental)\n"
- hint = (
- "以下事实未进入上述任一聚类,可在完成聚类主题加工后酌情审视;优先级低于聚类结果。\n"
- if is_zh
- else "Facts below were not grouped into any cluster above. Review after cluster themes; lower priority than cluster results.\n"
- )
- parts.append(header)
- parts.append(hint)
+ parts.append(text["unclustered_header"])
+ parts.append(text["unclustered_hint"])
for f in unclustered:
parts.append(f" - [{f['layer']}] {f['content']} (id={f['node_id']})")
parts.append("")
@@ -2692,10 +2437,7 @@ def _build_materials_message(materials: Dict[str, Any], lang: str = "zh") -> str
# Existing graph nodes
forward = materials.get("graph_forward", [])
if forward:
- if is_zh:
- parts.append(f"### 相关 Graph 节点(通过 cluster centroid 向量召回,共 {len(forward)} 条)\n")
- else:
- parts.append(f"### Related Graph Nodes (retrieved via cluster centroid search, {len(forward)} hits)\n")
+ parts.append(text["forward_header"].format(count=len(forward)))
for g in forward:
sim = g.get("similarity", "")
sim_str = f", sim={sim}" if sim else ""
@@ -2705,30 +2447,17 @@ def _build_materials_message(materials: Dict[str, Any], lang: str = "zh") -> str
)
parts.append("")
elif graph_total == 0:
- if is_zh:
- parts.append("### 已有 Graph 节点\n当前 Graph 为空,这是首次认知加工。无需搜索 Graph,直接根据聚类结果创建 Schema。\n")
- else:
- parts.append("### Existing Graph Nodes\nThe Graph is currently EMPTY — this is the first cognitive processing run. Do NOT search the Graph (it will return nothing). Proceed directly to create Schemas from the cluster results.\n")
+ parts.append(text["graph_empty"])
else:
# Graph 有节点但 centroid search 没召回(可能 threshold 太高或语义距离远)
- if is_zh:
- parts.append(
- f"### 已有 Graph 节点\n"
- f"Graph 中共有 {stats.get('graph_total_schemas', 0)} 个 Schema,"
- f"但 centroid 向量召回未命中相关节点。请根据聚类结果判断是否需要创建新 Schema。\n"
- )
- else:
- parts.append(
- f"### Existing Graph Nodes\n"
- f"The Graph has {stats.get('graph_total_schemas', 0)} Schemas, "
- f"but centroid-based vector recall found no matches. Decide based on cluster results whether new Schemas are needed.\n"
- )
+ parts.append(text["graph_no_recall"].format(
+ graph_total=stats.get('graph_total_schemas', 0),
+ ))
# Reverse hits
reverse = materials.get("graph_reverse", [])
if reverse:
- parts.append(("### Graph 反向引用(已有 Schema 引用的 VDB 事实)\n" if is_zh
- else "### Graph Reverse References (VDB facts referenced by existing Schemas)\n"))
+ parts.append(text["reverse_header"])
for r in reverse:
parts.append(
f" - [{r['layer']}] {r['content']} "
@@ -2739,26 +2468,9 @@ def _build_materials_message(materials: Dict[str, Any], lang: str = "zh") -> str
# Existing tags(指导 Agent 复用已有 tag,减少发散)
existing_tags = materials.get("existing_tags", [])
if existing_tags:
- if is_zh:
- parts.append("### 已有标签(请优先从中选择,避免创建同义标签)\n")
- parts.append(f" {', '.join(existing_tags)}\n")
- else:
- parts.append("### Existing Tags (prefer reusing these over creating synonyms)\n")
- parts.append(f" {', '.join(existing_tags)}\n")
-
- if is_zh:
- parts.append(
- "请分析以上材料,输出操作 JSON 数组。"
- "决定是否需要创建新的 Schema,或为已有 Schema 追加 evidence。"
- "如果数据不足以得出可靠结论,输出空数组 `[]`。"
- "打标签时请优先使用已有标签列表中的标签。"
- )
- else:
- parts.append(
- "Analyze the materials above and output a JSON array of operations. "
- "Decide whether to create new Schemas, or add evidence to existing ones. "
- "If the data is insufficient for reliable conclusions, output an empty array `[]`. "
- "When tagging, prefer reusing tags from the existing tags list above."
- )
+ parts.append(text["tags_header"])
+ parts.append(f" {', '.join(existing_tags)}\n")
+
+ parts.append(text["closing"])
return "\n".join(parts)
diff --git a/hy_memory/pipelines/system2_writer.py b/hy_memory/pipelines/system2_writer.py
index d67a614..a20e3a8 100644
--- a/hy_memory/pipelines/system2_writer.py
+++ b/hy_memory/pipelines/system2_writer.py
@@ -243,6 +243,7 @@ class System2Writer(WritePipeline):
materials=materials,
tool_executor=tool_executor,
config=self.config,
+ language=payload.get("language"),
)
# 计算 timing
@@ -508,6 +509,7 @@ class System2Writer(WritePipeline):
materials=batch,
tool_executor=tool_executor,
config=self.config,
+ language=payload.get("language"),
)
batch_record = {
"batch_index": batch_index,
@@ -632,6 +634,7 @@ class System2Writer(WritePipeline):
materials=holistic_materials,
tool_executor=tool_executor,
config=self.config,
+ language=payload.get("language"),
)
if holistic_result.get("success"):
await self._mark_holistic_therapy_reviewed(
@@ -1044,11 +1047,26 @@ class System2Writer(WritePipeline):
agent_id: str,
llm_call,
request_id: str = "",
+ language: Optional[str] = None,
) -> Dict[str, Any]:
- """在 System2 Agent 之后运行跨域突破性归纳"""
+ """在 System2 Agent 之后运行跨域突破性归纳
+
+ sweeper 的 prompt 只有英文版(要求与输入 schema 同语言)。显式 language
+ 时在每个 prompt 末尾追加该语言的输出规则,让产出用该语言书写。
+ """
if not _SWEEPER_ENABLED:
return {"skipped": True, "reason": "SWEEPER_ENABLED=false"}
+ if language:
+ from ..prompts import with_output_language
+
+ _base_call = llm_call
+
+ async def llm_call(prompt: str) -> str:
+ return await _base_call(
+ with_output_language(prompt, language, explicit=True)
+ )
+
try:
from .cross_domain_sweeper import CrossDomainSweeper
@@ -1119,6 +1137,7 @@ class System2Writer(WritePipeline):
self,
user_id: str,
agent_id: str = "default_agent",
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""
手动触发 cross-domain sweeper(同步等待完成)。
@@ -1145,6 +1164,7 @@ class System2Writer(WritePipeline):
agent_id=agent_id,
llm_call=self._get_llm_call(),
request_id=request_id,
+ language=language,
)
result["request_id"] = request_id
return result
@@ -1154,6 +1174,7 @@ class System2Writer(WritePipeline):
user_id: str,
agent_id: str = "default_agent",
max_batches: Optional[int] = None,
+ language: Optional[str] = None,
) -> Dict[str, Any]:
"""
手动触发 System 2 认知加工(由调用方/App 层控制触发时机)。
@@ -1186,6 +1207,8 @@ class System2Writer(WritePipeline):
"content": "",
"created_at": datetime.now().isoformat(),
"max_batches": max_batches,
+ # 显式 prompt 语言码(None → System 2 按 materials 做 zh/en 检测)
+ "language": language,
}
results = await self._run_system2_workers(payload)
@@ -1204,6 +1227,7 @@ class System2Writer(WritePipeline):
agent_id=agent_id,
llm_call=self._get_llm_call(),
request_id=request_id,
+ language=language,
)
agent_success = bool((results.get("system2_agent") or {}).get("success", True))
diff --git a/hy_memory/pipelines/writer.py b/hy_memory/pipelines/writer.py
index bb0d67e..70e2b8a 100644
--- a/hy_memory/pipelines/writer.py
+++ b/hy_memory/pipelines/writer.py
@@ -997,6 +997,7 @@ class MemoryWriter(WritePipeline):
# 这是一次 LLM 调用:prompt / 产出必须能在线上追到,
# 否则 badcase 只能看到"摘要内容不对"却拿不到输入
trace=self._make_trace_sink(request, "EPISODE_SUMMARY"),
+ language=request.language,
)
if nid:
logger.info(
@@ -1210,6 +1211,7 @@ class MemoryWriter(WritePipeline):
self._make_trace_sink(request, "TOPIC_SUMMARY")
if request is not None else None
),
+ language=getattr(request, "language", None),
)
except Exception as e:
logger.warning(f"[topic-summary] failed (non-fatal): {e}")
@@ -1286,6 +1288,7 @@ class MemoryWriter(WritePipeline):
graph_store=getattr(self, "_graph_store", None),
new_memory_embeddings=precomputed_embeddings,
source=request.source,
+ language=request.language,
)
if not recon_result.success:
@@ -2714,6 +2717,7 @@ class MemoryWriter(WritePipeline):
vector_store, request.user_id, request.agent_id,
exclude_memory_id=memory_id,
max_turns=_hist_turns * 2, # k 轮对话 = k*2 条 message
+ language=request.language,
)
_recent_history_ms = (_t_recent_history and (datetime.now() - _t_recent_history).total_seconds() * 1000) or 0.0
_recent_history_count = len([line for line in (_history_context or "").splitlines() if line.strip()])
@@ -2794,6 +2798,7 @@ class MemoryWriter(WritePipeline):
user_id=request.user_id,
agent_id=request.agent_id,
session_id=request.session_id or "default_session",
+ language=request.language,
)
if finalize is finalize_dynamic_episode_capsules:
finalize_kwargs["summary_concurrency"] = getattr(
@@ -2954,9 +2959,11 @@ class MemoryWriter(WritePipeline):
exclude_memory_id: str = "",
max_turns: int = 20,
max_chars_assistant: Optional[int] = None,
+ language: Optional[str] = None,
) -> str:
"""
获取该用户最近的 L1_RAW 对话记录,按轮次拆分后拼成 history context。
+ language:显式 prompt 语言码,用于渲染名字行;None 时按内容判 zh/en。
每条 L1_RAW 的 content 是多轮对话([user]: ...\n[assistant]: ...)。
raw 在写入时已按 utils/raw_trim.py 的规则裁好(custom[RAW_TRIMMED_KEY]),
@@ -3060,9 +3067,13 @@ class MemoryWriter(WritePipeline):
from .base import render_user_name_line
from ..utils.lang_detect import is_chinese
- _name_line = render_user_name_line(
- user_name,
- is_chinese("\n".join(b for _, b, _ in recent)),
+ _name_line = (
+ render_user_name_line(user_name, language=language)
+ if language else
+ render_user_name_line(
+ user_name,
+ is_chinese("\n".join(b for _, b, _ in recent)),
+ )
)
if _name_line:
all_messages.append(_name_line)
@@ -3305,6 +3316,7 @@ class MemoryWriter(WritePipeline):
existing_tags=existing_tags,
history_context=history_context,
basic_profile_fields=_basic_profile_fields,
+ language=request.language,
)
extract_timing["extract_total_ms"] = round(
(datetime.now() - _t_extract_total).total_seconds() * 1000, 2
diff --git a/hy_memory/prompts/__init__.py b/hy_memory/prompts/__init__.py
new file mode 100644
index 0000000..1838236
--- /dev/null
+++ b/hy_memory/prompts/__init__.py
@@ -0,0 +1,242 @@
+"""Prompt registry: every multilingual LLM prompt, keyed by language code.
+
+One module per language (``en.py``, ``zh_hans.py``, ``ja.py`` ...) defines the
+same set of names (``PROMPT_NAMES``). Call sites look prompts up with
+``get_prompt(name, language)`` instead of importing a language module, so a
+new language only needs a new module and an entry in ``_MODULES``.
+
+Language selection (``resolve_language``):
+
+* explicit ``language`` (per call, else ``MemoryConfig.language`` /
+ ``MEMORY_LANGUAGE``) wins and is validated by ``normalize_language``;
+* otherwise the existing zh/en auto-detection runs unchanged
+ (``utils.lang_detect.is_chinese`` → ``zh-Hans`` or ``en``). Auto-detection
+ never picks any of the other languages.
+
+When the language is explicit, ``with_output_language`` appends
+``OUTPUT_LANGUAGE_DIRECTIVE`` so memories are written in that language even
+if the conversation uses another one. Auto-detected requests keep the
+"same language as the input" rule and their prompts are byte-identical to
+earlier releases.
+"""
+
+from __future__ import annotations
+
+import importlib
+from types import ModuleType
+from typing import Any, Dict, Optional, Tuple
+
+# Canonical codes, in documentation order.
+SUPPORTED_LANGUAGES: Tuple[str, ...] = (
+ "en",
+ "zh-Hans",
+ "zh-Hant",
+ "ja",
+ "es",
+ "de",
+ "pt",
+ "fr",
+ "ko",
+ "ru",
+ "id",
+)
+
+# Accepted aliases (matched case-insensitively, "_" treated as "-").
+LANGUAGE_ALIASES: Dict[str, str] = {
+ "zh": "zh-Hans",
+ "zh-cn": "zh-Hans",
+ "zh-sg": "zh-Hans",
+ "zh-hans-cn": "zh-Hans",
+ "zh-tw": "zh-Hant",
+ "zh-hk": "zh-Hant",
+ "zh-mo": "zh-Hant",
+ "zh-hant-tw": "zh-Hant",
+ "zh-hant-hk": "zh-Hant",
+ "pt-br": "pt",
+ "pt-pt": "pt",
+ "en-us": "en",
+ "en-gb": "en",
+}
+
+_MODULES: Dict[str, str] = {
+ "en": "en",
+ "zh-Hans": "zh_hans",
+ "zh-Hant": "zh_hant",
+ "ja": "ja",
+ "es": "es",
+ "de": "de",
+ "pt": "pt",
+ "fr": "fr",
+ "ko": "ko",
+ "ru": "ru",
+ "id": "id",
+}
+
+# Every language module must define all of these.
+PROMPT_NAMES: Tuple[str, ...] = (
+ # chat extraction
+ "EXTRACT_SYSTEM_PROMPT",
+ "STRUCTURE_METADATA_PROMPT",
+ "EXTRACT_FEW_SHOT",
+ "EXTRACT_PROMPT",
+ "EXTRACT_PROMPT_NO_INTENTION",
+ "NO_INTENTION_SECTION_PATTERN",
+ "NO_INTENTION_MEMORY_SECTION",
+ "NO_INTENTION_REPLACEMENTS",
+ "INTENTION_DISABLED_NOTE",
+ "USER_NAME_LINE",
+ # chat reconcile
+ "SEARCH_QUERY_PROMPT",
+ "RECONCILE_PROMPT",
+ "RECONCILE_STRUCTURE_METADATA_PROMPT",
+ "RECONCILE_FEW_SHOT",
+ # working / coding memory
+ "CODING_EXTRACT_PROMPT",
+ "CODING_EXTRACT_PROMPT_CODING",
+ "CODING_CONVERSATION_BLOCK",
+ "CODING_EMPTY_BLOCK",
+ "CODING_RECONCILE_PROMPT",
+ "CODING_FACT_RECONCILE_PROMPT",
+ "CODING_CHAIN_SUMMARY_PROMPT",
+ # summaries
+ "EPISODE_SUMMARY_PROMPT",
+ "TOPIC_SUMMARY_PROMPT",
+ # System 2 evolve
+ "SYSTEM2_AGENT_PROMPT",
+ "SYSTEM2_OUTPUT_INSTRUCTIONS",
+ "SYSTEM2_SCHEMA_EVIDENCE_GATE",
+ "SYSTEM2_SINGLE_CALL_REPLACEMENTS",
+ "SYSTEM2_MATERIALS",
+ # explicit-language output rule
+ "OUTPUT_LANGUAGE_DIRECTIVE",
+ "LANGUAGE_NAME",
+)
+
+# Prompts rendered with str.format(); the value lists the expected fields.
+# The rest are appended verbatim (their braces are literal JSON).
+FORMAT_FIELDS: Dict[str, Tuple[str, ...]] = {
+ "EXTRACT_PROMPT": ("content", "current_date", "last_messages", "memory_at"),
+ "EXTRACT_PROMPT_NO_INTENTION": ("content", "current_date", "last_messages", "memory_at"),
+ "USER_NAME_LINE": ("name",),
+ "SEARCH_QUERY_PROMPT": ("new_memories",),
+ "RECONCILE_PROMPT": ("current_date", "existing_memories", "few_shot_section", "new_memories"),
+ "CODING_EXTRACT_PROMPT": ("branch_present", "conversation_block", "workspace_present"),
+ "CODING_EXTRACT_PROMPT_CODING": ("branch_present", "conversation_block", "workspace_present"),
+ "CODING_CONVERSATION_BLOCK": ("history", "new"),
+ "CODING_RECONCILE_PROMPT": ("candidates_block", "drafts_block"),
+ "CODING_FACT_RECONCILE_PROMPT": ("candidates_block", "drafts_block"),
+ "CODING_CHAIN_SUMMARY_PROMPT": ("chain_block",),
+ "EPISODE_SUMMARY_PROMPT": ("memories",),
+ "TOPIC_SUMMARY_PROMPT": ("memories", "topic_name"),
+}
+
+# Fields of each SYSTEM2_MATERIALS entry (all other entries have none).
+SYSTEM2_MATERIALS_FIELDS: Dict[str, Tuple[str, ...]] = {
+ "title": (),
+ "stats": ("clustered", "clusters", "evidenced", "fresh", "graph_total", "recalled", "total", "unclustered"),
+ "graph_status_empty": (),
+ "clusters_header": (),
+ "label_holistic": ("n",),
+ "label_source_context": ("n",),
+ "label_topic": ("n",),
+ "raw_label": (),
+ "holistic_note": ("max_schemas",),
+ "companion_header": (),
+ "unclustered_header": (),
+ "unclustered_hint": (),
+ "forward_header": ("count",),
+ "graph_empty": (),
+ "graph_no_recall": ("graph_total",),
+ "reverse_header": (),
+ "tags_header": (),
+ "closing": (),
+}
+
+_loaded: Dict[str, ModuleType] = {}
+
+
+def _supported_text() -> str:
+ aliases = ", ".join(f"{k}->{v}" for k, v in LANGUAGE_ALIASES.items())
+ return f"supported: {', '.join(SUPPORTED_LANGUAGES)} (aliases: {aliases})"
+
+
+def normalize_language(language: Optional[str]) -> Optional[str]:
+ """Return the canonical code for ``language``; None/"" stays None.
+
+ Raises ValueError for an unknown code, listing the supported codes.
+ """
+ if language is None:
+ return None
+ if not isinstance(language, str):
+ raise ValueError(
+ f"language must be a string, got {type(language).__name__}; "
+ + _supported_text()
+ )
+ raw = language.strip()
+ if not raw:
+ return None
+ key = raw.replace("_", "-").lower()
+ for code in SUPPORTED_LANGUAGES:
+ if code.lower() == key:
+ return code
+ if key in LANGUAGE_ALIASES:
+ return LANGUAGE_ALIASES[key]
+ raise ValueError(f"unsupported language {language!r}; " + _supported_text())
+
+
+def detect_language_code(content: str = "", messages=None) -> str:
+ """The legacy automatic choice: ``zh-Hans`` if Chinese, else ``en``."""
+ from ..utils.lang_detect import is_chinese
+
+ return "zh-Hans" if is_chinese(content, messages=messages) else "en"
+
+
+def resolve_language(
+ language: Optional[str] = None,
+ content: str = "",
+ messages=None,
+) -> str:
+ """Explicit language if given (validated), else zh/en auto-detection."""
+ code = normalize_language(language)
+ if code is not None:
+ return code
+ return detect_language_code(content, messages=messages)
+
+
+def _module(language: str) -> ModuleType:
+ code = normalize_language(language) or "en"
+ mod = _loaded.get(code)
+ if mod is None:
+ mod = importlib.import_module(f"{__name__}.{_MODULES[code]}")
+ _loaded[code] = mod
+ return mod
+
+
+def get_prompt(name: str, language: Optional[str] = "en") -> Any:
+ """Look up prompt ``name`` for ``language`` (canonical code or alias)."""
+ if name not in PROMPT_NAMES:
+ raise KeyError(f"unknown prompt {name!r}")
+ return getattr(_module(language or "en"), name)
+
+
+def with_output_language(
+ prompt: str, language: Optional[str], explicit: bool,
+) -> str:
+ """Append the output-language rule when the language was set explicitly."""
+ if not explicit or not language:
+ return prompt
+ return prompt + get_prompt("OUTPUT_LANGUAGE_DIRECTIVE", language)
+
+
+__all__ = [
+ "SUPPORTED_LANGUAGES",
+ "LANGUAGE_ALIASES",
+ "PROMPT_NAMES",
+ "FORMAT_FIELDS",
+ "SYSTEM2_MATERIALS_FIELDS",
+ "normalize_language",
+ "detect_language_code",
+ "resolve_language",
+ "get_prompt",
+ "with_output_language",
+]
diff --git a/hy_memory/prompts/de.py b/hy_memory/prompts/de.py
new file mode 100644
index 0000000..0c279eb
--- /dev/null
+++ b/hy_memory/prompts/de.py
@@ -0,0 +1,2312 @@
+# -*- coding: utf-8 -*-
+"""German prompts (``de``).
+
+Translated from en.py; native-speaker review recommended.
+"""
+
+
+# ================================================================
+# Chat extraction (agent/extractor.py)
+# ================================================================
+
+EXTRACT_SYSTEM_PROMPT = """# ROLLE
+
+Du bist ein Memory Extractor (Erinnerungsextraktor).
+
+Extrahiere dauerhafte, wertvolle Erinnerungen aus Gesprächen und wandle sie in strukturierte, in sich geschlossene Aussagen um.
+
+Extrahiere nur Informationen, die in künftigen Gesprächen voraussichtlich von Bedeutung sind.
+
+---
+
+# EINGABEN
+
+Du erhältst:
+
+* Letzte k Nachrichten (Last k Messages)
+* Neue Nachrichten (New Messages)
+* Memory Date
+* Current Date
+
+Verwende:
+
+* die letzten k Nachrichten ausschließlich zur Auflösung von Bezügen (Koreferenz)
+* Memory Date als EINZIGEN zeitlichen Bezugspunkt
+* Current Date nur als Metadatum, niemals zur Auflösung relativer Zeitangaben
+
+---
+
+# WAS EXTRAHIERT WIRD
+
+Extrahiere AUSSCHLIESSLICH wirklich neue Informationen, die in den NEUEN Nachrichten des Nutzers eingeführt werden.
+
+Gute Erinnerungen sind zum Beispiel:
+
+* Vorlieben
+* langfristige Projekte
+* Gewohnheiten
+* Ziele
+* wiederkehrende Aktivitäten
+* Meinungen
+* Beziehungen
+* wichtige Erlebnisse
+* stabile Eigenschaften
+* Zukunftspläne
+* Entscheidungen
+* Einschränkungen
+* angenommene Empfehlungen
+
+Extrahiere NICHT:
+
+* Smalltalk
+* Bestätigungen und Quittierungen
+* allgemeine Gefühlsäußerungen
+* vorübergehenden Gesprächskontext
+* Erinnerungen des Assistenten an alte Erinnerungen
+* Informationen, die sich bereits aus dem früheren Kontext ergeben
+* vage Persönlichkeitsurteile
+
+---
+
+# SUBJEKT
+
+Jede Erinnerung muss in sich geschlossen sein, in der dritten Person stehen und ein
+explizites Subjekt haben. Welches Subjekt zu verwenden ist, entscheidet sich danach, **wer gesprochen hat**:
+
+| Sprecher | Zu schreibendes Subjekt | Beispiel |
+| --- | --- | --- |
+| `role: "user"` | der Nutzer | "Der Nutzer ..." / "The user ..." / "用户..." |
+| jeder Sprecher mit einem `name`, der nicht der Nutzer ist (z. B. `name: "John"`) | diese Person, mit Namen | "John ..." |
+| `role: "assistant"` OHNE `name` | der KI-Assistent | "Der Assistent ..." |
+
+Die beiden Eingabeabschnitte drücken den Sprecher unterschiedlich aus:
+
+* **Neue Nachrichten** ist ein JSON-Array — lies `role` und das optionale Feld `name`.
+* **Letzte k Nachrichten** ist gerenderter Text — der Sprecher ist das Label in eckigen Klammern,
+ `[user]:` / `[John]:` / `[assistant]:`, optional mit einer vorangestellten Zeile
+ "Der Name des Nutzers ist Tim" / "The user's name is Tim" / "用户名叫Tim".
+
+Regeln:
+
+* Der Nutzer ist die Person, der diese Erinnerungen gehören. Auch wenn der eigene Name
+ des Nutzers bekannt ist (aus `name` an seiner Nachricht oder aus der vorangestellten Namenszeile),
+ schreibst du trotzdem "Der Nutzer ...", NIEMALS "Tim ...".
+* **`role: "assistant"` MIT einem `name` ist eine andere reale Person, nicht die KI.**
+ Schreibe ihre Erinnerungen mit ihrem Namen als Subjekt: "John ...".
+* Nur ein namenloser `role: "assistant"` ist der KI-Assistent.
+* Erfinde niemals einen Namen für den KI-Assistenten, er hat keinen.
+
+---
+
+# SPRACHREGELN
+
+* Die Ausgabesprache muss der Eingabesprache entsprechen.
+* Bewahre Originalschriften und Fachbegriffe exakt.
+* Transliteriere niemals Namen, Marken oder Gleichungen.
+
+---
+
+# ZWEI ARTEN VON ERINNERUNGEN
+
+Du extrahierst zwei Arten von Erinnerungen: **memory** (Erinnerungen) und **intentions** (Absichten).
+
+## memory
+
+Alles Dauerhafte und Merkenswerte über den Nutzer — und über jede andere
+namentlich genannte Person im Gespräch — gehört hierher:
+
+* Vorlieben, Meinungen, Werte, Einstellungen
+* Ereignisse, Handlungen, Erlebnisse
+* Gewohnheiten, Verhaltensmuster
+* Beziehungen, Eigenschaften
+* objektive Fakten, Entscheidungen, Einschränkungen
+* laufende Aktivitäten
+
+Implizite Vorlieben MÜSSEN erschlossen werden, wenn sie stark nahegelegt werden
+(z. B. eine Aktivität wieder aufnehmen → positives Interesse; etwas meiden →
+negative Vorliebe; wiederholter freiwilliger Einsatz → anhaltendes Interesse).
+
+Trenne NICHT „was für ein Mensch der Nutzer ist“ von „was passiert ist“.
+Beides gehört in `memory`.
+
+## intentions
+
+Etwas Vorausschauendes, das der Nutzer **in Zukunft vorhat oder zu tun beabsichtigt**,
+auf das man reagieren kann und das irrelevant wird, sobald es erledigt oder vorbei ist.
+
+Beispiele:
+
+* "Der Nutzer hat nächsten Dienstag ein Vorstellungsgespräch."
+* "Der Nutzer plant, Ende des Monats die Wohnung zu wechseln."
+* "Der Nutzer beabsichtigt, den Bericht vor Freitag fertigzustellen."
+
+KEINE intentions (diese gehören in `memory`):
+
+* stabile Vorlieben / Eigenschaften ("Der Nutzer mag Basketball")
+* abgeschlossene vergangene Ereignisse ("Der Nutzer ist letztes Jahr nach Peking gezogen")
+* allgemeine Ziele ohne konkreten, umsetzbaren nächsten Schritt
+
+### valid_until
+
+Gib für jede intention `valid_until` an: das Datum, nach dem die
+Absicht keine Rolle mehr spielt (die Frist / das Zieldatum), aufgelöst
+anhand des **Memory Date** (z. B. „nächsten Dienstag“ → das entsprechende absolute Datum).
+Lässt sich keine Frist bestimmen, setze `valid_until` auf `null`.
+
+---
+
+# OWNER
+
+Jede Erinnerung und jede Absicht MUSS einen `owner` tragen, der angibt, zu welchem Erinnerungsspeicher
+sie gehört. Es gibt genau zwei Werte:
+
+* `"user"` — alles, was in den eigenen Erinnerungsspeicher des Nutzers gehört. Dazu zählen
+ Fakten/Vorlieben/Eigenschaften über den Nutzer selbst UND Fakten über andere
+ namentlich genannte reale Personen im Gespräch, denn auch das sind Dinge, die der
+ Erinnerungsspeicher des Nutzers enthalten soll.
+* `"agent"` — Informationen, die der KI-Assistent (ein namenloser `role: "assistant"`)
+ liefert (Empfehlungen, Bestätigungen, Dinge, die er recherchiert hat), oder eine künftige
+ Handlung, die der Nutzer vom **Assistenten** ausgeführt haben möchte („erinnere mich in 8 Stunden“).
+
+Eine namentlich genannte Person ist NIEMALS `owner: "agent"` — sie ist eine reale Person, nicht die KI,
+auch wenn ihre Nachrichten `role: "assistant"` tragen. Ihre Erinnerungen sind
+`owner: "user"` mit ihrem Namen als Subjekt des Inhalts.
+
+Entscheide `owner` für jeden Eintrag einzeln. Im Zweifel ist der Standardwert `"user"`.
+
+---
+
+# ZEITREGELN
+
+Löse relative Zeitangaben anhand des Memory Date auf.
+
+Beispiele:
+
+* „nächste Woche“
+* „letzten Monat“
+* „morgen“
+
+Wenn sich eine Zeitangabe nicht sicher auflösen lässt:
+
+* entferne die relative Formulierung
+* halte die Erinnerung zeitlos
+
+Erfinde keine Chronologie.
+
+**Gerade passierte Ereignisse sind Ereignisse — behalte sie.** Wenn der Nutzer etwas als
+gerade abgeschlossen berichtet („bin gerade zurück“, „habe gerade fertig“, „heute Morgen“, „gestern“), ist das
+Abschlussdatum das Memory Date. Gib das **Ereignis selbst** mit diesem Datum aus; lass es nicht
+in einer Hintergrundaussage aufgehen.
+
+* „Ich bin gerade von einer Reise mit meiner Familie zurückgekommen“
+ → "Der Nutzer ist am <Memory Date> von einer Familienreise zurückgekehrt."
+ NICHT → "Der Nutzer macht Familienreisen." (das Rückkehrdatum ist die Antwort auf „wann sind
+ sie zurückgekommen“, und wenn es wegfällt, ist die Frage nicht mehr beantwortbar)
+
+Wenn ein Ereignis sowohl einen Beginn als auch ein Ende hat, die das Gespräch getrennt nennt,
+halte beide fest, statt sie zu einer einzigen Zeitspanne zusammenzufassen.
+
+---
+
+# QUALITÄTSREGELN
+
+Jede Erinnerung muss:
+
+* in sich geschlossen sein
+* kontextuell vollständig sein
+* gut auffindbar sein
+* informationsdicht sein
+
+Bewahre wichtige Details:
+
+* Namen
+* Produkte
+* Orte
+* Zahlen
+* Gleichungen
+* Einschränkungen
+
+Verallgemeinere nie etwas Konkretes zu einer Kategorie. Schreib, was tatsächlich gesagt wurde.
+
+* "Banff" → "Banff" beibehalten, NICHT "die Rocky Mountains"
+* "ein dreijähriger Border Collie namens Luna" → Rasse, Alter und Namen beibehalten
+
+**Konkrete Details, die der andere Sprecher liefert, zählen trotzdem.** Ein Fakt entsteht oft über
+mehrere Wortwechsel: Der andere Sprecher benennt die Sache, der Nutzer bestätigt sie. Die Subjektregeln
+entscheiden, *wessen* Erinnerung es ist — sie erlauben nicht, Details wegzulassen.
+
+* [Sam]: „Hast du die Skimöglichkeiten in Banff genutzt?“
+ [user]: „Ja, war super zum Skifahren!“
+ → "Der Nutzer war in Banff Ski fahren und fand den Schnee großartig."
+ NICHT → "Der Nutzer mag Wintersport." (sowohl der Ort als auch die Aktivität wurden
+ festgehalten, jeweils von einem der beiden Sprecher)
+
+Vermeide bruchstückhafte Erinnerungen ohne Kontext.
+
+Wähle die kleinste Anzahl von Erinnerungen, die dennoch alle unterschiedlichen künftigen
+Abrufbedürfnisse abdeckt.
+
+* Verdichten heißt zusammenfassen, nicht weglassen. Jede explizite dauerhafte Aussage
+ in den neuen Nachrichten muss genau einmal in der Ausgabe vorkommen.
+* Fasse Details zusammen, wenn sie dasselbe Subjekt und dasselbe reale Ereignis,
+ denselben Zustand, dieselbe Vorliebe, denselben Plan oder dieselbe Entscheidung betreffen. Ein zusammenhängendes Ereignis darf 1–3 Sätze umfassen.
+* Gib nicht sowohl eine allgemeine Aussage als auch engere Wiederholungen derselben Belege aus.
+* Teile nur auf, wenn das Subjekt verschieden ist, die Ereignisse unabhängig voneinander stattfanden oder die
+ Erinnerungen unterschiedliche Zustände beschreiben.
+* Halte eine Ursache, Empfehlung oder Folge bei dem Fakt, den sie erklärt, wenn
+ eine Trennung den Zusammenhang verlieren würde.
+* Führe getrennte datierte Vorkommnisse niemals nur deshalb zusammen, weil sie ein Thema teilen.
+* Bewahre die zeitliche Genauigkeit der Quelle. Mache aus vagen Wendungen wie „letztes
+ Wochenende“ oder „letzten Sommer“ keine exakten Kalenderdaten, es sei denn, das Datum ist explizit
+ genannt oder eindeutig bestimmt; „das Wochenende vor <Memory Date>“ ist zulässig.
+
+---
+
+# TAGS
+
+Jede Erinnerung muss 1–3 knappe Tags enthalten.
+- Thematische Schlüsselwörter bleiben kleingeschrieben und englisch (travel, health, work).
+- Eigennamen behalten ihre Großschreibung (Jasper, Canada, Banff, Prius).
+
+Beispiele:
+
+* work
+* travel
+* Jasper
+* Canada
+* health
+
+---
+"""
+
+STRUCTURE_METADATA_PROMPT = """
+
+---
+
+# STRUKTURELLE ORGANISATION
+
+Gib für jede `memory` zusätzlich aus:
+
+* `topic_paths`: eine abwärtskompatible Liste von null bis drei semantischen Pfaden,
+ jeweils vom Allgemeinen zum Spezifischen.
+* `event_facet`: ein Objekt mit ausschließlich `subject`, `participants`, `action`,
+ `objects`, `locations` und `state`; state ist `planned`, `ongoing`,
+ `completed` oder `unknown`.
+* `topic_assignments`: null bis sechs subjektspezifische Zuordnungen. Jeder Eintrag ist
+ `{subject, role, path}`, wobei `path` eine Liste von `{name, type}`-Segmenten ist und
+ `type` einer von `topic`, `facet`, `series` oder `episode`. Verwende `topic` für einen
+ breiten Bereich, `facet` für eine konkrete Aktivität / einen semantischen Aspekt, `series` nur
+ für wiederholte Vorkommnisse derselben konkreten Aktivitäts-/Zustandslinie und
+ `episode` nur für ein einzelnes, abgegrenztes reales Vorkommnis. Ein gemeinsames Ereignis kann
+ eine Zuordnung pro explizitem Teilnehmer haben und dabei eine kanonische Erinnerung behalten.
+ Die Typen folgen `topic -> facet -> series -> episode`; Ebenen dürfen übersprungen werden, aber
+ Typen dürfen sich weder wiederholen noch rückwärts laufen.
+
+Dieser Extraktor sieht nur den aktuellen Schreibvorgang und darf daher kein
+`series`-Segment ausgeben. Gib hier Topic/Facet/Episode aus. Der Reconcile-Schritt kann später eine
+Series festlegen, nachdem er unabhängige gespeicherte Vorkommnisse verglichen hat.
+
+Dies ist eine Organisation zum Schreibzeitpunkt. Leite Series/Episode nicht aus der Pfadtiefe ab,
+konstruiere keine Hierarchie aus einem Eigennamen oder einem breiten Tag und ordne keine Person nur
+deshalb zu, weil sie in einem unzusammenhängenden Kontext mit vorkommt. Hör auf der spezifischsten belegten
+Ebene auf und verwende leere Werte, wenn du unsicher bist. Kodiere niemals Frageformen wie
+„wann“, „wie viele“, „wer“, Pluralität oder Ordinalformulierungen.
+"""
+
+EXTRACT_FEW_SHOT = """
+---
+
+# BEISPIELE
+
+## Beispiel 1 — Abgrenzung: alter Kontext dient nur der Auflösung und wird nie erneut extrahiert
+
+Letzte k Nachrichten:
+[{"role": "user", "content": "Ich schaue mir gerade Hunde aus dem Tierheim in der Innenstadt an."},
+ {"role": "assistant", "content": "Wie schön — hast du schon einen gefunden, der dir gefällt?"}]
+Neue Nachrichten:
+[{"role": "user", "content": "Ja, ich habe sie gestern abgeholt — eine dreijährige Border-Collie-Hündin namens Luna."}]
+Memory Date: 2025-04-10
+
+Ausgabe:
+```json
+{
+ "memory": [
+ {"content": "Der Nutzer hat am 2025-04-09 eine dreijährige Border-Collie-Hündin namens Luna aus einem Tierheim in der Innenstadt adoptiert.", "tags": ["pets", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Die alten Nachrichten lösen nur „sie“ auf und liefern Kontext („Tierheim in der Innenstadt“). Gib KEINE veraltete Erinnerung wie „der Nutzer erwägt, einen Hund zu adoptieren“ aus — extrahiert wird nur der wirklich neue Fakt (die abgeschlossene Adoption), wobei „gestern“ anhand des Memory Date aufgelöst wird.
+
+## Beispiel 2 — Eine lange Antwort des Assistenten verdichten
+
+Neue Nachrichten:
+[{"role": "user", "content": "Schreib mir einen kurzen Essay darüber, warum Homeoffice die Produktivität steigert."},
+ {"role": "assistant", "content": "Gern — Einleitung: ‚Das Homeoffice hat die Arbeitsweise von Teams grundlegend verändert ...' [~2000 Wörter Hauptteil ausgelassen] ... Schluss: ‚Kurz gesagt: Autonomie und weniger Unterbrechungen sorgen für mehr Leistung.'"}]
+Memory Date: 2025-03-22
+
+Ausgabe:
+```json
+{
+ "memory": [
+ {"content": "Der Assistent hat für den Nutzer einen kurzen Essay entworfen, der argumentiert, dass Homeoffice die Produktivität steigert, weil Autonomie und weniger Unterbrechungen für mehr Leistung sorgen.", "tags": ["writing", "remote-work"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Die Antwort des Assistenten ist lang. Speichere niemals den Essay im Wortlaut — destilliere ihn auf Thema + Kernthese. owner ist "agent", weil der Assistent ihn erstellt hat. Aufgeblähter Wortlaut macht den Erinnerungsspeicher unbrauchbar.
+
+## Beispiel 3 — Kombinierte Extraktion: basic_info + intention + verdichteter Plan des Agenten
+
+Neue Nachrichten:
+[{"role": "user", "content": "Hallo, ich bin Kenji. Ich plane nächsten Monat eine Reise nach Japan — kannst du mir eine 7-Tage-Reiseroute zusammenstellen?"},
+ {"role": "assistant", "content": "# 7 Tage klassische Goldene Route durch Japan (Tokio → Kyoto → Nara → Osaka)\\nAnkunft in Tokio, mit dem Shinkansen nach Süden nach Kyoto, Tagesausflug nach Nara, Abflug ab Osaka (Kansai).\\n\\n## Tag 1: Ankunft in Tokio\\n- Landung in Haneda/Narita, Gepäck im Hotel nahe Tokyo Station abgeben.\\n- Später Nachmittag: Sensoji-Tempel (Asakusa), über die Nakamise-Straße schlendern, Taiyaki probieren.\\n- Abend: Shibuya Crossing + Shibuya Sky Dachterrasse zum Sonnenuntergang; Abendessen im Izakaya (Yakitori, Sake).\\n\\n## Tag 2: Tokios Märkte & Sehenswürdigkeiten — [ausgelassen]\\n## Tag 3: Shinkansen nach Kyoto, Fushimi Inari, Gion — [ausgelassen]\\n## Tag 4: Kyotos Tempel (Kiyomizu-dera, Kinkaku-ji, Ginkaku-ji) — [ausgelassen]\\n## Tag 5: Tagesausflug nach Nara (Hirsche im Nara-Park, Todai-ji) — [ausgelassen]\\n## Tag 6: Osaka (Burg Osaka, Streetfood in Dotonbori) — [ausgelassen]\\n## Tag 7: Sightseeing in Osaka + Abflug vom Flughafen Kansai — [ausgelassen]\\n\\nTipp: Kauf vor der Ankunft einen 7-Tage-JR-Pass. Soll ich etwas anpassen?"}]
+Memory Date: 2025-09-15
+
+Ausgabe:
+```json
+{
+ "memory": [
+ {"content": "Der Assistent hat für den Nutzer eine 7-Tage-Reiseroute durch Japan entlang der klassischen Goldenen Route erstellt: Tokio (Asakusa, Shibuya), mit dem Shinkansen nach Kyoto (Fushimi Inari, Kiyomizu-dera, Kinkaku-ji, Gion), ein Tagesausflug nach Nara (Hirschpark, Todai-ji), dann Osaka (Burg Osaka, Dotonbori), Abflug vom Flughafen Kansai.", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
+ ],
+ "intentions": [
+ {"content": "Der Nutzer plant im Oktober 2025 eine 7-tägige Reise nach Japan.", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
+ ],
+ "basic_info": {"name": "Kenji"}
+}
+```
+Ein einziger Wortwechsel erzeugt drei Ausgaben in verschiedenen Bereichen: Der Name kommt in basic_info, die Reise ist eine vorausschauende intention mit Frist, und die lange, mehrteilige Reiseroute des Assistenten wird zu EINER dichten agent-Erinnerung verdichtet — die Route und die wichtigsten Stationen pro Stadt, NICHT die Stichpunkte, Tipps oder Essenslisten jedes einzelnen Tages. Die gesamte Antwort im Wortlaut zu speichern, würde den Erinnerungsspeicher aufblähen; das Gerüst zu speichern, hält ihn abfragbar.
+
+## Beispiel 4 — Eine spätere Nachricht, die eine frühere Empfehlung bestätigt/übernimmt, ist selbst ein Fakt
+
+Neue Nachrichten:
+[{"role": "user", "content": "Mein sechsjähriges Kind isst überhaupt kein Gemüse. Hast du Ideen?"},
+ {"role": "assistant", "content": "Versuch, Spinat oder Karotten in die Nudelsoße zu pürieren — Farbe und Geschmack verschwinden größtenteils, und viele Kinder essen es, ohne es zu merken."},
+ {"role": "user", "content": "Oh, gut, das probieren wir heute Abend. Übrigens, welche Schlafenszeit ist in dem Alter sinnvoll?"},
+ {"role": "assistant", "content": "Für ein sechsjähriges Kind ist eine Schlafenszeit zwischen 19 und 21 Uhr mit etwa 10–11 Stunden Schlaf ideal."}]
+Memory Date: 2025-06-20
+
+Ausgabe:
+```json
+{
+ "memory": [
+ {"content": "Der Nutzer hat ein sechsjähriges Kind, das sich weigert, Gemüse zu essen, und hat den Vorschlag des Assistenten angenommen, Spinat oder Karotten in die Nudelsoße zu pürieren, um sie zu verstecken.", "tags": ["parenting", "food"], "owner": "user"},
+ {"content": "Der Assistent hat dem Nutzer geraten, dass ein sechsjähriges Kind zwischen 19 und 21 Uhr ins Bett gehen und etwa 10–11 Stunden schlafen sollte.", "tags": ["parenting", "sleep"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+In der dritten Nachricht sagte der Nutzer „das probieren wir heute Abend“ — er übernimmt damit ausdrücklich den früheren Vorschlag. Diese Annahme ist wertvoll und muss festgehalten werden („hat den Vorschlag des Assistenten angenommen, ...“), statt als Smalltalk verworfen zu werden. Der Rat zur Schlafenszeit wurde gerade erst gegeben und noch nicht übernommen, daher wird er als Rat festgehalten (owner "agent").
+
+## Beispiel 5 — RAG/eingefügter Kontext: den eingefügten Text nie speichern
+
+Neue Nachrichten:
+[{"role": "user", "content": "[Abgerufener Kontext: Der Eiffelturm ist 330 m hoch und wurde 1889 fertiggestellt.] Vor diesem Hintergrund werde ich meiner Freundin diesen Sommer oben auf dem Eiffelturm einen Heiratsantrag machen."}]
+Memory Date: 2025-05-02
+
+Ausgabe:
+```json
+{
+ "memory": [],
+ "intentions": [
+ {"content": "Der Nutzer plant, seiner Freundin im Sommer 2025 oben auf dem Eiffelturm einen Heiratsantrag zu machen.", "tags": ["relationship", "travel"], "valid_until": "2025-08-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+Der in Klammern abgerufene Kontext (Höhe und Baujahr des Turms) ist per RAG eingefügtes Referenzmaterial, NICHTS, was der Nutzer uns über sich selbst erzählt hat — speichere ihn NICHT. Extrahiert wird nur der eigene, vorausschauende Plan des Nutzers. Vom System/RAG eingefügter Text ist Kontext für das Modell, niemals eine Erinnerung.
+
+## Beispiel 6 — Geteiltes Referenzmaterial: den Inhalt extrahieren, nicht die Handlung des Teilens
+
+Neue Nachrichten:
+[{"role": "user", "content": "Merk dir das Teigtaschenrezept meiner Oma, damit es nicht verloren geht. Füllung: 500 g Schweinehack, 300 g Chinakohl, 2 EL Sojasoße, 1 EL Sesamöl, ein daumengroßes Stück Ingwer, fein gehackt. Kohl 15 Minuten salzen, dann gut ausdrücken. Teigtaschen kochen, zweimal kaltes Wasser nachgießen, fertig, wenn sie oben schwimmen."},
+ {"role": "assistant", "content": "Alles klar, gespeichert!"}]
+Memory Date: 2025-07-01
+
+Ausgabe:
+```json
+{
+ "memory": [
+ {"content": "Das Teigtaschenrezept der Großmutter des Nutzers: Füllung aus 500 g Schweinehack, 300 g Chinakohl (15 Minuten gesalzen, dann gut ausgedrückt), 2 EL Sojasoße, 1 EL Sesamöl und einem daumengroßen Stück fein gehacktem Ingwer; die Teigtaschen kochen, zweimal kaltes Wasser nachgießen, und sie sind fertig, wenn sie oben schwimmen.", "tags": ["food", "recipe", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Extrahiere den tatsächlichen sachlichen Inhalt (Zutaten, Mengen, den Schritt mit Salzen und Ausdrücken, die Kochmethode) — NICHT „der Nutzer hat ein Rezept geteilt“ oder „der Nutzer hat gebeten, sich das Rezept zu merken“. Die Handlung des Teilens ist wertlos; abfragbar ist der Inhalt.
+
+## Beispiel 7 — Strukturierte Zahlen und Attribute exakt bewahren
+
+Neue Nachrichten:
+[{"role": "user", "content": "Ich trage meine Bestleistungen im Heim-Gym für diesen Zyklus ein: Kniebeuge 140 kg x 3, Bankdrücken 100 kg x 5, Kreuzheben 180 kg x 2, Schulterdrücken 60 kg x 6. Körpergewicht 78 kg, 3 Sätze pro Übung, 3 Minuten Pause."},
+ {"role": "assistant", "content": "Eingetragen — starke Zahlen!"}]
+Memory Date: 2026-01-20
+
+Ausgabe:
+```json
+{
+ "memory": [
+ {"content": "Die aktuellen Bestleistungen des Nutzers im Krafttraining sind Kniebeuge 140 kg x 3, Bankdrücken 100 kg x 5, Kreuzheben 180 kg x 2 und Schulterdrücken 60 kg x 6, bei einem Körpergewicht von 78 kg.", "tags": ["fitness", "strength"], "owner": "user"},
+ {"content": "Der Nutzer trainiert mit 3 Sätzen pro Übung und 3 Minuten Pause zwischen den Sätzen.", "tags": ["fitness", "training"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Jede Zahl und jede Einheit (kg, Wiederholungen, Sätze, Pausenzeit) wird exakt bewahrt — sie wegzulassen, würde die am besten abfragbaren Informationen zerstören. Teile in zwei saubere Themen auf (Bestleistungen vs. Trainingsprotokoll), aber runde oder streiche niemals die konkreten Werte.
+
+## Beispiel 8 — Langes Gespräch mit mehreren Themen: nicht nach dem ersten Thema aufhören
+
+Neue Nachrichten:
+[{"role": "user", "content": "Große Woche — ich habe am Dienstag endlich meine Doktorarbeit verteidigt!"},
+ {"role": "assistant", "content": "Herzlichen Glückwunsch! Wie fühlst du dich?"},
+ {"role": "user", "content": "Erleichtert! Außerdem habe ich einen Mietvertrag für eine Wohnung in Berlin unterschrieben und ziehe nächsten Monat um. Und ich habe angefangen, mit Duolingo Deutsch zu lernen — 30-Tage-Serie. Meine Partnerin Sofia bleibt vorerst in Madrid, das ist hart."}]
+Memory Date: 2025-11-08
+
+Ausgabe:
+```json
+{
+ "memory": [
+ {"content": "Der Nutzer hat am 2025-11-04 seine Doktorarbeit verteidigt.", "tags": ["education", "milestone"], "owner": "user"},
+ {"content": "Der Nutzer hat einen Mietvertrag für eine Wohnung in Berlin unterschrieben.", "tags": ["housing"], "owner": "user"},
+ {"content": "Der Nutzer lernt mit Duolingo Deutsch und hat eine 30-Tage-Serie.", "tags": ["language", "learning"], "owner": "user"},
+ {"content": "Die Partnerin des Nutzers, Sofia, bleibt vorerst in Madrid, was der Nutzer als hart empfindet.", "tags": ["relationship"], "owner": "user"}
+ ],
+ "intentions": [
+ {"content": "Der Nutzer plant, nächsten Monat (etwa im Dezember 2025) nach Berlin zu ziehen.", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+Vier oder mehr Themen — die Verteidigung der Doktorarbeit, die Wohnung in Berlin, das Deutschlernen und die Partnerin in Madrid. Hör nicht nach dem ersten Thema auf. Beachte, dass ein Wortwechsel in einen abgeschlossenen Fakt (Mietvertrag unterschrieben) UND eine intention (der bevorstehende Umzug) aufgeteilt wird, und dass das emotionale, aber gehaltvolle Detail über Sofia behalten wird, weil es dauerhaften Beziehungskontext trägt.
+
+## Beispiel 9 — Zwei reale Personen: `name` an einer Assistenten-Nachricht bedeutet eine reale Person
+
+Neue Nachrichten:
+[{"role": "user", "name": "Tim", "content": "Bin gerade aus der Kletterhalle zurück, zum dritten Mal diese Woche. Endlich die Überhang-Route geschafft."},
+ {"role": "assistant", "name": "John", "content": "Stark! Ich gehe stattdessen schwimmen — meine Schulter tut seit letztem Monat immer noch weh."}]
+Memory Date: 2025-08-14
+
+Ausgabe:
+```json
+{
+ "memory": [
+ {"content": "Der Nutzer klettert dreimal pro Woche und hat kürzlich eine schwierige Überhang-Route geschafft.", "tags": ["fitness", "climbing"], "owner": "user"},
+ {"content": "John geht stattdessen schwimmen, weil seine Schulter nach einer Verletzung um Juli 2025 immer noch wehtut.", "tags": ["fitness", "health"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {"name": "Tim"}
+}
+```
+John trägt `role: "assistant"`, hat aber einen `name`, also ist er eine andere reale Person, NICHT die KI: Seine Erinnerung verwendet "John ..." als Subjekt und ist trotzdem `owner: "user"` (sie gehört in den Erinnerungsspeicher des Nutzers). Die eigene Erinnerung des Nutzers bleibt "Der Nutzer ...", obwohl wir wissen, dass er Tim heißt — niemals "Tim klettert". `basic_info.name` stammt aus `name: "Tim"` an der Nutzernachricht, was maßgeblich ist, auch wenn Tim seinen Namen nie selbst ausgesprochen hat.
+
+## Beispiel 10 — Gegenbeispiel: Eigenschaften einer anderen Person gehören nie in basic_info
+
+Neue Nachrichten:
+[{"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
+
+Ausgabe:
+```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"}
+}
+```
+Johns Beruf und Wohnort sind SEINE Eigenschaften, deshalb kommen sie in `memory` mit "John" als Subjekt. Sie dürfen NIEMALS in `basic_info.occupation` / `basic_info.location` landen — `basic_info` ist ausschließlich das Profil des Nutzers selbst. Nur `name` (Tim, aus dem Feld `name` der Nutzernachricht) gehört dorthin. Beachte, dass die Ausgabesprache der Eingabesprache folgt (dieses Beispiel ist auf Englisch).
+
+## Beispiel 11 — Gegenbeispiel: Smalltalk hat keine basic_info
+
+Neue Nachrichten:
+[{"role": "user", "content": "Hallo"},
+ {"role": "assistant", "content": "Hallo! Der Name des Nutzers ist Der Nutzer. Wie kann ich helfen?"}]
+Memory Date: 2025-09-03
+
+Ausgabe:
+```json
+{
+ "memory": [],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Der Nutzer hat nichts über sich selbst gesagt. Die Zeile des Assistenten ist kein Wortwechsel des Nutzers, und "Der Nutzer" ist ein Platzhalter, kein Name. Gib `{}` aus — niemals `{"name": "Der Nutzer"}` oder `{"name": "user"}`.
+
+---
+"""
+
+EXTRACT_PROMPT = """## Letzte k Nachrichten
+
+{last_messages}
+
+---
+
+## Neue Nachrichten
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Ausgabeformat
+
+Gib AUSSCHLIESSLICH ein JSON-Objekt in einem ```json-Codeblock zurück.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "intentions": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "valid_until": "YYYY-MM-DD",
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Regeln:
+
+* `memory` = dauerhafte, merkenswerte Informationen: Vorlieben, Meinungen, Einstellungen,
+ Eigenschaften, Ereignisse, Pläne, Erlebnisse, Gewohnheiten, Entscheidungen — über den Nutzer oder
+ über jede andere namentlich genannte reale Person, mit dem Subjekt gemäß „# SUBJEKT“
+* `intentions` = vorausschauende Dinge, die der Nutzer (oder eine andere namentlich genannte Person) in Zukunft
+ vorhat / zu tun beabsichtigt, mit `valid_until` = Frist/Zieldatum
+ (aufgelöst anhand des Memory Date) oder `null`, falls keines vorhanden
+* `owner` (Pflicht bei jeder memory & intention) = `"user"` oder `"agent"`
+ (siehe „# OWNER“ oben; im Zweifel `"user"`)
+* `basic_info` = **ausschließlich das eigene Profil des Nutzers**. Nimm stabile Profil-
+ felder auf (z. B. Name, Alter, Wohnort, Beruf, Arbeitgeber), die in den NEUEN Nutzernachrichten
+ **ausdrücklich genannt** werden. Niemals erschließen, niemals erfinden. Wird kein Feld ausdrücklich
+ genannt, gib `{{}}` aus.
+ * HARTE REGEL: Fülle ein Feld NUR, wenn der Nutzer es in einem `user`-Wortwechsel genannt hat.
+ Alles, was nur der Assistent gesagt hat (auch wenn der Assistent eine
+ frühere Erinnerung zitiert wie "Der Name des Nutzers ist X"), zählt NICHT. Wenn nichts
+ infrage kommt, gib `"basic_info": {{}}` aus.
+ * Schreib NIEMALS den Feldnamen selbst oder einen Platzhalter als Wert ("user",
+ "The user", "Der Nutzer", "用户", "name", "N/A", "unknown", "none", "-"). Lass das Feld weg.
+ * Negativbeispiel: Smalltalk wie `[user]: Hi` / `[assistant]: How can
+ I help?` oder `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
+ * Ausnahme für `name`: Das Feld `name` an der eigenen Nachricht des Nutzers oder eine vorangestellte
+ Zeile "Der Name des Nutzers ist X" / "The user's name is X" / "用户名叫X" ist eine maßgebliche Quelle für
+ `name` — auch wenn der Nutzer ihn nie selbst ausgesprochen hat.
+ * Trage hier NIEMALS die Eigenschaften einer anderen realen Person ein. Wenn John (eine Nachricht mit
+ Assistentenrolle, die `name` trägt) sagt „Ich bin Krankenpfleger in Berlin“, ist das eine `memory`
+ ("John ist Krankenpfleger in Berlin."), NICHT `basic_info.occupation` / `.location`.
+* Keine doppelten Informationen über Abschnitte hinweg
+* Tags müssen 1–3 knappe, kleingeschriebene Schlüsselwörter enthalten
+* Verwende leere Arrays `[]` oder `{{}}`, wenn nichts extrahiert wird
+* Gib ausschließlich gültiges JSON zurück
+
+Gib jetzt das JSON aus."""
+
+EXTRACT_PROMPT_NO_INTENTION = """## Letzte k Nachrichten
+
+{last_messages}
+
+---
+
+## Neue Nachrichten
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Ausgabeformat
+
+Gib AUSSCHLIESSLICH ein JSON-Objekt in einem ```json-Codeblock zurück.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Regeln:
+
+* `memory` = dauerhafte, merkenswerte Informationen: Vorlieben, Meinungen, Einstellungen,
+ Eigenschaften, Ereignisse, Erlebnisse, Gewohnheiten, Entscheidungen, **sowie Zukunftspläne / bevorstehende
+ Handlungen** — über den Nutzer oder über jede andere namentlich genannte reale Person, mit dem
+ Subjekt gemäß „# SUBJEKT“. Erfinde **keinen** separaten intentions-Bereich.
+* `owner` (Pflicht bei jeder memory) = `"user"` oder `"agent"`
+ (siehe „# OWNER“ oben; im Zweifel `"user"`)
+* `basic_info` = **ausschließlich das eigene Profil des Nutzers**. Nimm stabile Profil-
+ felder auf (z. B. Name, Alter, Wohnort, Beruf, Arbeitgeber), die in den NEUEN Nutzernachrichten
+ **ausdrücklich genannt** werden. Niemals erschließen, niemals erfinden. Wird kein Feld ausdrücklich
+ genannt, gib `{{}}` aus.
+ * HARTE REGEL: Fülle ein Feld NUR, wenn der Nutzer es in einem `user`-Wortwechsel genannt hat.
+ Alles, was nur der Assistent gesagt hat (auch wenn der Assistent eine
+ frühere Erinnerung zitiert wie "Der Name des Nutzers ist X"), zählt NICHT. Wenn nichts
+ infrage kommt, gib `"basic_info": {{}}` aus.
+ * Schreib NIEMALS den Feldnamen selbst oder einen Platzhalter als Wert ("user",
+ "The user", "Der Nutzer", "用户", "name", "N/A", "unknown", "none", "-"). Lass das Feld weg.
+ * Negativbeispiel: Smalltalk wie `[user]: Hi` / `[assistant]: How can
+ I help?` oder `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
+ * Ausnahme für `name`: Das Feld `name` an der eigenen Nachricht des Nutzers oder eine vorangestellte
+ Zeile "Der Name des Nutzers ist X" / "The user's name is X" / "用户名叫X" ist eine maßgebliche Quelle für
+ `name` — auch wenn der Nutzer ihn nie selbst ausgesprochen hat.
+ * Trage hier NIEMALS die Eigenschaften einer anderen realen Person ein. Wenn John (eine Nachricht mit
+ Assistentenrolle, die `name` trägt) sagt „Ich bin Krankenpfleger in Berlin“, ist das eine `memory`
+ ("John ist Krankenpfleger in Berlin."), NICHT `basic_info.occupation` / `.location`.
+* Keine doppelten Informationen über Abschnitte hinweg
+* Tags: 1–3 knappe Schlüsselwörter; thematische Tags kleingeschrieben; Eigennamen behalten ihre Großschreibung
+* Verwende leere Arrays `[]` oder `{{}}`, wenn nichts extrahiert wird
+* Gib ausschließlich gültiges JSON zurück — füge **niemals** einen `intentions`-Schlüssel ein
+
+Gib jetzt das JSON aus."""
+
+
+# ================================================================
+# Chat reconcile (agent/reconciler.py)
+# ================================================================
+
+SEARCH_QUERY_PROMPT = """Du bist ein Generator für Suchanfragen. Erzeuge zu einer Liste neu extrahierter Erinnerungen eine Reihe kurzer Suchanfragen, mit denen sich verwandte bestehende Erinnerungen in einer Vektordatenbank finden lassen.
+
+Das Ziel ist maximaler Recall — finde bestehende Erinnerungen, die mit den neuen Erinnerungen semantisch verwandt sind, auch wenn die Formulierung ganz anders ist.
+
+## Neue Erinnerungen:
+{new_memories}
+
+## Anweisungen
+
+Erzeuge Suchanfragen, die Folgendes abdecken:
+- zentrale Themen, Entitäten und Motive, die in den Erinnerungen vorkommen
+- umformulierte oder abstrahierte Fassungen der Kernkonzepte
+- verwandte Konzepte, die im Erinnerungsspeicher des Nutzers existieren könnten
+
+Gib ein JSON-Array von Suchanfrage-Strings aus (5–15 Anfragen, kurz und fokussiert):
+
+["anfrage1", "anfrage2", "anfrage3", ...]
+
+Gib nur das JSON-Array aus, keinen weiteren Text."""
+
+RECONCILE_PROMPT = """Du bist ein System zur Verwaltung von Erinnerungen.
+
+Deine Aufgabe ist es, neue Erinnerungen so in einen bestehenden Erinnerungsbestand einzufügen, dass er:
+
+* verlustfrei
+* widerspruchsfrei
+* kompakt
+* gut abrufbar
+
+bleibt.
+
+---
+
+# Operationen
+
+## ADD
+
+Verwende sie, wenn die Information völlig neu ist.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## UPDATE
+
+Verwende sie, wenn:
+
+* die neue Erinnerung mit einer bestehenden vereinbar ist
+* beide dasselbe Thema beschreiben
+* das Zusammenführen Vollständigkeit oder Abrufbarkeit verbessert
+
+Regeln:
+
+* verlustfrei zusammenführen
+* alle nützlichen Informationen bewahren
+* KEINE Duplikate erzeugen
+* wenn sich die beiden in einem Wert widersprechen, behalte den Wert der Erinnerung mit dem späteren
+ `memory_at`; lass niemals eine ältere Erinnerung einen neueren Wert überschreiben
+
+### Dasselbe Vorkommnis vs. ein weiteres Vorkommnis
+
+Verwende **UPDATE** nur, wenn die neue Erinnerung Details zu demselben realen
+Vorkommnis oder demselben dauerhaften Fakt ergänzt, der bereits festgehalten ist.
+
+Wenn dieselbe Person dieselbe Art von Aktivität/Ereignis zu einem anderen Zeitpunkt erneut ausführt
+(eine weitere Reise, ein weiteres Spiel, eine weitere Verletzung, ein weiterer Kauf, ein weiterer Gesundheitsschreck usw.), behalte das Vorkommnis
+als separates **ADD**. Bewahre sein eigenes Datum und seine eigenen Details. Wenn eine bestehende Erinnerung
+eindeutig ein weiteres Vorkommnis in genau dieser konkreten Serie ist, verknüpfe sie mit
+`related: [{{"memory_id":"...","relation":"same_series"}}]`.
+
+Führe getrennte datierte Vorkommnisse nicht zu einer langen Zähl-/Zeitleisten-Erinnerung zusammen.
+Die Abrufschicht baut Zeitleisten aus den verknüpften L2-Erinnerungen auf.
+
+```json
+{{
+ "op": "UPDATE",
+ "memory_id": "...",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## SUPERSEDE
+
+Verwende sie NUR, wenn:
+
+* die neue Erinnerung einer bestehenden Erinnerung widerspricht
+* beide nicht gleichzeitig wahr sein können
+* die alte Erinnerung jetzt eine falsche Antwort zum aktuellen Zustand liefern würde
+* das `memory_at` der neuen Erinnerung gleich dem oder SPÄTER als das `memory_at` der bestehenden Erinnerung ist
+
+Beispiele:
+
+* Stadt hat sich geändert
+* Arbeitgeber hat sich geändert
+* Beziehungsstatus hat sich geändert
+
+NICHT verwenden für:
+
+* ergänzte Details
+* vereinbare Vorlieben
+* Unterschiede in der Formulierung
+* semantische Gleichwertigkeit
+* eine neue Erinnerung, deren `memory_at` FRÜHER liegt als das der bestehenden Erinnerung — sie ist ein
+ älterer Zustand und darf niemals einen neueren ersetzen (siehe „Zeitliche Reihenfolge“)
+
+Regeln:
+
+* content darf NUR den neuen Zustand enthalten
+* unveränderte Informationen NICHT kopieren
+* das System behält den alten Knoten und hängt ihn automatisch an die Entwicklungskette an; um die Historie musst du dich nicht kümmern
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_id": "...",
+ "content": "...",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+### Mehrere bestehende Erinnerungen zu einer Kette zusammenfalten
+
+Wenn ZWEI ODER MEHR bestehende Erinnerungen DIESELBE Dimension verfolgen und die neue Erinnerung
+die jüngste Änderung auf dieser Dimension ist — ihr `memory_at` liegt später als das `memory_at` jeder
+zusammengefalteten Erinnerung —, darfst du sie zu einer einzigen Entwicklungs-
+kette zusammenfalten. Verwende `memory_ids` (eine geordnete Liste, ÄLTESTE → NEUESTE) statt einer einzelnen
+`memory_id`:
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_ids": ["<oldest_id>", "<newer_id>"],
+ "content": "<nur der neueste Zustand>",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+Die aufgeführten Erinnerungen werden von der ältesten zur neuesten verkettet, und die neue Erinnerung wird zum
+Kettenkopf. `content` beschreibt weiterhin NUR den neuesten Zustand — kopiere niemals den
+Text der älteren Erinnerungen hinein; sie bleiben in der Kettenhistorie abfragbar.
+
+---
+
+# Regeln
+
+* Bewahre alle bedeutsamen Informationen.
+* Überspringe exakte Duplikate.
+* Führe verwandte Fragmente bevorzugt zusammen.
+* Getrennte datierte Vorkommnisse bleiben getrennte ADDs; verwende `same_series` nur für
+ dasselbe Subjekt und dieselbe konkrete Art von Aktivität/Ereignis.
+* Halte jede Erinnerung auf ein zusammenhängendes Thema fokussiert.
+* Befolge die „Zeitliche Reihenfolge“ unten.
+* **Führe NIEMALS über verschiedene Subjekte hinweg zusammen und ersetze NIEMALS über sie hinweg.** Das Subjekt ist die Person,
+ um die es im Inhalt geht: "Der Nutzer ..." vs. "John ..." vs. "Mary ...". Erinnerungen über
+ verschiedene Personen sind unabhängige Fakten, selbst wenn der Satz ansonsten
+ identisch ist — "Der Nutzer mag Kaffee" und "John mag Kaffee" sind zwei getrennte
+ Erinnerungen, niemals ein UPDATE oder ein SUPERSEDE voneinander.
+* `owner` (`user`/`agent`): übernimm ihn aus der zu schreibenden Erinnerung. Führe NIEMALS über verschiedene owner hinweg zusammen und ersetze NIEMALS über sie hinweg — ein Fakt des Nutzers und ein Fakt des Assistenten sind verschieden, selbst beim selben Thema.
+* Ein SUPERSEDE zielt entweder auf EINE Erinnerung (`memory_id`) oder faltet mehrere Erinnerungen auf derselben Dimension zu einer Kette zusammen (`memory_ids`, älteste→neueste). Ein UPDATE zielt auf genau EINE Erinnerung.
+* Berühre dieselbe bestehende Erinnerung niemals mit mehr als einer Operation.
+* Die Ausgabesprache entspricht der Sprache der eingegebenen Erinnerungen.
+
+---
+
+# Zeitliche Reihenfolge
+
+Jede Erinnerung, ob neu oder bestehend, hat ein `memory_at`: wann sie geschehen ist. Erinnerungen werden
+NICHT immer in der Reihenfolge geschrieben, in der sie geschehen sind — Verläufe können verspätet importiert werden,
+und eine Erinnerung kann hinzugefügt werden, während ältere Verläufe noch verarbeitet werden. Eine neue
+Erinnerung kann daher ÄLTER sein als eine bestehende.
+
+* Entscheide, welche Erinnerung neuer ist, AUSSCHLIESSLICH anhand von `memory_at`. „Neue Erinnerungen“ bedeutet „werden
+ jetzt geschrieben“, nicht „sind jünger“.
+* Eine ältere Erinnerung darf niemals eine neuere ersetzen: kein SUPERSEDE einer neueren
+ Erinnerung und kein UPDATE, das einen neueren Wert mit einem älteren überschreibt.
+* Wenn eine neue Erinnerung älter ist als eine bestehende Erinnerung, mit der sie in Konflikt steht, behalte die
+ bestehende Erinnerung als aktuellen Zustand. Füge die neue per ADD als vergangenen Zustand hinzu, formuliert
+ in der Vergangenheit mit ihrem Zeitpunkt (zum Beispiel „2023 lebte der Nutzer in Shanghai“),
+ oder gib nichts aus, wenn sie keine Information hinzufügt.
+* `memory_at: null` bedeutet unbekannte Zeit. Unbekannt ist NICHT neuer: Ersetze niemals per SUPERSEDE eine
+ Erinnerung mit bekanntem `memory_at` durch eine, deren `memory_at` null ist.
+* Erfinde keine Chronologie.
+
+---
+
+# Optional: `related`
+
+Bei jeder Operation DARFST du ein `related`-Array hinzufügen, das festhält, wie die zu schreibende Erinnerung
+mit einer BESTEHENDEN Erinnerung zusammenhängt. Das ändert nichts daran, was gespeichert wird — es hält
+lediglich eine Verknüpfung fest.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."],
+ "related": [{{"memory_id": "<existing_id>", "relation": "causes"}}]
+}}
+```
+
+Nur diese vier Relationen sind erlaubt:
+
+* `causes` — die beiden Erinnerungen stehen in einem Ursache-Wirkungs-Verhältnis
+ (z. B. „hat angefangen, täglich zu laufen“ → „das Knie hat angefangen zu schmerzen“)
+* `elaborates` — ergänzt Details zur bestehenden Erinnerung oder ist eine spätere Entwicklung davon
+* `contrasts` — sie stehen in einem Spannungsverhältnis, sind aber BEIDE noch wahr (wenn eine die andere
+ falsch macht, ist das ein SUPERSEDE, keine `contrasts`-Verknüpfung)
+* `same_series` — getrennte datierte Vorkommnisse derselben konkreten Aktivität oder
+ derselben Ereignisart für dasselbe Subjekt (zum Beispiel zwei verschiedene Skireisen)
+
+Regeln:
+
+* Verknüpfe nur mit Erinnerungen, die unter „Bestehende Erinnerungen“ erscheinen — erfinde niemals eine ID.
+* Gib eine Verknüpfung nur aus, wenn die Beziehung **explizit und spezifisch** ist. Dass zwei Erinnerungen
+ lediglich dasselbe breite Thema betreffen, ist KEINE Relation — lass `related` weg.
+* `same_series` erfordert dasselbe Subjekt und eine konkrete wiederholte Handlung bzw. ein konkretes wiederholtes Ereignis;
+ gemeinsame breite Tags wie health, travel, sport, food oder work reichen nicht aus.
+* Lass das Feld ganz weg, wenn es nichts zu verknüpfen gibt. Null Verknüpfungen sind der Normalfall.
+* Verwende `related` niemals als Ersatz für UPDATE / SUPERSEDE.
+
+---
+{few_shot_section}
+###################
+Eingabedaten
+###################
+
+Current date: {current_date}
+
+## Bestehende Erinnerungen
+
+{existing_memories}
+
+## Neue Erinnerungen
+
+{new_memories}
+
+---
+
+# Ausgabe
+
+Gib AUSSCHLIESSLICH ein JSON-Array in einem ```json-Codeblock zurück.
+
+Wenn keine Änderungen nötig sind:
+
+```json
+[]
+```
+
+Erzeuge jetzt das JSON-Array."""
+
+RECONCILE_STRUCTURE_METADATA_PROMPT = """
+
+Zusätzlicher Vertrag für die strukturelle Ausgabe:
+
+Bewahre oder verfeinere für jedes ADD-, UPDATE- oder SUPERSEDE-Ergebnis `topic_paths`,
+`event_facet` und `topic_assignments`. `event_facet` enthält ausschließlich `subject`,
+`participants`, `action`, `objects`, `locations` und `state`.
+`topic_assignments` enthält subjektspezifische Einträge `{subject, role, path}`;
+jedes Pfadsegment ist `{name, type}`, und type ist `topic|facet|series|episode`.
+Die Typen folgen `topic -> facet -> series -> episode`; Ebenen dürfen übersprungen werden, aber
+Typen dürfen sich weder wiederholen noch rückwärts laufen.
+Verwende Series nur für wiederholte Vorkommnisse einer konkreten Aktivitäts-/Zustandslinie und
+Episode nur für ein einzelnes, abgegrenztes reales Vorkommnis. Leite diese Typen niemals aus
+der Tiefe, einem breiten gemeinsamen Tag oder einem unzusammenhängenden gemeinsamen Vorkommen ab. Wenn eine bestehende Erinnerung
+bereits einen semantisch gleichwertigen subjektspezifischen Pfad hat, verwende exakt deren Knoten-
+namen und -typen wieder, statt eine synonyme Abzweigung anzulegen. Um eine exakte Wiederverwendung anzufordern, gib
+`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
+"through":"topic|facet|series|episode"}]` aus. Die referenzierte ID muss unter
+„Bestehende Erinnerungen“ erscheinen. `through` bedeutet, das bestehende Pfadpräfix bis einschließlich des
+genannten Strukturtyps zu kopieren; ein explizit verfasstes tieferes Suffix bleibt neu. Die Wiederverwendung
+ist verboten, wenn sich das Subjekt, die konkrete Aktivitäts-/Zustandslinie oder die Episode-Grenze
+unterscheidet. Diese Felder beschreiben die Erinnerung, niemals eine künftige Frageform wie
+„wann“, „wie viele“ oder „wer“.
+
+Series ist eine Relation des Reconcile-Zeitpunkts: Lege sie nur fest, wenn die neue Erinnerung und
+mindestens eine unabhängige bestehende Erinnerung getrennte Vorkommnisse derselben
+konkreten Aktivitäts-/Zustandslinie sind. Mehrere Aussagen aus dem aktuellen Schreibvorgang belegen
+keine Wiederholung.
+"""
+
+RECONCILE_FEW_SHOT = """
+###################
+Beispiele
+###################
+
+## Beispiel 1 — Eine neue Erinnerung: ein Teil widerspricht einer bestehenden Kette, ein Teil ist unabhängig
+
+Bestehende Erinnerungen:
+[
+ {"memory_id": "m1", "content": "Der Nutzer arbeitet als Produktmanager bei Stripe.", "owner": "user", "history_versions": [{"content": "Der Nutzer arbeitet als Produktmanager bei einem Fintech-Start-up."}]}
+]
+Neue Erinnerungen:
+[
+ {"content": "Der Nutzer hat Stripe verlassen, ist jetzt Product Lead bei Notion und hat vor Kurzem am Wochenende mit dem Töpfern angefangen.", "owner": "user"}
+]
+
+Ausgabe:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "m1", "content": "Der Nutzer arbeitet als Product Lead bei Notion.", "supersede_reason": "Arbeitgeber hat von Stripe zu Notion gewechselt", "owner": "user", "tags": ["work"]},
+ {"op": "ADD", "content": "Der Nutzer hat vor Kurzem am Wochenende mit dem Töpfern angefangen.", "owner": "user", "tags": ["hobby"]}
+]
+```
+EINE EINZIGE neue Erinnerung enthält zwei Dinge: den Jobwechsel (dieselbe Dimension wie die bestehende Beschäftigungskette m1, die bereits eine Historie hat → SUPERSEDE, wird zum neuen Kettenkopf) und ein unabhängiges Detail (Töpfern → ADD). Teile die eine Erinnerung auf und wähle pro Teil die passende Operation — der neue Kopf beschreibt NUR den Beschäftigungsstatus, niemals das Töpfern.
+
+## Beispiel 2 — Zwei unverknüpfte bestehende Erinnerungen + die neue Änderung zu einer Kette mit 3 Knoten zusammenfalten
+
+Bestehende Erinnerungen:
+[
+ {"memory_id": "a1", "content": "Der Nutzer lernt Gitarre spielen.", "owner": "user", "memory_at": "2024-02-10 09:00"},
+ {"memory_id": "a2", "content": "Der Nutzer kann jetzt ein paar ganze Lieder auf der Gitarre spielen.", "owner": "user", "memory_at": "2024-09-05 09:00"}
+]
+Neue Erinnerungen:
+[
+ {"content": "Der Nutzer tritt jetzt bei lokalen Open-Mic-Abenden mit der Gitarre auf.", "owner": "user"}
+]
+
+Ausgabe:
+```json
+[
+ {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "Der Nutzer tritt bei lokalen Open-Mic-Abenden mit der Gitarre auf.", "supersede_reason": "Gitarrenkönnen hat sich entwickelt: lernen → Lieder spielen → live auftreten", "owner": "user", "tags": ["music", "hobby"]}
+]
+```
+a1 und a2 waren nie verknüpft, aber sie verfolgen dieselbe Dimension (Fortschritt auf der Gitarre), und die neue Erinnerung ist der jüngste Schritt. Falte sie mit `memory_ids` in der Reihenfolge älteste→neueste zusammen; sie werden zu einer Kette mit 3 Knoten (a1 ← a2 ← neuer Kopf). Der `content` des Kopfes beschreibt NUR den aktuellen Zustand — er wiederholt weder „lernt“ noch „ein paar Lieder“.
+
+## Beispiel 3 — Der neue Kopf darf den Inhalt der alten Erinnerung NICHT kopieren
+
+Bestehende Erinnerungen:
+[
+ {"memory_id": "c1", "content": "Der Nutzer wohnt in einer gemieteten Einzimmerwohnung in Shibuya, Tokio, zahlt ¥180,000/Monat, liebt die 5 Minuten Fußweg zum Bahnhof, beklagt sich aber, dass es nachts laut ist und es keinen Parkplatz gibt.", "owner": "user"}
+]
+Neue Erinnerungen:
+[
+ {"content": "Der Nutzer hat gerade ein Haus mit drei Schlafzimmern in einem Vorort von Yokohama gekauft und ist dort eingezogen, mit Garten und Doppelgarage.", "owner": "user"}
+]
+
+Ausgabe:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "c1", "content": "Der Nutzer hat ein Haus mit drei Schlafzimmern in einem Vorort von Yokohama gekauft und ist dort eingezogen, mit Garten und Doppelgarage.", "supersede_reason": "Wohnsitz hat sich von einer gemieteten Wohnung in Shibuya zu einem eigenen Haus in Yokohama geändert", "owner": "user", "tags": ["housing"]}
+]
+```
+Die neue Erinnerung ersetzt c1 per SUPERSEDE und wird zum Kettenkopf. Der `content` des Kopfes beschreibt NUR das neue Haus in Yokohama. Schleppe die charakteristischen Details der alten Wohnung (Shibuya, ¥180,000 Miete, der Fußweg zum Bahnhof, die Beschwerden über Lärm/Parkplatz) NICHT in den neuen Knoten — sie gehören eindeutig zum alten Wohnsitz, nicht zum neuen. Sie bleiben in der Kettenhistorie und bleiben abrufbar; sie zu kopieren, würde den Kopf in sich widersprüchlich machen (gleichzeitig zur Miete in Shibuya UND im Eigentum in Yokohama).
+
+## Beispiel 4 — Verschiedene Subjekte werden nie zusammengeführt, egal wie ähnlich die Formulierung ist
+
+Bestehende Erinnerungen:
+[
+ {"memory_id": "d1", "content": "Der Nutzer trinkt jeden Morgen schwarzen Kaffee.", "owner": "user"}
+]
+Neue Erinnerungen:
+[
+ {"content": "John trinkt jeden Morgen schwarzen Kaffee.", "owner": "user"},
+ {"content": "Der Nutzer trinkt jetzt zweimal täglich schwarzen Kaffee, morgens und nach dem Mittagessen.", "owner": "user"}
+]
+
+Ausgabe:
+```json
+[
+ {"op": "ADD", "content": "John trinkt jeden Morgen schwarzen Kaffee.", "owner": "user", "tags": ["food"]},
+ {"op": "UPDATE", "memory_id": "d1", "content": "Der Nutzer trinkt zweimal täglich schwarzen Kaffee, morgens und nach dem Mittagessen.", "owner": "user", "tags": ["food"]}
+]
+```
+Die beiden neuen Erinnerungen sind fast identisch formuliert, haben aber VERSCHIEDENE Subjekte. "John ..." handelt von einer anderen Person, also ist es ein einfaches ADD — niemals ein UPDATE oder SUPERSEDE von d1, obwohl d1 fast dasselbe über den Nutzer sagt. Nur die Erinnerung, deren Subjekt ebenfalls "Der Nutzer" ist, darf mit d1 zusammengeführt werden.
+
+## Beispiel 5 — Wiederkehrendes Ereignis: Anzahl erhöhen und eine Zeitleiste führen (UPDATE, nicht ADD)
+
+Bestehende Erinnerungen:
+[
+ {"memory_id": "i1", "content": "John hat sich letzte Saison am Knöchel verletzt und brauchte eine Pause sowie Physiotherapie.", "owner": "user", "memory_at": "2023-05-21 19:48"}
+]
+Neue Erinnerungen:
+[
+ {"content": "John hat sich bei einem kürzlichen Spiel erneut den Knöchel verdreht.", "owner": "user", "memory_at": "2023-10-13 13:50"}
+]
+
+Ausgabe:
+```json
+[
+ {"op": "UPDATE", "memory_id": "i1", "content": "John hat sich zweimal am Knöchel verletzt: zuerst letzte Saison (etwa in der Saison 2022–2023), mit Pause und Physiotherapie; dann bei einem Spiel um den 2023-10-13.", "owner": "user", "tags": ["health", "basketball", "injury"]}
+]
+```
+Dieselbe Ereignisart tritt erneut auf → UPDATE der alten Erinnerung. Nenne die **Anzahl** und führe die Vorkommnisse mit Zeitangaben auf, soweit bekannt. Füge KEINEN zweiten Fakt „John hat sich am Knöchel verletzt“ per ADD hinzu und verwende KEIN SUPERSEDE (die erste Verletzung ist nicht unwahr geworden).
+"""
+
+
+# ================================================================
+# Working / coding memory (coding/)
+# ================================================================
+
+CODING_EXTRACT_PROMPT = """\
+Du extrahierst dauerhafte WORKING-Erinnerungen aus einem Abschnitt einer Aufgabenausführungs-Session.
+Eine „working“-Session ist jede praktische Aufgabe, bei der der Nutzer einen Computer /
+ein System über Tools bedient — das umfasst SOWOHL Software-/Code-Arbeit (Schreiben, Debuggen,
+Refactoring, Bauen, Deployen, Nutzung von APIs/Bibliotheken) ALS AUCH System- und Betriebs-
+arbeit (Ausführen von Shell-/PowerShell-Befehlen, Analyse oder Bereinigung von Festplatten/Speicher, Datei-
+& Ordneroperationen, Installieren/Konfigurieren von Software, Einrichten von Umgebungen/Geräten,
+Prüfung des Hardware-/Festplattenzustands, Backup, Planung/Automatisierung, Datenverarbeitung).
+
+Du erzeugst ZWEI Ebenen aus DEMSELBEN Abschnitt:
+
+ EXPERIENCES (prozedural, „wie man es macht“) — wiederverwendbare Methode, nur extrahiert,
+ wenn sie die unten stehende WERTSCHWELLE überwindet. Ein Bündel aus (task, search_keys, solution,
+ boundary_envs).
+
+ FACT (episodisch, „was diesmal passiert ist“) — GENAU EIN Datensatz über DIESE
+ Session: was der Nutzer wollte, wie vorgegangen wurde, wie es ausgegangen ist. Keine
+ Wertschwelle, aber es gibt nie mehr als einen.
+
+Die beiden Ebenen beantworten unterschiedliche Fragen und werden getrennt gespeichert. Eine Methode,
+die sich verallgemeinern lässt, gehört in EXPERIENCES; die Geschichte dieser konkreten Session —
+nur gültig für dieses System / dieses Projekt / genau jetzt — gehört in den FACT.
+
+═══════════════════════════════════════════════════════════════════
+WERTSCHWELLE (NUR FÜR EXPERIENCES) — überschreite sie NICHT leichtfertig.
+═══════════════════════════════════════════════════════════════════
+Eine Erinnerung MUSS ALLE folgenden Bedingungen erfüllen:
+ (a) Sie löst ein Problem, das beim selben Nutzer wahrscheinlich wieder auftritt
+ (b) Die Lösung ist nicht trivial: Sie kombiniert mehrere Informationen / Schritte, ODER
+ enthält eine Entscheidungsbegründung, ODER hält einen hart erkämpften Workaround fest, ODER ist ein
+ wiederverwendbares Verfahren/Rezept für eine operative Aufgabe (z. B. wie man die Festplattennutzung
+ analysiert und bereinigt, wie man Dateien stapelweise ordnet, wie man den Hardwarezustand
+ prüft, wie man einen geplanten Job einrichtet)
+ (c) Ein künftiger Agent / Nutzer würde es lieber nachschlagen, als es neu herauszufinden
+
+WICHTIG — Analyse-, Diagnose- und Untersuchungsaufgaben ZÄHLEN:
+Eine Aufgabe muss NICHTS ändern oder „reparieren“, um es wert zu sein, erinnert zu werden.
+Rein lesende / analytische / Fehlersuch-Arbeit ist wertvoll, wenn ihr VERFAHREN oder ihre
+SCHLUSSFOLGERUNG wiederverwendbar ist. Extrahiere ausdrücklich:
+ - Analyse-/Diagnoserezepte: das wiederverwendbare Verfahren + was es ergeben hat
+ (z. B. „wie man analysiert, welche Ordner den Platz auf Laufwerk C: belegen“ — die Scan-Befehle,
+ die Stolperfallen und der Befund). „Es wurde nur ein Bericht erzeugt, nichts geändert“
+ ist KEIN Grund zum Überspringen — die wiederverwendbare METHODE ist die Erinnerung.
+ - Untersuchungsergebnisse, EINSCHLIESSLICH negativer / Nicht-gefunden-Ergebnisse
+ (z. B. „Ordner X auf C: und D: mit rg / fs_search / SQL-Index gesucht —
+ nirgends gefunden“). Eine festgehaltene Sackgasse erspart dem nächsten Agenten, dieselbe
+ fruchtlose Suche zu wiederholen, und überwindet daher die Schwelle.
+Verwirf eine Erinnerung NICHT bloß deshalb, weil „der Assistent die Befehle neu
+erzeugen könnte“ oder „nichts tatsächlich geändert wurde“. Wenn das Verfahren oder die Schlussfolgerung
+künftigen Aufwand sparen würde, behalte sie.
+
+Extrahiere NICHT:
+ - Wirklich triviale Einzelschritt-Operationen ohne wiederverwendbares Verfahren („eine Datei umbenennen“,
+ „git status“, „einmal ls ausführen“)
+ - Einmalige, bereits gelöste Probleme ohne übertragbare Lehre
+ - Informationen, die bereits im Repo/System stehen (package.json nicht duplizieren)
+ - Wegwerfaufgaben pro PR / pro Session, es sei denn, sie enthalten ein wiederverwendbares Muster
+ - Das NACHFRAGEN BEIM NUTZER nach fehlenden Informationen. Einen Parameter anfordern,
+ auflisten, was unbekannt ist, oder Pflichtfelder erfragen ist Gesprächs-
+ verhalten, keine Methode: Jeder Agent weiß bereits, wie man eine Frage stellt, also
+ gibt es später nichts nachzuschlagen. Gib niemals eine Experience aus, deren task oder
+ search_keys die Form „wie man nach X fragt“, „das fehlende Y einsammeln“,
+ „Pflichtfelder erfragen“, „was vor dem Start zu klären ist“ haben. Beachte: Das
+ bleibt nur aus EXPERIENCES heraus — dass die Session mit dem Warten auf den Nutzer endete,
+ ist ein realer Zustand und gehört in den FACT.
+
+Wenn der Abschnitt keinen substanziellen Fortschritt gemacht hat, weil er beim Warten auf den
+Nutzer ins Stocken geriet — der Assistent hat nur nach Parametern gefragt oder wurde blockiert, bevor er
+echte Arbeit geleistet hat —, gib "experiences": [] aus und schreibe nur den FACT. Es wurde noch nichts
+gelernt, also gibt es keine Methode zu speichern. Das ist wichtiger, als es aussieht:
+Eine aus einem Stillstand destillierte Experience liest sich beim Abruf wie eine legitime Fähigkeit,
+und ein späterer Abschnitt derselben Aufgabe passt darauf und fragt den Nutzer erneut,
+statt weiterzumachen — so reproduziert sich der Stillstand für den Rest der
+Session. Beurteile die Substanz danach, was die Tools tatsächlich getan haben, nicht danach, ob der
+Wortwechsel flüssigen Text erzeugt hat.
+
+Faustregel: Wenn der Nutzer (oder ein künftiger Agent, der dieselbe Art von Aufgabe erledigt)
+das lieber aufgeschrieben hätte, statt es erneut herauszufinden, behalte es. Ein mehrstufiges
+operatives Verfahren (auch ein System-/Ops- oder ein rein lesendes Analyse-/Suchverfahren, nicht
+nur Code) qualifiziert sich in der Regel. Verwirf es nur, wenn es ein einzelner Befehl ist, den jeder Nutzer
+in 30 Sekunden über `--help` findet, UND es keine Entscheidung/Stolperfalle enthält, die es wert wäre,
+erinnert zu werden.
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE-FELDER
+═══════════════════════════════════════════════════════════════════
+
+task — Name in Anfrageform; formuliere so, wie ein Nutzer später FRAGEN würde.
+ „ein Release auf der xx-Plattform veröffentlichen“, nicht
+ „publish_release_internal“
+ In sich geschlossen (kein „dies“, „die Datei“, „wir“).
+
+search_keys — 0 bis 5 alternative Formulierungen, die wichtige Aspekte der
+ solution erfassen, auf die `task` allein nicht passen würde. Formuliere sie als Fragen
+ oder Themen, nach denen künftige Nutzer FRAGEN würden. Verschieden von task.
+ Weglassen, wenn task bereits alles abdeckt.
+
+solution — Vollständiger, in sich geschlossener Inhalt, den der Nutzer tatsächlich braucht:
+ Befehle, Speicherorte von Zugangsdaten (NICHT die WERTE der Zugangsdaten),
+ Dateipfade, geordnete Schritte, Stolperfallen, Entscheidungsbegründung.
+ Fasse mehrteilige End-to-End-Arbeit zu EINER solution zusammen, wenn sie
+ eine zusammenhängende Aufgabe bildet; teile nur dann in mehrere Erinnerungen auf, wenn
+ der Nutzer voneinander unabhängige Aufgaben erledigt hat.
+
+boundary_envs — Konkrete Festlegungen, von denen die solution abhängt, mehrzeilig als „key: value“:
+ Runtime / SDK / Bibliothek + Version
+ API-Endpunkt oder Methodensignatur
+ externer Dienst / Middleware-Version
+ NAME der Umgebungsvariable (nicht der Wert)
+ Pfad der Konfigurationsdatei
+ Host- / Cluster- / Regionskennung
+ Ist die solution umgebungsunabhängig, lass das Feld als "" (leer).
+ Zweck: Wenn das zugrunde liegende SDK / die Middleware aktualisiert wird, können künftige
+ Nutzer hier prüfen, ob die solution noch gilt.
+
+confidence — 0.0 bis 1.0
+ 1.0 der Nutzer hat dies ausdrücklich als Regel / Anweisung genannt
+ 0.7 mit guten Belegen aus Tool-Aktionen erschlossen
+ 0.5 schwach erschlossen; eine einzige Beobachtung; unsicher
+
+═══════════════════════════════════════════════════════════════════
+FACT-FELD — GENAU EINER pro Abschnitt, keine Wertschwelle
+═══════════════════════════════════════════════════════════════════
+
+Du schreibst EINEN Fact für den gesamten Abschnitt — einen wiederherstellbaren Zustandsdatensatz für diese
+Session, keinen polierten Rückblick und niemals eine Liste getrennter Befunde. Ein
+künftiger Agent muss daraus weitermachen können, ohne einen Vorschlag, eine
+Schlussfolgerung oder eine Teilsuche mit etwas Verifiziertem zu verwechseln.
+
+subject — WER oder WAS Gegenstand dieser Session ist: die einzelne Entität, an der oder für die
+ die Arbeit durchgeführt wurde. Eine kurze Nominalphrase, kein Satz, kein Verb.
+ Wähle die spezifischste Entität, um die es in der Session *geht*, nicht das
+ Tool, das verwendet wurde:
+ den Namen einer Person, wenn die Session einer namentlich genannten Person dient
+ ("Dylan", "Matthew")
+ die Datei / das Modul / das Symbol, wenn die Arbeit auf Code zielt
+ ("auth/middleware.ts", "parse_plan_text")
+ den Dienst / Host / das Gerät / das Laufwerk bei Ops-Arbeit
+ ("D:\\WXWork", "redis-cache-prod", "ci.yml")
+ Das ist ein HARTER SCHLÜSSEL, keine Prosa: Zwei Sessions über verschiedene Personen
+ oder verschiedene Dateien MÜSSEN verschiedene subjects erhalten, und zwei Sessions
+ über dieselbe MÜSSEN denselben String erhalten, identisch geschrieben.
+ Bevorzuge den exakten Bezeichner, wie er im Trace vorkommt, gegenüber einer
+ Beschreibung davon. Wenn der Abschnitt wirklich kein einzelnes Subjekt hat,
+ gib "" aus.
+
+ Warum es wichtig ist: subject ist das Tor, das entscheidet, ob eine spätere
+ Session diese als „dieselbe Aufgabe, fortgesetzt“ überschreiben darf. Wenn
+ es falsch ist, ersetzt der Zustand einer Person stillschweigend den einer anderen.
+
+statement — Ein kompakter Datensatz über DIESE Session. Zwei Teile, und der zweite ist
+ derjenige, der verloren geht.
+ Bewahre aufgabenbezogene Vorgaben und konkrete Einschränkungen, statt sie durch
+ eine allgemeine Bewertung des Ergebnisses zu ersetzen. Nenne
+ jede Regel einmal: wiederholter Anweisungstext konkurriert mit den Daten,
+ die die Erinnerung festhalten muss.
+
+ TEIL 1 — was passiert ist, etwa 300 lateinische Zeichen (~150 CJK).
+ Beginne mit dem konkreten Ziel und Objekt („den von D:\\WXWork belegten
+ Speicherplatz zurückgewinnen“, „den Ordner new_file_search finden“), nicht mit einem allgemeinen
+ „einen Bug beheben“ / „eine Datei finden“. Dann grob, was untersucht, versucht
+ oder geändert wurde. Dann, wie es endete, mit der Bedeutung genau eines von:
+ abgeschlossen, teilweise abgeschlossen, fehlgeschlagen, blockiert oder
+ noch zu verifizieren. Nenne negative Ergebnisse und Sackgassen,
+ ohne sie zu übertreiben.
+
+ TEIL 2 — die AUFGABENBEZOGENEN VORGABEN: alles, worauf die GESAMTE Aufgabe aufbaut,
+ auch wenn dieser Abschnitt es nicht festgelegt hat und auch wenn es sich
+ zu elementar anfühlt, um es zu nennen. Bindungen (wofür jeder Name / jedes Symbol / jedes Label
+ steht), feste Werte, die die Aufgabe vorgibt statt herleitet, übernommene
+ Konventionen (Indexbasis, Einheiten, Zeitzone, Standardwerte) und
+ das eigene Ergebnis dieses Abschnitts MIT seinem Wert („x = 7“, nicht „der Wert
+ wurde berechnet“).
+
+ Schreib TEIL 2 als Daten, ein Eintrag pro Zeile, Werte wie vorgegeben:
+ 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
+ Eine Zeile sollte fast nur aus Werten bestehen. Behalte die Notation des Traces —
+ Symbole, Einheiten, Zahlen, Schreibweisen — und lass seine Sätze weg: Streiche
+ die Wendungen, die eine Vorgabe ankündigen, statt selbst eine zu sein („ich würde
+ bevorzugen“, „es sollte irgendwo zwischen … und … liegen“). Sie wiederholen sich bei jedem
+ Eintrag, sodass eine Liste mit 15 Einträgen 15-mal dafür bezahlt.
+ Führe sie in JEDEM Fact mit; schreib niemals „wie oben“ oder „wie in der
+ vorherigen Session“ — der Abruf liefert eine Handvoll Facts nach
+ Ähnlichkeit, und das Bezugsobjekt ist womöglich nicht darunter.
+
+ Ziel: insgesamt unter 1200 Zeichen. Wenn TEIL 2 nicht hineinpasst, korrigiere die
+ Notation, niemals die Abdeckung: statement ist der Abrufvektor UND
+ das einzige Feld, das ein späterer Abschnitt lesen kann (details wird weder eingebettet
+ noch eingefügt), also ist alles, was daraus gestrichen wird, verloren. Verdichte die Formulierung
+ um eine Vorgabe herum, niemals die Vorgabe selbst.
+
+ Der Test: Wenn der nächste Abschnitt das ursprüngliche Material nicht sehen kann, kann
+ er allein anhand dieses Datensatzes weitermachen? Nur ein Ja zählt. Eine fehlende
+ Bindung scheitert nicht lautstark — der Name wirkt weiterhin bedeutungsvoll, also
+ wird er in seiner allgemeinen Bedeutung gelesen, und die Antwort, die
+ folgt, ist flüssig und betrifft eine andere Frage.
+
+ SPRACHE — dieselbe Sprache wie der Session-Trace: statement ist der
+ Abrufvektor, und Anfragen kommen in der Arbeitssprache des Nutzers,
+ also zahlt eine andere Sprache bei jedem Abruf einen sprachübergreifenden Malus.
+
+ TREUE ZU DEN BELEGEN — halte nur tatsächlich ausgeführte Aktionen und
+ explizit im Trace vorhandene Belege fest. Bewahre wesentliche
+ Befehle, Flags, Argumente, Fehler und Zahlen im Wortlaut.
+ Ergänze NIEMALS einen Befehl um übliche Flags und mache niemals
+ aus Ratschlägen oder Plänen Aktionen:
+ "ran Get-ChildItem -Force" → "ran Get-ChildItem"
+ (der Trace enthielt kein `-Force`; erfinde es nicht)
+ Begrenze jeden negativen Befund auf das, was tatsächlich durchsucht wurde, und
+ zähle JEDE explizite Abdeckungsgrenze auf, die ihn entkräften könnte,
+ insbesondere fehlende Berechtigungen und Tiefenbegrenzungen: Behalte die Wurzeln,
+ Filter und die Tiefe bei, die galten („nicht gefunden unter C:\\ und
+ D:\\ bis Tiefe 3; einige Verzeichnisse wurden wegen Access
+ denied nicht abgedeckt“), weite es niemals zu „existiert nicht“ aus. Lass keine Grenze
+ weg, um den Datensatz hübscher zu machen.
+ Mache aus einer Teilsuche niemals eine globale Abwesenheit.
+ Ein blockierter Versuch behält seinen Blocker.
+ Bewahre die Unterscheidung zwischen versucht, beobachtet, verifiziert,
+ erschlossen und ungelöst — drücke sie natürlich aus („versuchte …, wurde aber
+ durch Access denied blockiert“, „vermutlich …, noch nicht verifiziert“), nicht als
+ Labels. Ohne Tool-Ausgabe oder ausdrückliche Bestätigung behaupte NIEMALS, eine
+ Korrektur sei erfolgreich gewesen, eine Ursache sei festgestellt oder ein Pfad existiere nicht.
+
+ Halte KEINE Begrüßungen oder reines Geplauder fest — das ist der einzige Fall,
+ der "fact": null bekommt. Ein Abschnitt, der lediglich Anforderungen nannte oder
+ vor der eigentlichen Arbeit ins Stocken geriet, hat trotzdem etwas festgelegt.
+
+details — Die konkrete AUSGABE der Session, wörtlich übernommen. `statement` ist
+ eine Zusammenfassung, und eine Zusammenfassung lässt zwangsläufig die einzelnen Werte weg;
+ ein späterer Abruf will fast immer einen bestimmten Wert, nicht das Wesentliche.
+ Gib daher jedes adressierbare Ergebnis, das diese Session erzeugt hat,
+ hier in seiner ursprünglichen Form und Struktur wieder:
+ ein Plan / Zeitplan / eine Reiseroute → behalte jede Zeile, jeden Tag, jeden
+ Slot und jeden Preis genau wie geschrieben
+ ein Konfigurations- oder Codeblock → behalte den Block
+ die wesentliche Ausgabe eines Befehls → behalte die Zeilen, die die
+ Befunde tragen (Größen, Anzahlen, Versionen, Fehlertext)
+ ein strukturiertes Ergebnis (Tabelle, Liste von Datensätzen) → behalte die Zeilen
+ Bewahre das ursprüngliche Layout — Zeilenumbrüche, Präfixe wie `Day 1:` / key: value,
+ Einheiten, Währungssymbole, IDs. Nicht neu zusammenfassen, nicht
+ umordnen, keine Zahlen runden, nicht übersetzen.
+
+ Übernimm NUR, was im Trace vorhanden ist. Fülle niemals eine Lücke: Wenn ein Slot
+ leer gelassen wurde, lass ihn leer oder sag das — ein erfundener Wert
+ ist schlimmer als ein fehlender, weil er abgerufen und verwendet wird.
+ Obergrenze etwa 4000 Zeichen; ist die Ausgabe länger, behalte die Teile,
+ die konkrete Werte tragen, und lass schmückende Prosa weg, mit einem Hinweis darauf, was
+ weggelassen wurde.
+
+ "" wenn die Session kein solches Artefakt erzeugt hat (reine Untersuchung
+ noch ohne Befunde oder ein Stillstand beim Warten auf den Nutzer).
+
+ Dieses Feld ist NICHT Teil des Abrufvektors — `statement` und
+ `subject` sorgen fürs Finden, `details` liefert den Wert, sobald er gefunden ist.
+ Schreib hier also keinen Abruf-Köder und dupliziere nicht die
+ Zusammenfassung; schreib das Rohmaterial.
+
+files — 0..N absolute oder repo-relative DATEI- ODER VERZEICHNIS-Pfade, die in dieser Session
+ tatsächlich bearbeitet oder untersucht wurden. Behalte untersuchte
+ Wurzeln wie `C:\\` und `D:\\`. Nimm nur Pfade auf, auf die
+ tatsächlich zugegriffen bzw. die tatsächlich durchsucht wurden, keine lediglich vorgeschlagenen oder geplanten Pfade;
+ [] wenn keine zutreffen.
+═══════════════════════════════════════════════════════════════════
+HOST-KONTEXT (vom SDK übergeben)
+═══════════════════════════════════════════════════════════════════
+- workspace_id present: {workspace_present}
+- branch present: {branch_present}
+
+Wenn keine workspace_id vorhanden ist, darf sich die solution nicht auf unausgesprochenen
+projektlokalen Kontext stützen — schreib jedes Repo / jeden Pfad / jeden Dienst, den sie braucht, in
+`solution` oder `boundary_envs` aus, damit die Erinnerung für sich allein nutzbar bleibt.
+
+═══════════════════════════════════════════════════════════════════
+GESPRÄCH
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+AUSGABE (ausschließlich striktes JSON, kein Markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "subject": "...",
+ "statement": "...",
+ "files": ["..."],
+ "details": "..."
+ }}
+}}
+
+STANDARDMÄSSIG EXTRAHIEREN. Wenn der Abschnitt echte Arbeit geleistet hat, MUSST du mindestens
+eine Experience ausgeben — auch wenn die Aufgabe einfach aussieht oder auf Anhieb gelungen ist,
+halte trotzdem den wiederverwendbaren Kern des Getanen fest (die Methode / den Befehl / das How-to).
+Wenn die Session dünn ist, genügt die eine wertvollste Experience.
+
+Die EINZIGE Ausnahme ist der oben beschriebene Stillstand: Wenn der Abschnitt keine echte Arbeit geleistet hat,
+weil er beim Nachfragen nach fehlenden Informationen beim Nutzer blockiert war, gib
+"experiences": [] aus und schreibe nur den Fact. Erfinde keine Experience, um
+diese Anweisung zu erfüllen — eine erfundene („wie man nach der Abfahrts-
+stadt fragt“) ist schlimmer als keine, weil sie später abgerufen und befolgt wird. Leer ist
+NUR aus diesem Grund erlaubt, niemals als Abkürzung, wenn tatsächlich Arbeit geleistet wurde.
+
+"fact" ist ein EINZELNES Objekt, niemals eine Liste — ein Datensatz pro Session.
+
+Schreib IMMER den Fact. Die Schwelle für den Fact ist nicht „war das wertvoll“, sondern „ist
+überhaupt etwas passiert“, und ein Abschnitt, der dich erreicht, hat diese Schwelle bereits überwunden.
+Das gilt auch für Abschnitte, die eher nach Vorbereitung als nach Arbeit aussehen: Eine einzelne
+Nutzernachricht, die Anforderungen, Parameter oder einen Ausgangszustand nennt, ohne dass
+Tools ausgeführt wurden, ist genau das Material, das eine spätere Session nicht selbst rekonstruieren kann
+— schreib Anforderungen, Parameter und Ausgangszustand samt Situation in `statement` (kompakte Notation,
+keine wörtlichen Sätze aus dem Gespräch), schieb sie nicht in `details` ab (`details` geht nicht in den
+Abrufvektor ein und wird auf der Leseseite auch nicht mehr eingefügt). Verwende
+"fact": null NUR für Begrüßungen und reines Geplauder ganz ohne Inhalt.
+Im Zweifel schreib den Fact: Ein unnötiger Datensatz kostet eine Zeile, während ein weggelassener
+jede spätere Session kostet, die ihn gebraucht hätte und nicht wissen kann, dass er existierte.
+"""
+
+CODING_EXTRACT_PROMPT_CODING = """\
+╔═══════════════════════════════════════════════════════════════════════════╗
+║ HARTE VORGABE — lies das vor allem anderen; sie hat Vorrang vor jeder ║
+║ späteren Formulierung in diesem Prompt, die nach einer Erzählung klingt. ║
+║ ║
+║ Du schreibst KEINEN Bericht darüber, was eine Person getan hat. Du ║
+║ schreibst, was ein KÜNFTIGER AGENT braucht, um zu handeln. Dieser Agent ║
+║ hat bereits seine eigene Aufgabe; ihn interessiert nicht, was dieser ║
+║ Nutzer wollte. Er muss wissen: was hier entschieden wurde, an welchen ║
+║ Code-Koordinaten, was versucht und verworfen wurde und ob es verifiziert ║
+║ wurde. ║
+║ ║
+║ Konkret gilt in jedem `statement` und jeder `solution`: ║
+║ · Das grammatische Subjekt ist der CODE oder DIE ENTSCHEIDUNG — niemals ║
+║ „der Nutzer“ und niemals „der Agent“. Schreib nicht ║
+║ „Der Nutzer versuchte …“, „Der Nutzer wollte …“, ║
+║ „Der Agent prüfte dann …“. ║
+║ · Schließe niemals mit einer Buchhaltungsfloskel wie „die Session wurde ║
+║ abgeschlossen“, „der Fehler wurde notiert“, „noch keine Lösung ║
+║ gefunden“. Schließe mit der Entscheidung und ihrem ║
+║ Verifikationsstatus. Wurde nichts entschieden, schließe mit dem, was ║
+║ AUSGESCHLOSSEN wurde, und der nächsten unerforschten Spur — das ist ║
+║ der wiederverwendbare Teil. ║
+║ · Behalte das konkrete Symptom (Fehlerstring, fehlschlagender Befehl, ║
+║ falsche Ausgabe) — genau darauf trifft eine künftige Suche. ║
+║ ║
+║ schlecht: „Der Nutzer versuchte, eine QTable mit header_rows als RST zu ║
+║ schreiben, und bekam einen TypeError. Die Session wurde mit ║
+║ notiertem Fehler abgeschlossen.“ ║
+║ gut: „Der RST-Writer von ascii.rst lehnt header_rows ab: ║
+║ `tbl.write(..., format='ascii.rst', header_rows=['name','unit'])` ║
+║ löst TypeError aus, weil RST.__init__ es nicht weiterreicht, ║
+║ anders als ascii.fixed_width, das es akzeptiert. Kein Fix ║
+║ geschrieben — der Writer braucht dieselbe ║
+║ header_rows-Durchreichung wie fixed_width.“ ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+
+Du extrahierst dauerhafte WORKING-Erinnerungen aus einem Abschnitt einer Aufgabenausführungs-Session.
+Eine „working“-Session ist jede praktische Aufgabe, bei der der Nutzer einen Computer /
+ein System über Tools bedient — das umfasst SOWOHL Software-/Code-Arbeit (Schreiben, Debuggen,
+Refactoring, Bauen, Deployen, Nutzung von APIs/Bibliotheken) ALS AUCH System- und Betriebs-
+arbeit (Ausführen von Shell-/PowerShell-Befehlen, Analyse oder Bereinigung von Festplatten/Speicher, Datei-
+& Ordneroperationen, Installieren/Konfigurieren von Software, Einrichten von Umgebungen/Geräten,
+Prüfung des Hardware-/Festplattenzustands, Backup, Planung/Automatisierung, Datenverarbeitung).
+
+Du erzeugst ZWEI Ebenen aus DEMSELBEN Abschnitt:
+
+ EXPERIENCES (prozedural, „wie man es macht“) — wiederverwendbare Methode, nur extrahiert,
+ wenn sie die unten stehende WERTSCHWELLE überwindet. Ein Bündel aus (task, search_keys, solution,
+ boundary_envs).
+
+ FACT (episodisch, „was diesmal festgelegt wurde“) — GENAU EIN Datensatz über DIESE
+ Session. Er ist KEINE Erzählung dessen, was der Nutzer getan hat. Er hält in dieser Reihenfolge fest:
+ die Aufgabe und ihr konkretes Symptom (das macht ihn später auffindbar), die
+ Code-Koordinaten, WORAUF MAN SICH FESTGELEGT HAT und was verworfen wurde, und wie weit es
+ verifiziert wurde. Keine Wertschwelle, aber es gibt nie mehr als einen.
+
+Die beiden Ebenen beantworten unterschiedliche Fragen und werden getrennt gespeichert. Eine Methode,
+die sich verallgemeinern lässt, gehört in EXPERIENCES; die Geschichte dieser konkreten Session —
+nur gültig für dieses System / dieses Projekt / genau jetzt — gehört in den FACT.
+
+═══════════════════════════════════════════════════════════════════
+WERTSCHWELLE (NUR FÜR EXPERIENCES) — überschreite sie NICHT leichtfertig.
+═══════════════════════════════════════════════════════════════════
+Eine Erinnerung MUSS ALLE folgenden Bedingungen erfüllen:
+ (a) Sie löst ein Problem, das beim selben Nutzer wahrscheinlich wieder auftritt
+ (b) Die Lösung ist nicht trivial: Sie kombiniert mehrere Informationen / Schritte, ODER
+ enthält eine Entscheidungsbegründung, ODER hält einen hart erkämpften Workaround fest, ODER ist ein
+ wiederverwendbares Verfahren/Rezept für eine operative Aufgabe (z. B. wie man die Festplattennutzung
+ analysiert und bereinigt, wie man Dateien stapelweise ordnet, wie man den Hardwarezustand
+ prüft, wie man einen geplanten Job einrichtet)
+ (c) Ein künftiger Agent / Nutzer würde es lieber nachschlagen, als es neu herauszufinden
+
+WICHTIG — Analyse-, Diagnose- und Untersuchungsaufgaben ZÄHLEN:
+Eine Aufgabe muss NICHTS ändern oder „reparieren“, um es wert zu sein, erinnert zu werden.
+Rein lesende / analytische / Fehlersuch-Arbeit ist wertvoll, wenn ihr VERFAHREN oder ihre
+SCHLUSSFOLGERUNG wiederverwendbar ist. Extrahiere ausdrücklich:
+ - Analyse-/Diagnoserezepte: das wiederverwendbare Verfahren + was es ergeben hat
+ (z. B. „wie man analysiert, welche Ordner den Platz auf Laufwerk C: belegen“ — die Scan-Befehle,
+ die Stolperfallen und der Befund). „Es wurde nur ein Bericht erzeugt, nichts geändert“
+ ist KEIN Grund zum Überspringen — die wiederverwendbare METHODE ist die Erinnerung.
+ - Untersuchungsergebnisse, EINSCHLIESSLICH negativer / Nicht-gefunden-Ergebnisse
+ (z. B. „Ordner X auf C: und D: mit rg / fs_search / SQL-Index gesucht —
+ nirgends gefunden“). Eine festgehaltene Sackgasse erspart dem nächsten Agenten, dieselbe
+ fruchtlose Suche zu wiederholen, und überwindet daher die Schwelle.
+Verwirf eine Erinnerung NICHT bloß deshalb, weil „der Assistent die Befehle neu
+erzeugen könnte“ oder „nichts tatsächlich geändert wurde“. Wenn das Verfahren oder die Schlussfolgerung
+künftigen Aufwand sparen würde, behalte sie.
+
+Extrahiere NICHT:
+ - Wirklich triviale Einzelschritt-Operationen ohne wiederverwendbares Verfahren („eine Datei umbenennen“,
+ „git status“, „einmal ls ausführen“)
+ - Einmalige, bereits gelöste Probleme ohne übertragbare Lehre
+ - Informationen, die bereits im Repo/System stehen (package.json nicht duplizieren)
+ - Wegwerfaufgaben pro PR / pro Session, es sei denn, sie enthalten ein wiederverwendbares Muster
+
+Faustregel: Wenn der Nutzer (oder ein künftiger Agent, der dieselbe Art von Aufgabe erledigt)
+das lieber aufgeschrieben hätte, statt es erneut herauszufinden, behalte es. Ein mehrstufiges
+operatives Verfahren (auch ein System-/Ops- oder ein rein lesendes Analyse-/Suchverfahren, nicht
+nur Code) qualifiziert sich in der Regel. Verwirf es nur, wenn es ein einzelner Befehl ist, den jeder Nutzer
+in 30 Sekunden über `--help` findet, UND es keine Entscheidung/Stolperfalle enthält, die es wert wäre,
+erinnert zu werden.
+
+═══════════════════════════════════════════════════════════════════
+CODE-ARBEIT — was ein künftiger Agent nicht neu herleiten kann und daher erfasst werden MUSS
+═══════════════════════════════════════════════════════════════════
+Wenn der Abschnitt Softwarearbeit an einem Repository ist, ist die wiederverwendbare Methode nur
+die Hälfte. Die andere Hälfte ist, WO die Arbeit liegt und WELCHE VERSION gewonnen hat. Das lässt sich
+später nicht durch Lesen des Codes wiederherstellen — der Code zeigt den aktuellen Zustand,
+nicht, auf welchem Branch er liegt, und auch nicht, was bereits verworfen wurde.
+
+Dieser Abschnitt verlangt KEINEN längeren Datensatz. Er verlangt, DASSELBE BUDGET
+für wertvollere Tokens AUSZUGEBEN: Lass wiederholte Ziele weg, die Erzählung dessen, was der
+Assistent „dann beschloss“, und eingefügten Code, den du nur wiedergibst; verwende diese
+Zeichen stattdessen für die vier folgenden Punkte. Ein Datensatz, der den Branch weglässt, aber
+30 Zeilen Diff zitiert, ist ein schlechter Tausch.
+
+1. BRANCH / ARBEITSORT — im Wortlaut, im `statement` des Facts. Wenn der Abschnitt
+ `feat/x` / `fix/y` erwähnt oder auscheckt, MUSS dieses Token erscheinen. Ein Agent,
+ der auf dem falschen Branch weitermacht, erzeugt Änderungen, die stillschweigend verworfen werden,
+ daher wiegt dieses eine Token schwerer als jedes andere Detail.
+
+2. WELCHE VERSION GEWONNEN HAT — wenn der Nutzer seine Meinung geändert hat, nenne den Gewinner und markiere
+ den Verlierer in einem Satzteil: „festgelegt auf A; die Zwischenversion B wurde verworfen“. Nicht beide
+ vollständig — ein Satzteil. Nur die neueste zu behalten ist falsch: Ein Agent, der auf den
+ verworfenen Code stößt, muss ihn erkennen, sonst „repariert“ er die Dinge zurück zur verworfenen
+ Variante. Wendungen wie `scratch that / go back to / actually, let's / no, not that`
+ (bzw. „vergiss das / zurück zu / eigentlich lass uns / nein, nicht das“)
+ markieren das: Was folgt, gilt; was vorausgeht, ist überholt.
+
+3. EXAKTE KOORDINATEN, KEIN EINGEFÜGTER CODE — repo-relativer Pfad
+ (`qutebrowser/utils/debug.py`, niemals bloß `debug.py`) plus die berührte Funktion /
+ Klasse. Wenn sich eine Signatur geändert hat, gib die neue Signatur an. Wenn eine Konstante,
+ ein Regex oder ein Literal festgelegt wurde, zitiere GENAU DAS im Wortlaut — aber nur das, nicht den
+ umgebenden Block. Eine genaue Zeile schlägt einen Absatz voller Näherungen.
+
+4. VERIFIZIERT vs. NUR GESCHRIEBEN — wenige Wörter genügen („Tests ausgeführt und bestanden“ /
+ „nur per git diff bestätigt, Tests nicht ausgeführt“). „Die Änderung ist drin“ und „die Änderung ist drin
+ und getestet“ führen einen künftigen Agenten zu sehr unterschiedlichen nächsten Schritten.
+
+Anti-Muster — das Ziel zusammenfassen und die Koordinaten weglassen:
+ schlecht: „hat die Logik zum Parsen von Farben sauberer umgebaut.“
+ gut: „auf feat/q4, in qutebrowser/config/configtypes.py QtColor._parse_value:
+ festgelegt auf `mult = 360.0 if kind == 'h' else 255.0`; die Zwischenversion, die
+ für alles 255.0 verwendete, wurde verworfen. Tests nicht ausgeführt.“
+ (die gute Variante ist KÜRZER als die meisten schlechten — sie verwendet nur jedes Zeichen
+ für etwas, das sich nicht neu herleiten lässt)
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE-FELDER
+═══════════════════════════════════════════════════════════════════
+
+task — Name in Anfrageform; formuliere so, wie ein Nutzer später FRAGEN würde.
+ „ein Release auf der xx-Plattform veröffentlichen“, nicht „publish_release_internal“
+ In sich geschlossen (kein „dies“, „die Datei“, „wir“).
+
+search_keys — 0 bis 5 alternative Formulierungen, die wichtige Aspekte der
+ solution erfassen, auf die `task` allein nicht passen würde. Formuliere sie als Fragen
+ oder Themen, nach denen künftige Nutzer FRAGEN würden. Verschieden von task.
+ Weglassen, wenn task bereits alles abdeckt.
+
+solution — Vollständiger, in sich geschlossener Inhalt, den der Nutzer tatsächlich braucht:
+ Befehle, Speicherorte von Zugangsdaten (NICHT die WERTE der Zugangsdaten),
+ Dateipfade, geordnete Schritte, Stolperfallen, Entscheidungsbegründung.
+ Fasse mehrteilige End-to-End-Arbeit zu EINER solution zusammen, wenn sie
+ eine zusammenhängende Aufgabe bildet; teile nur dann in mehrere Erinnerungen auf, wenn
+ der Nutzer voneinander unabhängige Aufgaben erledigt hat.
+
+boundary_envs — Konkrete Festlegungen, von denen die solution abhängt, mehrzeilig als „key: value“:
+ Runtime / SDK / Bibliothek + Version
+ API-Endpunkt oder Methodensignatur
+ externer Dienst / Middleware-Version
+ NAME der Umgebungsvariable (nicht der Wert)
+ Pfad der Konfigurationsdatei
+ Host- / Cluster- / Regionskennung
+ Ist die solution umgebungsunabhängig, lass das Feld als "" (leer).
+ Zweck: Wenn das zugrunde liegende SDK / die Middleware aktualisiert wird, können künftige
+ Nutzer hier prüfen, ob die solution noch gilt.
+
+confidence — 0.0 bis 1.0
+ 1.0 der Nutzer hat dies ausdrücklich als Regel / Anweisung genannt
+ 0.7 mit guten Belegen aus Tool-Aktionen erschlossen
+ 0.5 schwach erschlossen; eine einzige Beobachtung; unsicher
+
+═══════════════════════════════════════════════════════════════════
+FACT-FELD — GENAU EINER pro Abschnitt, keine Wertschwelle
+═══════════════════════════════════════════════════════════════════
+
+Du schreibst EINEN Fact für den gesamten Abschnitt — einen wiederherstellbaren Zustandsdatensatz für diese
+Session, keinen polierten Rückblick und niemals eine Liste getrennter Befunde. Ein
+künftiger Agent muss daraus weitermachen können, ohne einen Vorschlag, eine
+Schlussfolgerung oder eine Teilsuche mit etwas Verifiziertem zu verwechseln.
+
+statement — Eine kompakte Zusammenfassung DIESER Session. Sie hat zwei Aufgaben zugleich und
+ muss BEIDE erfüllen: Sie ist der Abrufvektor (ein künftiger Agent findet sie, indem er
+ mit einer neuen Problemmeldung sucht, formuliert so, wie ein Nutzer ein
+ Problem formuliert), und sie ist die Nutzlast, auf deren Grundlage dieser Agent dann handelt. Also:
+
+ BEGINNE mit der Aufgabe und dem Symptom, in den Worten, die ein Nutzer verwenden würde.
+ Das macht sie auffindbar — halte die Oberflächenform nah daran, wie das
+ Problem gemeldet würde. Nenne das konkrete Ziel und Objekt
+ („Speicherplatz unter D:\\WXWork zurückgewinnen“, „den Farbton-Multiplikator
+ in QtColor._parse_value auf feat/q4 anpassen“, „den Ordner new_file_search
+ finden“), niemals ein allgemeines „einen Bug beheben“ / „nach einer Datei suchen“. Nenne
+ das konkrete Symptom: den Fehlerstring, den fehlschlagenden Befehl, die
+ falsche Ausgabe.
+
+ DANN nenne die Koordinaten und die Entscheidung.
+ Repo-relativer Pfad, Symbol und Branch bei Code-Arbeit. Gib an, worauf
+ man sich FESTGELEGT hat, und markiere im selben Satzteil, was verworfen wurde
+ („festgelegt auf X; die Zwischenversion Y wurde verworfen“). Das ist der Teil, der
+ sich nicht durch Lesen des Codes neu herleiten lässt — der Code zeigt nur den
+ Gewinner, niemals, dass Y versucht und verworfen wurde. Ein Agent, der später auf die
+ verworfene Variante stößt, muss sie erkennen können, sonst
+ „repariert“ er den Code zurück zur verworfenen Version.
+
+ SCHLIESSE mit dem Belegstatus.
+ Genau eines von: abgeschlossen, teilweise abgeschlossen, fehlgeschlagen, blockiert oder
+ noch zu verifizieren — plus wie es geprüft wurde („Tests ausgeführt und
+ bestanden“ / „nur per git diff bestätigt, Tests nicht ausgeführt“). Nenne
+ negative Ergebnisse und Sackgassen, ohne sie zu übertreiben.
+
+ ⚠️ Hör niemals bei der Erzählung auf. „Der Nutzer versuchte X und stieß auf Fehler Y; noch
+ keine Lösung gefunden“ ist ein verschwendeter Datensatz: Er wird problemlos abgerufen, gibt einem
+ künftigen Agenten aber nichts, womit er handeln kann. Wenn die Session wirklich zu keiner
+ Entscheidung gekommen ist, nenne, was ausgeschlossen wurde und was die nächste unerforschte Spur ist —
+ das ist der wiederverwendbare Teil.
+
+ Das Subjekt der Sätze sollte der Code und die Entscheidung sein, nicht
+ „der Nutzer“. 2 bis 4 Sätze, fließende Prosa, keine beschrifteten Abschnitte.
+ Harte Obergrenze ~400 lateinische Zeichen (~200 CJK-Zeichen).
+
+ TREUE ZU DEN BELEGEN — verpflichtend:
+ - Halte nur tatsächlich ausgeführte Aktionen und explizit im Trace
+ vorhandene Belege fest. Bewahre wesentliche Befehle, Flags,
+ Argumente, Fehler und Zahlen im Wortlaut. Ergänze NIEMALS einen
+ Befehl um übliche Flags und mache aus Ratschlägen/Plänen keine Aktionen.
+ - Bewahre die Unterscheidung zwischen versucht, beobachtet, verifiziert,
+ erschlossen und ungelöst. Füge diese Labels nicht in die Prosa ein;
+ drücke ihre Bedeutung natürlich aus, z. B. „versuchte …, wurde aber durch
+ Access denied blockiert“ oder „vermutlich … , noch nicht verifiziert“.
+ - Ohne Tool-Ausgabe oder ausdrückliche Bestätigung behaupte NIEMALS, eine Korrektur
+ sei erfolgreich gewesen, eine Ursache sei festgestellt, eine Datei / ein Ordner existiere
+ nicht oder Tests seien bestanden.
+ - Begrenze jeden negativen Befund auf das, was tatsächlich durchsucht wurde, und
+ zähle JEDE explizite Abdeckungsgrenze auf, die ihn entkräften könnte,
+ insbesondere fehlende Berechtigungen und die maximale Suchtiefe:
+ „nicht gefunden in den durchsuchten Teilen von C:\\ und D:\\; einige
+ Verzeichnisse wurden wegen Access denied übersprungen, und die Suche war zudem
+ tiefenbegrenzt“. Lass keine Grenze weg, um die
+ Zusammenfassung hübscher zu machen. Mache aus einer Teilsuche niemals eine globale
+ Abwesenheit.
+ - Stelle Kausalität nur dann als sicher dar, wenn der Trace sie direkt verifiziert.
+ Andernfalls behalte die Einschränkung bei („vermutet“ / „erschlossen“ / „noch nicht
+ verifiziert“); schreib eine
+ falsche Testannahme nicht in die Grundursache des Systems um.
+
+ ENTSCHEIDEND — dieser Text IST der Abrufvektor, und er ist das Einzige,
+ womit eine künftige Anfrage abgeglichen wird. Eine allgemeine Zusammenfassung ist
+ wertlos, denn JEDE Session sieht aus wie eine allgemeine Zusammenfassung: Sie
+ würde auf jede Anfrage passen und keine beantworten. Daher MUSST du
+ die konkreten Anker nennen, die DIESE Session auffindbar machen — echte Datei-
+ pfade, Funktions- / Symbolnamen, Branch-Namen, Befehle, Fehler-
+ strings, Versionen, Konfigurationsschlüssel und -werte, Host- / Dienstnamen.
+ Wenn später jemand nach einem dieser Details sucht, muss diese
+ Zusammenfassung das sein, was zurückkommt.
+ gut: „Behebung eines fehlschlagenden `npm run build` in CI. .github/workflows/ci.yml
+ und package.json gelesen; zurückgeführt auf webpack 5.74, das unter node 18
+ auf ERR_OSSL_EVP_UNSUPPORTED stößt. Das Anheben von node im Workflow auf 20
+ ließ den Build durchlaufen; mit node 18 lässt sich der Fehler lokal weiterhin reproduzieren.“
+ gut: „auf Branch feat/q0, in qutebrowser/utils/debug.py signal_name:
+ PyQt<5.11 gibt den Namen nur über repr(sig) preis, und repr kommt sowohl
+ in einer Form mit eckigen als auch mit runden Klammern. Festgelegt auf zwei Muster,
+ die nacheinander mit fullmatch geprüft werden, Abbruch beim ersten Treffer; die
+ Variante mit einem einzigen Regex wurde verworfen. Per git diff bestätigt, Tests
+ nicht ausgeführt.“
+ schlecht: „Nutzer wollte einen Build-Bug behoben haben, der Agent hat sich ein paar Konfigurations-
+ dateien angesehen, etwas Code geändert und es behoben.“
+ (kein Pfad, kein Befehl, kein Fehlerstring, keine Version — nichts,
+ worauf ein Abruf greifen könnte; jede Session liest sich genau so)
+ schlecht: „Kompatibilitätsproblem beim Parsen von Signalnamen auf einem Feature-
+ Branch behoben.“
+ (welcher Branch? welche Datei? welche Funktion? welche der beiden
+ konkurrierenden Versionen hat gewonnen? nichts davon übersteht einen
+ Abruf eine Woche später)
+ Beispiele zur Belegtreue (schlecht → gut):
+ "ran Get-ChildItem -Force" → "ran Get-ChildItem"
+ (der Trace enthielt kein `-Force`; erfinde es nicht)
+ „bestätigt, dass new_file_search nicht existiert“ →
+ „new_file_search wurde in den durchsuchten Teilen von C:\\ und
+ D:\\ nicht gefunden; einige Verzeichnisse wurden wegen Access denied oder durch die Tiefen-
+ begrenzung übersprungen, die Untersuchung ist also nur teilweise abgeschlossen“
+ „identische Payloads verursachen einen fälschlichen Lock-Fehler“ →
+ „das Verifikationsskript nahm an, der letzte Schreiber sei immer ein fester
+ Rang; diese Annahme gilt nicht, ob es also einen Lock-Bug gibt,
+ ist noch nicht verifiziert“
+
+ Halte KEINE Begrüßungen oder reines Geplauder fest. Wenn der Abschnitt
+ überhaupt nichts festgelegt hat, gib "fact": null aus.
+
+files — 0..N absolute oder repo-relative DATEI- ODER VERZEICHNIS-Pfade, die in dieser Session
+ tatsächlich bearbeitet oder untersucht wurden. Behalte untersuchte
+ Wurzeln wie `C:\\` und `D:\\`. Nimm nur Pfade auf, auf die
+ tatsächlich zugegriffen bzw. die tatsächlich durchsucht wurden, keine lediglich vorgeschlagenen oder geplanten Pfade;
+ [] wenn keine zutreffen.
+
+═══════════════════════════════════════════════════════════════════
+HOST-KONTEXT (vom SDK übergeben)
+═══════════════════════════════════════════════════════════════════
+- workspace_id present: {workspace_present}
+- branch present: {branch_present}
+
+Wenn keine workspace_id vorhanden ist, darf sich die solution nicht auf unausgesprochenen
+projektlokalen Kontext stützen — schreib jedes Repo / jeden Pfad / jeden Dienst, den sie braucht, in
+`solution` oder `boundary_envs` aus, damit die Erinnerung für sich allein nutzbar bleibt.
+
+═══════════════════════════════════════════════════════════════════
+GESPRÄCH
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+AUSGABE (ausschließlich striktes JSON, kein Markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "statement": "...",
+ "files": ["..."]
+ }}
+}}
+
+VERPFLICHTEND: Du MUSST mindestens EINE Experience ausgeben. Gib KEINE leere Liste zurück.
+Auch wenn die Aufgabe einfach aussieht oder auf Anhieb gelungen ist, halte trotzdem den
+wiederverwendbaren Kern des Getanen fest (die Methode / den Befehl / das How-to). Wenn die Session dünn ist,
+ist nur die eine wertvollste Experience erforderlich — aber gib niemals
+ein leeres "experiences"-Array aus.
+
+"fact" ist ein EINZELNES Objekt, niemals eine Liste — ein Datensatz pro Session. Verwende
+"fact": null nur, wenn der Abschnitt reines Geplauder ist, das nichts festgelegt hat.
+"""
+
+CODING_RECONCILE_PROMPT = """\
+Du entscheidest, wie neue Entwürfe für Coding-Erinnerungen mit den bestehenden Erinnerungen des Nutzers zusammengeführt werden.
+
+Entscheide für jeden neuen Entwurf eines von:
+ ADD — keine bestehende Erinnerung beschreibt dieselbe Aufgabe / denselben Aspekt
+ UPDATE — eine bestehende Erinnerung beschreibt dieselbe Aufgabe; der neue Entwurf ersetzt sie
+ (die solution kann sich geändert haben, die Umgebung kann aktualisiert worden sein usw.)
+ SKIP — Duplikat einer bestehenden Erinnerung; nichts Neues
+
+Zusätzlich darfst du DELETE-Operationen für bestehende Kandidaten ausgeben, wenn der neue
+Inhalt sie überholt oder ungültig macht:
+ DELETE — das neue Gespräch ersetzt/storniert/entwertet AUSDRÜCKLICH eine
+ bestehende Erinnerung, die sich nicht per UPDATE reparieren lässt. Beispiele:
+ * der Nutzer sagt „verwende X nicht mehr“, und X existiert nur als
+ separate Erinnerung (nicht die, die hinzugefügt/aktualisiert wird)
+ * die boundary_envs des Kandidaten (Dienst / Endpunkt / SDK) existieren nicht mehr,
+ und das neue Gespräch bestätigt die Abkündigung
+
+Regeln:
+- „Dieselbe Aufgabe“ bedeutet, dass die bestehende Erinnerung und der neue Entwurf beide gültige
+ Antworten auf dieselbe künftige Nutzeranfrage wären.
+- Wenn sich die solution unterscheidet, bevorzuge UPDATE (wir führen keine Historie).
+- Wenn sowohl task als auch solution weitgehend übereinstimmen, SKIP.
+- DELETE nur, wenn es AUSDRÜCKLICHE Belege dafür gibt, dass der Kandidat ungültig/überholt ist.
+ Niemals DELETE, nur weil ein Kandidat „veraltet“ aussieht.
+- Es kann mehr Ausgabe-Operationen als Entwürfe geben, wenn DELETEs erzeugt werden.
+
+═══════════════════════════════════════════════════════════════════
+NEUE ENTWÜRFE
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+BESTEHENDE KANDIDATEN (pro Entwurf, abgerufen nach Ähnlichkeit der Aufgabe)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+AUSGABE (ausschließlich striktes JSON, kein 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": "Nutzer hat Y ausdrücklich für veraltet erklärt"}},
+ {{"draft_idx": 2, "action": "SKIP", "reason": "Duplikat"}}
+ ]
+}}
+
+Wenn es keine Entwürfe gibt, gib {{"ops": []}} aus.
+"""
+
+CODING_FACT_RECONCILE_PROMPT = """\
+Du pflegst WORKING FACTS auf Session-Ebene. Jedes statement fasst einen ganzen
+Trace / eine ganze Session zusammen: die Aufgabe des Nutzers, das grobe Vorgehen und das Ergebnis. Es ist keine
+atomare Aussage.
+
+Jeder unten stehende neue Session-Fact WIRD gespeichert; das ist nicht deine Entscheidung. Deine einzige
+Aufgabe ist es, Fortsetzungen von Aufgaben zu erkennen: Treibt die neue Session DIESELBE
+Nutzeraufgabe weiter voran wie ein bestehender Session-Fact? Wenn ja, ersetze den älteren Fact per SUPERSEDE, sodass
+die Verknüpfungen eine sessionübergreifende Fortschrittskette für diese Aufgabe bilden.
+
+Markiere einen bestehenden Fact NUR dann als ersetzt, wenn es starke Belege dafür gibt, dass:
+ - die Subjekte übereinstimmen: beide Datensätze betreffen DIESELBE Entität — dieselbe
+ Person, dieselbe Datei / dasselbe Modul, denselben Host / Dienst. Ein gemeinsames Subjekt ist
+ notwendig, aber nicht hinreichend; UND
+ - das Ziel des Nutzers im Wesentlichen DASSELBE ist, nicht bloß im selben Thema/Projekt liegt;
+ UND
+ - der neue Trace die im bestehenden Trace festgehaltene Arbeit fortsetzt, wiederholt, erweitert, verifiziert oder
+ abschließt.
+
+Ersetze NICHT, wenn:
+ - die beiden Datensätze verschiedene Subjekte nennen. Zwei Personen in einer Gruppe, zwei Dateien
+ in einem Modul, zwei Hosts in einem Cluster sind PARALLEL, nicht aufeinanderfolgend: Der Zustand einer
+ Person ist keine neuere Version des Zustands einer anderen. Wo ein Subjekt
+ als (unspecified) angezeigt wird, urteile ersatzweise allein anhand des statement.
+ - die Sessions lediglich dieselbe Datei, dasselbe Symbol, dieselbe Komponente, dasselbe Repository,
+ denselben Fehler oder dieselbe Technologie erwähnen, aber unterschiedliche Nutzerziele verfolgen.
+ - eine Aufgabe lediglich Kontext oder eine Technik für eine andere Aufgabe liefert.
+ - die Beziehung unsicher ist. Sei konservativ: INSERT ist der sichere Standard;
+ das Zusammenführen unabhängiger Sessions zerstört ihre getrennte Aufgabenhistorie.
+
+Behandle jedes statement als belegbegrenzten Text. Deute eine Schlussfolgerung darin
+nicht in eine festgestellte Ursache um und verwende eine gemeinsame Vermutung / einen gemeinsamen Fehler nicht als Beweis dafür, dass
+die Nutzerziele dieselben sind. Deine Entscheidung betrifft ausschließlich die Fortsetzung der Aufgabe;
+„korrigiere“, ergänze oder beschönige keinen der beiden Session-Datensätze.
+
+Beispiele:
+ bestehend: „Der Nutzer musste das npm run build in CI reparieren; zurückgeführt auf
+ ERR_OSSL_EVP_UNSUPPORTED unter Node 18, Workflow noch nicht geändert.“
+ neu: „Der Nutzer setzte die Reparatur desselben CI-Builds fort; Node in
+ .github/workflows/ci.yml auf 20 angehoben, und npm run build lief durch.“
+ → SUPERSEDE
+
+ bestehend: „Der Nutzer musste die Behandlung abgelaufener JWTs in
+ auth/middleware.ts korrigieren; eine Refresh-Logik wurde hinzugefügt.“
+ neu: „Der Nutzer wollte Performance-Logging in
+ auth/middleware.ts ergänzen; eine Latenzmetrik wurde eingeführt.“
+ → beide behalten
+ (dieselbe Datei / dasselbe Projekt, anderes Nutzerziel)
+
+═══════════════════════════════════════════════════════════════════
+NEUE SESSION-FACTS
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+BESTEHENDE SESSION-FACTS (pro neuem Fact, abgerufen nach Ähnlichkeit des statement)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+AUSGABE (ausschließlich striktes JSON, kein Markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "ops": [
+ {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "setzt dieselbe CI-Reparatur fort"}},
+ {{"draft_idx": 1, "supersedes": []}}
+ ]
+}}
+
+Verwende nur Fact-IDs, die in der Kandidatenliste für genau diesen draft_idx erscheinen.
+Wenn nirgends etwas ersetzt wird, gib {{"ops": []}} aus.
+"""
+
+CODING_CHAIN_SUMMARY_PROMPT = """\
+Eine Nutzeraufgabe in einem Working-Memory-Speicher ist über mehrere Sessions vorangekommen. Unten stehen
+die Session-Zusammenfassungen in der Fortschrittskette dieser Aufgabe, die älteste zuerst, endend mit
+der aktuellen Session.
+
+Fasse zusammen, wie DIESELBE Aufgabe über die Sessions hinweg bis zu ihrem aktuellen Stand vorangekommen ist.
+Decke jede wichtige Phase in chronologischer Reihenfolge ab. Bewahre für jede Phase,
+soweit vorhanden: die tatsächliche Aktion oder Änderung, ihr direktes Ergebnis und jedes
+ungelöste Problem oder jede einschränkende Bedingung. Schließe mit einem ausdrücklichen aktuellen Status.
+
+Regeln:
+ - Dies ist reine Verdichtung. Gib NUR wieder, was die Einträge sagen; füge niemals einen Befehl,
+ eine Ursache, ein Motiv, eine Aktion, ein Testergebnis, einen Erfolgszustand oder eine
+ globale negative Schlussfolgerung hinzu und ergänze nichts davon.
+ - Bewahre den Belegstatus exakt: versucht ist nicht abgeschlossen, beobachtet ist
+ nicht verifiziert, erschlossen ist nicht festgestellt, und ungelöst bleibt ungelöst.
+ Behalte Unsicherheitswörter und Grenzen von Suche/Berechtigung/Abdeckung bei.
+ - Gib den aktuellen Endstatus getreu wieder (abgeschlossen, teilweise abgeschlossen,
+ fehlgeschlagen, blockiert oder noch zu verifizieren). Werte ihn niemals auf, gestützt auf
+ eine plausible Kausalgeschichte oder einen späteren Eintrag, der ihn nicht verifiziert hat.
+ - Wenn Einträge eine vermutete Ursache und ein späteres Ergebnis nennen, verknüpfe sie nur dann
+ kausal, wenn ein Eintrag direkt sagt, dass diese Ursache verifiziert wurde.
+ - Bewahre konkrete Abrufanker: Dateipfade, Symbole, Befehle, Fehler-
+ strings, Versionen, Konfigurationsschlüssel/-werte und wichtige Zahlenwerte, die
+ für den Fortschritt relevant sind.
+ - Verdichte bei Ketten aus 2–3 Generationen den Verlauf nicht übermäßig zu einem
+ Satz. Bevorzuge 2–4 kompakte Absätze, wo sinnvoll, oder gut lesbare Prosa mit
+ einem klaren Aufgabenziel, einem Verlauf Phase für Phase und dem aktuellen Status.
+ - Kopiere nicht mechanisch die gesamte Historie. Lass Wiederholungen und Details von geringem Wert
+ weg und behalte wichtige Aktionen, direkte Ergebnisse und offene Reste.
+ - Erfinde keine Phasenüberschriften oder Daten. Nenne ein Datum nur, wenn die Einträge
+ es bedeutsam machen; nackte Zeitstempel sind Rauschen.
+ - Wenn die Einträge besagen, dass ältere Revisionen weggelassen wurden, sag ausdrücklich, dass
+ frühere Historie weggelassen wurde; erwecke nicht den Eindruck, die gelieferten Einträge seien vollständig.
+ - Schreib in derselben Sprache, in der die Einträge geschrieben sind.
+ - Keine Einleitung und keine umschließenden Anführungszeichen.
+
+Beispiel
+ Einträge:
+ (2026-07-20) Der Nutzer musste das npm run build in CI reparieren; zurückgeführt auf
+ ERR_OSSL_EVP_UNSUPPORTED unter Node 18, Workflow noch nicht
+ geändert.
+ (2026-07-24) Der Nutzer setzte diese CI-Reparatur fort; Node in
+ .github/workflows/ci.yml auf 20 angehoben, aber der Abhängigkeits-Cache
+ reproduzierte weiterhin den alten Fehler.
+ (now) Der Nutzer setzte die Verifikation derselben Reparatur fort; nach dem Leeren des
+ npm-Caches lief npm run build durch.
+ Ausgabe:
+ Ziel der Aufgabe ist die Reparatur des npm run build in CI. Zunächst wurde der Fehler auf
+ ERR_OSSL_EVP_UNSUPPORTED unter Node 18 zurückgeführt, der Workflow war noch nicht geändert;
+ dann wurde .github/workflows/ci.yml auf Node 20 angehoben, doch der Abhängigkeits-
+ Cache hielt den alten Fehler aufrecht. Schließlich lief npm run build nach dem Leeren des npm-Caches
+ durch, sodass diese Build-Reparatur derzeit als abgeschlossen verifiziert ist.
+
+═══════════════════════════════════════════════════════════════════
+EINTRÄGE
+═══════════════════════════════════════════════════════════════════
+{chain_block}
+
+═══════════════════════════════════════════════════════════════════
+AUSGABE (nur die Zusammenfassung selbst, sonst nichts)
+═══════════════════════════════════════════════════════════════════
+"""
+
+
+# ================================================================
+# Episode / topic summaries
+# ================================================================
+
+EPISODE_SUMMARY_PROMPT = """Du fasst EINE Episode eines Gesprächs mit dem Nutzer zusammen.
+
+Eine Episode ist ein einzelner zusammenhängender Gesprächsabschnitt — ein Thema, über das gesprochen wurde,
+möglicherweise über mehrere Schreib-Sessions hinweg.
+
+## Während dieser Episode erfasste Erinnerungen (älteste → neueste)
+
+{memories}
+
+---
+
+Schreib eine einzige dichte Zusammenfassung dessen, was in dieser Episode passiert ist / besprochen wurde.
+
+Regeln:
+
+* 2–4 Sätze, dritte Person, beginnend mit „Der Nutzer ...“ (oder mit der namentlich genannten Person,
+ wenn die Erinnerungen von jemand anderem handeln).
+* Verbinde die Erinnerungen zu einer zusammenhängenden Darstellung — eine Episode hat meist einen
+ roten Faden (einen Plan, ein Problem, einen Ausflug, eine Entscheidung).
+* Bewahre konkrete Details: Namen, Orte, Zahlen, Daten.
+* Erfinde NICHTS, was nicht in den Erinnerungen steht.
+* Zähle die Erinnerungen NICHT einzeln auf; führe sie zusammen.
+* Die Ausgabesprache muss der Sprache der Erinnerungen entsprechen.
+
+Gib NUR den Zusammenfassungstext zurück, keine Einleitung, kein JSON, keine Anführungszeichen."""
+
+TOPIC_SUMMARY_PROMPT = """Du fasst alles zusammen, was über EIN Thema bekannt ist.
+
+## Thema
+
+{topic_name}
+
+## Erinnerungen zu diesem Thema (älteste → neueste)
+
+{memories}
+
+---
+
+Schreib eine einzige dichte Zusammenfassung dessen, was über den Nutzer in Bezug auf dieses
+Thema bekannt ist.
+
+Regeln:
+
+* 2–4 Sätze, dritte Person, beginnend mit „Der Nutzer ...“ (oder mit der namentlich genannten Person,
+ wenn die Erinnerungen von jemand anderem handeln).
+* Behandle das Thema als Ganzes — nenne die aktuelle Situation und erwähne, wie sie sich
+ entwickelt hat, nur dann, wenn die Veränderung von Bedeutung ist.
+* Bewahre konkrete Details: Namen, Orte, Zahlen, Daten.
+* Erfinde NICHTS, was nicht in den Erinnerungen steht.
+* Zähle die Erinnerungen NICHT einzeln auf; führe sie zusammen.
+* Die Ausgabesprache muss der Sprache der Erinnerungen entsprechen.
+
+Gib NUR den Zusammenfassungstext zurück, keine Einleitung, kein JSON, keine Anführungszeichen."""
+
+
+# ================================================================
+# System 2 evolve (pipelines/system2_agent.py)
+# ================================================================
+
+SYSTEM2_AGENT_PROMPT = """Du bist ein Agent für kognitive Verarbeitung. Deine Aufgabe ist es, aus den Roh-Erinnerungsdaten eines Nutzers kognitive Strukturen höherer Ordnung zu entwickeln.
+
+## Erinnerungsarchitektur
+
+### VDB (Vektordatenbank) — nur lesend
+| Ebene | Beschreibung |
+|-------|-------------|
+| L0 BASIC_INFO | Attribute des Nutzers (Name, Alter, Beruf) |
+| L1 RAW | Ursprüngliche Gesprächsprotokolle |
+| L2 FACT | Aus Gesprächen extrahierte atomare Fakten |
+| L3 SUMMARY | Session-Zusammenfassungen |
+| L4 IDENTITY | Identitätsmerkmale, Vorlieben, Gewohnheiten |
+| L5 KNOWLEDGE | Fachwissen |
+
+### Graph (Wissensgraph) — du bist der einzige Schreibende
+| Ebene | Beschreibung |
+|-------|-------------|
+| L6 SCHEMA | Verhaltensmuster — domänengebunden, atomar, nach der Erstellung unveränderlich |
+
+## Was ist ein L6-Schema?
+
+Ein Schema ist ein ereignisübergreifendes Verhaltensmuster im langfristigen Nutzermodell und
+besteht aus den folgenden drei Komponenten:
+
+
+- **Umstand**: Die Domäne / das Thema / die Situation, in der dieses Muster beobachtet wird. Ein Schema MUSS innerhalb seines Umstands bleiben — verallgemeinere NICHT über Domänen hinweg. Domänenübergreifende Abstraktion übernimmt das System separat.
+- **Muster**: Das gewohnheitsmäßige Verhalten, der Denkstil oder die Handlungstendenz des Nutzers in diesem Umstand.
+- **Einsicht**: Der zugrunde liegende psychologische Antrieb oder das mentale Modell.
+
+### Inhaltsformat
+Verwende einen einzigen Satz, der alle drei vereint:
+„Wenn [Umstand], [Muster des Nutzers] — Ausdruck von [Einsicht].“
+
+Bei dauerhaften Mustern im Zusammenhang mit Emotionen, Therapie, Stress, Trauer oder Trauma
+lösche den konkreten autobiografischen Hintergrund nicht zugunsten eines allgemeinen Persönlichkeits-
+labels. Bevorzuge eine verankerte Struktur, die Folgendes bewahrt:
+„Auslöser/Hintergrund -> wiederkehrende emotionale Reaktion -> beobachtete Bewältigungsressource.“
+Nimm nur Auslöser, Reaktionen und Bewältigungsressourcen auf, die in nutzereigenen
+Belegen vorhanden sind. Ratschläge des Assistenten sind keine beobachtete Bewältigungsressource des Nutzers.
+
+### Regeln
+- **Atomar**: Ein Muster pro Schema. Zwei verschiedene Muster → zwei Schemas.
+- **Unveränderlich**: Einmal erstellt, ändert sich der Inhalt NIE.
+- **Nur Evidenz**: Für neue Fakten, die lediglich die bestehende Formulierung stützen → rufe
+ `add_evidence` auf. Wenn neue Evidenz den aktuellen dauerhaften Zustand wesentlich verändert,
+ korrigiert oder eingrenzt, verwende `revise_schema`, sodass die alte Version für die
+ Nachvollziehbarkeit erhalten bleibt, aber aus dem aktiven Abruf entfernt wird.
+- **Domänengebunden**: Bleib innerhalb der beobachteten Domäne. Domänenübergreifende Abstraktion übernimmt ein separater Systemprozess.
+- **Fakten von Mustern trennen**: Eine einzelne explizite Identität, ein Gesundheitszustand,
+ eine Gerätenutzung, eine Zugehörigkeit, ein Projekt oder eine Vorliebe gehört in den L2-Zustandsspeicher,
+ nicht in L6. L6 erfordert nutzereigene Evidenz, die mindestens zwei unabhängige
+ Raw-Schreibvorgänge oder Sessions repräsentiert. Ein zusammengeführter L2-Fakt kann mehrere Schreibvorgänge repräsentieren;
+ prüfe seine source_raw_memory_ids, statt Faktknoten zu zählen.
+- **Subjektsicherheit**: Fakten, die einen Quell-Chunk teilen, können andere Personen oder
+ Beispiele beschreiben. Erstelle ein Nutzer-Schema nur, wenn das Material das Muster ausdrücklich
+ dem Nutzer zuschreibt. Andernfalls gib für dieses Material keine Operation aus.
+- **Kandidatenabdeckung**: Berücksichtige bei einer Source-Context-Prüfung jeden aufgeführten
+ Kandidatenfakt: Verwende ihn entweder als Evidenz in `create_schema`/`add_evidence`
+ oder gib `skip_fact` aus. Raw-Kontext darf sein Subjekt bestätigen oder ausgelassene
+ Details wiederherstellen, darf aber keine unzusammenhängenden Schemas anstoßen.
+- **Evidenzschwelle**: Das Erstellen von L6 erfordert einen oder mehrere nutzereigene Evidenz-
+ fakten, die mindestens zwei unabhängige Raw-Schreibvorgänge oder Sessions repräsentieren.
+ Ratschläge des Assistenten begründen für sich allein kein Nutzermuster.
+
+### Gute vs. schlechte Beispiele
+✅ „Beim Kochen hält sich der Nutzer streng an die Rezeptschritte und misst die Zutaten genau ab — Ausdruck eines Bedürfnisses nach äußerer Struktur, um mit Unsicherheit umzugehen.“
+✅ „Beim Spielen schaut der Nutzer immer in Komplettlösungen, um 100 % Vervollständigung zu erreichen — angetrieben von geringer Toleranz gegenüber Unvollständigkeit.“
+✅ „Nach dem unerwarteten Verlust eines Mentors können Erinnerungen an die Sterblichkeit die Trauer plötzlich zurückbringen; der Nutzer hält inne, um nachzudenken, und macht ruhige Spaziergänge, um wieder Halt zu finden.“
+❌ „Der Nutzer begreift Musik als Medium für kreative Synthese und kulturellen Brückenbau und verbindet beständig verschiedene musikalische Traditionen ...“ (mehrere Muster vermischt, zu breit)
+❌ „Der Nutzer ist für viele Dinge begeistert und legt Wert auf Qualität.“ (kein Umstand, zu vage)
+❌ „Der Nutzer ist sinnorientiert und resilient.“ (löscht den dauerhaften Auslöser und die beobachtete Bewältigungsevidenz)
+
+## Dein Arbeitsablauf
+
+Eingabematerialien (du wirst nur aufgerufen, wenn mindestens ein Cluster existiert):
+- **Cluster-Ergebnisse**: Primäre Eingabe — nach semantischer Ähnlichkeit gruppierte Fakten
+- **Nicht geclusterte Fakten (ergänzend)**: Fakten, die in keinem Cluster sind; niedrigere Priorität als die Cluster-Ergebnisse
+
+Für jede Gruppe von Fakten (geclustert oder nicht geclustert):
+1. **Bestehende Schemas durchsuchen**: Wenn ein bestehendes Schema dieses Muster bereits erfasst, rufe `add_evidence` auf. Verwende `revise_schema` nur, wenn die alte Formulierung nach dem Hinzufügen der neuen Evidenz wesentlich unvollständig oder irreführend würde.
+2. **Neues Schema erstellen**: Nur wenn kein bestehendes Schema dieses Muster abdeckt. Ein Satz, drei Komponenten.
+3. **Beziehungen aufbauen**: Wenn zwei Schemas thematisch verwandt sind, verwende `add_edge` (RELATED_TO).
+
+## Grundsätze
+
+- Alle Graph-Operationen MÜSSEN über Tools laufen
+- Schema-Inhalt ist UNVERÄNDERLICH — erstelle niemals neu, was bereits existiert
+- Bevorzuge `add_evidence` gegenüber dem Anlegen von Duplikaten
+- Lieber nichts erstellen als Knoten von geringer Qualität
+- Ein Schema = ein atomares Muster in einer Domäne
+- Verwende beim Taggen bevorzugt Tags aus der Liste der bestehenden Tags wieder"""
+
+
+# ================================================================
+# Fragments assembled in code
+# ================================================================
+
+# Display name of this language, used in logs and docs.
+LANGUAGE_NAME = "Deutsch"
+
+# 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, so their prompts stay exactly as before.
+OUTPUT_LANGUAGE_DIRECTIVE = """
+
+---
+
+# AUSGABESPRACHE
+
+Schreib jeden natürlichsprachlichen Wert, den du ausgibst (Erinnerungstexte, Zusammenfassungen, Begründungen, Suchanfragen), auf Deutsch, unabhängig davon, welche Sprache das Gespräch oder die bestehenden Erinnerungen verwenden. Dies hat Vorrang vor jeder Regel oben, die verlangt, der Eingabesprache zu folgen. Behalte JSON-Schlüssel, Feldnamen, Enum-Werte, Operationsnamen, IDs, Code, Dateipfade, Befehle, Fehlermeldungen und Eigennamen exakt so bei, wie sie sind.
+"""
+
+# 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"# ZWEI ARTEN VON ERINNERUNGEN.*?(?=\n# OWNER\n)"
+
+NO_INTENTION_MEMORY_SECTION = (
+ "# ERINNERUNGEN\n"
+ "\n"
+ "Du extrahierst eine Art von Erinnerungen: **memory** (Erinnerungen).\n"
+ "\n"
+ "## memory\n"
+ "\n"
+ "Alles Dauerhafte und Merkenswerte über den Nutzer — und über jede andere\n"
+ "namentlich genannte Person im Gespräch — gehört hierher:\n"
+ "\n"
+ "* Vorlieben, Meinungen, Werte, Einstellungen\n"
+ "* Ereignisse, Handlungen, Erlebnisse\n"
+ "* Gewohnheiten, Verhaltensmuster\n"
+ "* Beziehungen, Eigenschaften\n"
+ "* objektive Fakten, Entscheidungen, Einschränkungen\n"
+ "* laufende Aktivitäten\n"
+ "* **Zukunftspläne / bevorstehende Handlungen**, die es wert sind, erinnert zu werden\n"
+ " (schreib sie in `memory`; erfinde KEINEN separaten intentions-Bereich)\n"
+ "\n"
+ "Implizite Vorlieben MÜSSEN erschlossen werden, wenn sie stark nahegelegt werden.\n"
+ "\n"
+ "Trenne NICHT „was für ein Mensch der Nutzer ist“ von „was passiert ist“.\n"
+ "Beides gehört in `memory`.\n"
+ "\n"
+ "---\n"
+ "\n"
+)
+
+# (old, new) pairs applied in order after the section swap.
+NO_INTENTION_REPLACEMENTS = (
+ (
+ "Jede Erinnerung und jede Absicht MUSS einen `owner` tragen",
+ "Jede Erinnerung MUSS einen `owner` tragen",
+ ),
+)
+
+INTENTION_DISABLED_NOTE = (
+ "\n\n---\n\n# INTENTION DEAKTIVIERT\n"
+ "Die Extraktion von intentions ist deaktiviert. Auch wenn Few-Shot-Beispiele "
+ "`intentions` zeigen, gib diesen Schlüssel **nicht** aus; schreib Zukunftspläne in `memory`.\n"
+)
+
+# Coding / working extractor: wraps the history and the new messages.
+CODING_CONVERSATION_BLOCK = (
+ "LETZTE 5 NUTZER-WORTWECHSEL (NUR KONTEXT; nicht erneut extrahieren):\n"
+ "{history}"
+ "\n\nNEUE NACHRICHTEN (nur aus diesem vollständigen Schreibvorgang extrahieren):\n"
+ "{new}"
+)
+CODING_EMPTY_BLOCK = "(keine)"
+
+# 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 = "Der Name des Nutzers ist {name}"
+
+# System 2 single-call mode: output contract appended to SYSTEM2_AGENT_PROMPT.
+SYSTEM2_OUTPUT_INSTRUCTIONS = """
+
+## Ausgabeformat
+
+Rufe KEINE Tools auf. Gib direkt ein JSON-Array von Operationen aus, eingeschlossen in einen ```json-Codeblock.
+
+Verfügbare Operationen:
+
+1. **create_schema** — Ein neues L6-Verhaltens-Schema erstellen
+ ```{"op": "create_schema", "schema_kind": "behavior_pattern", "content": "knappes, für den Nutzer lesbares Muster", "retrieval_text": "Verhalten plus relevante Situationen", "evidence_list": ["fact_node_id_1", "fact_node_id_2"], "tags": ["tag1"]}```
+
+2. **add_evidence** — Einem bestehenden Schema Evidenz hinzufügen (der Inhalt bleibt unveränderlich)
+ ```{"op": "add_evidence", "node_id": "existing_schema_node_id", "evidence_list": ["new_fact_id_1"]}```
+
+3. **revise_schema** — Eine neue Version erstellen, wenn neue Evidenz den aktuellen Zustand wesentlich verändert, und die alte Version aus dem aktiven Abruf nehmen. Nicht für vereinbare Details verwenden.
+ ```{"op": "revise_schema", "node_id": "old_schema_id", "schema_kind": "explicit_state", "content": "aktualisiertes aktuelles Profil", "retrieval_text": "aktualisierter Abruftext", "evidence_list": ["new_fact_id_1"], "tags": ["tag1"], "reason": "warum die alte Formulierung irreführen würde"}```
+
+4. **add_edge** — Eine Beziehung zwischen zwei Schemas erstellen
+ ```{"op": "add_edge", "source_id": "schema_id_1", "target_id": "schema_id_2", "reason": "Grund der Beziehung"}```
+
+5. **skip_fact** — Einen Kandidatenfakt ausdrücklich als geprüft markieren, ohne
+ ein Schema zu erstellen. Nur für Fakten über eine andere Person, vorübergehende Ereignisse, Ratschläge des Assistenten,
+ die kein Nutzermerkmal begründen, oder Fakten, die bereits vollständig abgedeckt sind.
+ ```{"op": "skip_fact", "node_id": "candidate_fact_id", "reason": "kein dauerhaftes Nutzermuster"}```
+
+## Ausgabevertrag
+
+1. Die Ausgabe MUSS ein JSON-Array in einem ```json-Codeblock sein.
+2. Wenn die Daten für verlässliche Schlussfolgerungen nicht ausreichen, gib `[]` aus. Bei einer
+ Source-Context-Prüfung bedeutet `[]`, dass jeder Kandidat dieser Prüfung untersucht wurde
+ und keiner ein dauerhaftes Schema stützt.
+3. KEIN Text außerhalb des Codeblocks.
+4. Die IDs in evidence_list müssen aus den in den Materialien bereitgestellten Fakt-node_ids stammen.
+5. Die node_id bei add_evidence / revise_schema muss aus bestehenden Graph-Knoten-IDs stammen.
+6. Bei einer Source-Context-Prüfung muss jeder Kandidatenfakt in einer evidence_list oder in skip_fact erscheinen."""
+
+# Appended to SYSTEM2_OUTPUT_INSTRUCTIONS when the schema evidence gate is on.
+SYSTEM2_SCHEMA_EVIDENCE_GATE = """
+
+7. L6 steht ausschließlich für ereignisübergreifende Verhaltensmuster. create_schema muss nutzereigene Evidenz verwenden, die mindestens zwei unabhängige Raw-Schreibvorgänge oder Sessions repräsentiert. Ein einzelner zusammengeführter Fakt kann ausreichen, wenn source_raw_memory_ids mehrere unabhängige Schreibvorgänge enthält.
+8. Erstelle kein L6 für eine einzelne explizite Identität, einen Gesundheitszustand, eine Gerätenutzung, eine Zugehörigkeit, ein Projekt oder eine Vorliebe. Für diese Fakten ist die kanonische L2-Zustandsprojektion zuständig."""
+
+# (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
+# (or be harmless if it does not).
+SYSTEM2_SINGLE_CALL_REPLACEMENTS = (
+ ("- Alle Graph-Operationen MÜSSEN über Tools laufen\n", ""),
+ ("rufe `add_evidence` auf", "verwende die Operation add_evidence"),
+ ("verwende `add_edge` (RELATED_TO)", "verwende die Operation add_edge"),
+)
+
+# System 2 user message (materials). Keys are fixed; values are format
+# strings with the named fields shown.
+SYSTEM2_MATERIALS = {
+ "title": "## Vorverarbeitete Materialien\n",
+ "stats": (
+ "### Statistik\n- VDB-Fakten gesamt: {total}\n"
+ "- Frische Fakten (zu verarbeiten): {fresh} (durch Evidenz ausgeschlossen={evidenced})\n"
+ "- Gefundene Cluster: {clusters}\n"
+ "- Fakten in Clustern: {clustered}, nicht geclusterte Ergänzung: {unclustered}\n"
+ "- Graph-Schemas gesamt: {graph_total} (abgerufen={recalled})"
+ ),
+ "graph_status_empty": "- Graph-Status: **LEER** (erster Durchlauf der kognitiven Verarbeitung)\n",
+ "clusters_header": "### Cluster-Ergebnisse\n",
+ "label_holistic": "{n} sessionübergreifende Nutzerfakten; nur durch Evidenz gestützte dauerhafte Emotions-/Therapiemuster",
+ "label_source_context": "{n} Kandidatenfakten; der Raw-Schreibvorgang dient nur der Prüfung von Subjekt/Details",
+ "label_topic": "{n} Fakten, Thema",
+ "raw_label": "Relevanter Raw-Auszug pro Kandidat",
+ "holistic_note": (
+ "Dies ist ein begrenzter nächtlicher ganzheitlicher Konsolidierungsdurchlauf. Erstelle höchstens "
+ "{max_schemas} verankerte Therapie-Schemas. "
+ "Verbinde bevorzugt dauerhaften Auslöser/Hintergrund, wiederkehrende emotionale Reaktion "
+ "und beobachtete Bewältigungsressource oder Entscheidungsbeschränkung über verschiedene Raw-Schreibvorgänge/Sessions hinweg. "
+ "Bilde vor create_schema die Vereinigung der raw_sources seiner Evidenz-IDs und verlange mindestens zwei "
+ "verschiedene Raw-Quell-IDs; zwei Fakten aus einem Raw-Schreibvorgang sind ein Ereignis. "
+ "Gib [] aus, wenn die Evidenz nicht ausreicht.\n"
+ ),
+ "companion_header": "**Begleithinweise aus unabhängigen Quellen (Kandidaten, keine Schlussfolgerungen):**",
+ "unclustered_header": "### Nicht geclusterte Fakten (ergänzend)\n",
+ "unclustered_hint": "Die folgenden Fakten wurden keinem der obigen Cluster zugeordnet. Prüfe sie nach den Cluster-Themen; niedrigere Priorität als die Cluster-Ergebnisse.\n",
+ "forward_header": "### Verwandte Graph-Knoten (abgerufen per Cluster-Zentroid-Suche, {count} Treffer)\n",
+ "graph_empty": "### Bestehende Graph-Knoten\nDer Graph ist derzeit LEER — dies ist der erste Durchlauf der kognitiven Verarbeitung. Durchsuche den Graph NICHT (es würde nichts zurückkommen). Erstelle direkt Schemas aus den Cluster-Ergebnissen.\n",
+ "graph_no_recall": (
+ "### Bestehende Graph-Knoten\n"
+ "Der Graph enthält {graph_total} Schemas, "
+ "aber der zentroidbasierte Vektorabruf hat keine Treffer gefunden. Entscheide anhand der Cluster-Ergebnisse, ob neue Schemas nötig sind.\n"
+ ),
+ "reverse_header": "### Graph-Rückverweise (VDB-Fakten, auf die bestehende Schemas verweisen)\n",
+ "tags_header": "### Bestehende Tags (verwende diese bevorzugt wieder, statt Synonyme anzulegen)\n",
+ "closing": (
+ "Analysiere die obigen Materialien und gib ein JSON-Array von Operationen aus. "
+ "Entscheide, ob neue Schemas erstellt oder bestehenden Schemas Evidenz hinzugefügt werden soll. "
+ "Wenn die Daten für verlässliche Schlussfolgerungen nicht ausreichen, gib ein leeres Array `[]` aus. "
+ "Verwende beim Taggen bevorzugt Tags aus der obigen Liste der bestehenden Tags wieder."
+ ),
+}
diff --git a/hy_memory/prompts/en.py b/hy_memory/prompts/en.py
new file mode 100644
index 0000000..7605c5b
--- /dev/null
+++ b/hy_memory/prompts/en.py
@@ -0,0 +1,2305 @@
+"""English prompts (``en``).
+
+The source of truth for every other language. Moved verbatim from the
+modules that use them; those modules re-export the old names.
+"""
+
+
+# ================================================================
+# Chat extraction (agent/extractor.py)
+# ================================================================
+
+EXTRACT_SYSTEM_PROMPT = """# ROLE
+
+You are a Memory Extractor.
+
+Extract durable, high-value memories from conversations and convert them into structured, self-contained statements.
+
+Only extract information that is likely to matter in future conversations.
+
+---
+
+# INPUTS
+
+You will receive:
+
+* Last k Messages
+* New Messages
+* Memory Date
+* Current Date
+
+Use:
+
+* Last k Messages only for coreference resolution
+* Memory Date as the ONLY temporal anchor
+* Current Date only as metadata, never for resolving relative time
+
+---
+
+# WHAT TO EXTRACT
+
+Extract ONLY genuinely new information introduced in the NEW user messages.
+
+Good memories include:
+
+* preferences
+* long-term projects
+* habits
+* goals
+* recurring activities
+* opinions
+* relationships
+* important experiences
+* stable traits
+* future plans
+* decisions
+* constraints
+* accepted recommendations
+
+Do NOT extract:
+
+* small talk
+* acknowledgements
+* generic emotions
+* temporary conversational context
+* assistant reminders of old memories
+* information already implied by prior context
+* vague personality judgments
+
+---
+
+# SUBJECT
+
+Every memory must be self-contained, written in third person, with an explicit
+subject. Which subject to use is decided by **who spoke**:
+
+| Speaker | Subject to write | Example |
+| --- | --- | --- |
+| `role: "user"` | the user | "The user ..." / "用户..." |
+| any speaker with a `name` other than the user (e.g. `name: "John"`) | that person, by name | "John ..." |
+| `role: "assistant"` with NO `name` | the AI assistant | "The assistant ..." |
+
+The two input sections express the speaker differently:
+
+* **New Messages** is a JSON array — read `role` and the optional `name` field.
+* **Last k Messages** is rendered text — the speaker is the bracket label,
+ `[user]:` / `[John]:` / `[assistant]:`, optionally preceded by one line
+ "The user's name is Tim" / "用户名叫Tim".
+
+Rules:
+
+* The user is the person these memories belong to. Even when the user's own name
+ is known (from `name` on their message, or from the leading name line), still
+ write "The user ...", NEVER "Tim ...".
+* **`role: "assistant"` WITH a `name` is another real person, not the AI.**
+ Write their memories with their name as the subject: "John ...".
+* Only a nameless `role: "assistant"` is the AI assistant.
+* Never invent a name for the AI assistant, it has none.
+
+---
+
+# LANGUAGE RULES
+
+* Output language must match input language.
+* Preserve original scripts and technical terms exactly.
+* Never transliterate names, brands, or equations.
+
+---
+
+# TWO KINDS OF MEMORY
+
+You extract two kinds of memory: **memory** and **intentions**.
+
+## memory
+
+Everything durable and worth remembering about the user — and about any other
+named person in the conversation — goes here:
+
+* preferences, opinions, values, attitudes
+* events, actions, experiences
+* habits, behavioral patterns
+* relationships, traits
+* objective facts, decisions, constraints
+* ongoing activities
+
+Implicit preferences MUST be inferred when strongly suggested
+(e.g. resuming an activity → positive interest; avoiding something →
+negative preference; repeated voluntary effort → sustained interest).
+
+Do NOT separate "what kind of person the user is" from "what happened".
+Both go into `memory`.
+
+## intentions
+
+A forward-looking thing the user **plans or intends to do in the future**,
+which can be acted on and which becomes irrelevant once done or past.
+
+Examples:
+
+* "The user has a job interview next Tuesday."
+* "The user plans to move apartments at the end of the month."
+* "The user intends to finish the report before Friday."
+
+NOT intentions (these belong in `memory`):
+
+* stable preferences / traits ("The user likes basketball")
+* completed past events ("The user moved to Beijing last year")
+* general goals with no actionable future step
+
+### valid_until
+
+For each intention, provide `valid_until`: the date after which the
+intention no longer matters (the deadline / target date), resolved
+against **Memory Date** (e.g. "next Tuesday" → that absolute date).
+If no deadline can be determined, set `valid_until` to `null`.
+
+---
+
+# OWNER
+
+Every memory and intention MUST carry an `owner` saying which memory store it
+belongs to. There are exactly two values:
+
+* `"user"` — anything belonging to the user's own memory store. This includes
+ facts/preferences/traits about the user themselves, AND facts about other
+ named real people in the conversation, because those are still things the
+ user's memory should hold.
+* `"agent"` — information the AI assistant (a nameless `role: "assistant"`)
+ provides (recommendations, confirmations, things it researched), or a future
+ action the user wants the **assistant** to perform ("remind me in 8 hours").
+
+A named person is NEVER `owner: "agent"` — they are a real person, not the AI,
+even though their messages carry `role: "assistant"`. Their memories are
+`owner: "user"` with their name as the content subject.
+
+Decide `owner` per item. When unsure, default to `"user"`.
+
+---
+
+# TEMPORAL RULES
+
+Resolve relative time using Memory Date.
+
+Examples:
+
+* "next week"
+* "last month"
+* "tomorrow"
+
+If time cannot be resolved safely:
+
+* remove the relative wording
+* keep the memory atemporal
+
+Do not invent chronology.
+
+**Just-happened events are events — keep them.** When the user reports something as
+just completed ("just got back", "just finished", "this morning", "yesterday"), the
+completion date is the Memory Date. Emit the **event itself** with that date; do not
+fold it into a background statement.
+
+* "I just got back from a trip with my family"
+ → "The user returned from a family trip on <Memory Date>."
+ NOT → "The user takes family trips." (the return date is the answer to "when did
+ they get back", and dropping it makes the question unanswerable)
+
+Where an event has both a start and an end that the conversation gives separately,
+record both rather than collapsing them into one span.
+
+---
+
+# QUALITY RULES
+
+Each memory must be:
+
+* self-contained
+* contextually complete
+* retrieval-friendly
+* information-dense
+
+Retain important details:
+
+* names
+* products
+* locations
+* numbers
+* equations
+* constraints
+
+Never generalise a specific into a category. Write what was actually said.
+
+* "Banff" → keep "Banff", NOT "the Rocky Mountains"
+* "a 3-year-old border collie named Luna" → keep the breed, age and name
+
+**Specifics supplied by the other speaker still count.** A fact is often built across
+turns: the other speaker names the thing, the user confirms it. The subject rules
+decide *whose* memory it is — they do not license dropping detail.
+
+* [Sam]: "Did you take advantage of the skiing opportunities in Banff?"
+ [user]: "Yeah, it was great for skiing!"
+ → "The user went skiing in Banff and found the snow amazing."
+ NOT → "The user enjoys winter sports." (both the place and the activity were
+ established, one by each speaker)
+
+Avoid fragmentary memories lacking context.
+
+Choose the smallest number of memories that still preserves distinct future
+retrieval needs.
+
+* Compression means combining, not omitting. Every explicit durable proposition
+ in the new messages must appear exactly once in the output.
+* Combine details when they share the same subject and the same real-world event,
+ state, preference, plan, or decision. A coherent event may use 1–3 sentences.
+* Do not emit both a broad statement and narrower restatements of the same evidence.
+* Split only when the subject differs, the events happened independently, or the
+ memories describe different states.
+* Keep a cause, recommendation, or consequence with the fact it explains when
+ separating them would lose the relationship.
+* Never merge separate dated occurrences merely because they share a topic.
+* Preserve the source's time precision. Do not turn vague phrases such as "last
+ weekend" or "last summer" into exact calendar dates unless the date is explicit
+ or uniquely determined; "the weekend before <Memory Date>" is acceptable.
+
+---
+
+# TAGS
+
+Each memory must include 1–3 concise tags.
+- Topical keywords stay lowercase (travel, health, work).
+- Proper nouns keep capitalization (Jasper, Canada, Banff, Prius).
+
+Examples:
+
+* work
+* travel
+* Jasper
+* Canada
+* health
+
+---
+"""
+
+STRUCTURE_METADATA_PROMPT = """
+
+---
+
+# STRUCTURAL ORGANIZATION
+
+For every `memory`, also output:
+
+* `topic_paths`: a backward-compatible list of zero to three broad-to-specific
+ semantic paths.
+* `event_facet`: an object with only `subject`, `participants`, `action`,
+ `objects`, `locations`, and `state`; state is `planned`, `ongoing`,
+ `completed`, or `unknown`.
+* `topic_assignments`: zero to six subject-specific memberships. Each item is
+ `{subject, role, path}`, where `path` is a list of `{name, type}` segments and
+ `type` is one of `topic`, `facet`, `series`, or `episode`. Use `topic` for a
+ broad domain, `facet` for a concrete activity/semantic aspect, `series` only
+ for repeated occurrences of the same concrete activity/state line, and
+ `episode` only for one bounded real-world occurrence. A shared event may have
+ one assignment per explicit participant while keeping one canonical memory.
+ Types follow `topic -> facet -> series -> episode`; levels may be skipped but
+ types may not repeat or move backward.
+
+This extractor sees only the current write and therefore must not emit a
+`series` segment. Emit Topic/Facet/Episode here. Reconcile may later establish a
+Series after comparing independent stored occurrences.
+
+This is write-time organization. Do not infer Series/Episode from path depth,
+manufacture hierarchy from a proper noun or broad tag, or assign a person only
+because they co-occur in unrelated context. Stop at the most specific supported
+level and use empty values when uncertain. Never encode query forms such as
+"when", "how many", "who", plurality, or ordinal wording.
+"""
+
+EXTRACT_FEW_SHOT = """
+---
+
+# EXAMPLES
+
+## Example 1 — Boundary: old context is for resolution only, never re-extracted
+
+Last k Messages:
+[{"role": "user", "content": "I've been looking at rescue dogs at the shelter downtown."},
+ {"role": "assistant", "content": "That's lovely — found one you like?"}]
+New Messages:
+[{"role": "user", "content": "Yeah, picked her up yesterday — a 3-year-old border collie named Luna."}]
+Memory Date: 2025-04-10
+
+Output:
+```json
+{
+ "memory": [
+ {"content": "The user adopted a 3-year-old border collie named Luna from a downtown shelter on 2025-04-09.", "tags": ["pets", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+The old messages only resolve "her" and supply context ("downtown shelter"). Do NOT emit a stale memory like "the user is considering adopting a dog" — only the genuinely new fact (the completed adoption) is extracted, with "yesterday" resolved against Memory Date.
+
+## Example 2 — Condense a long assistant reply
+
+New Messages:
+[{"role": "user", "content": "Write me a short essay on why remote work boosts productivity."},
+ {"role": "assistant", "content": "Sure — opening: 'Remote work has reshaped how teams operate...' [~2000 words of body omitted] ...closing: 'In short, autonomy and fewer interruptions drive higher output.'"}]
+Memory Date: 2025-03-22
+
+Output:
+```json
+{
+ "memory": [
+ {"content": "The assistant drafted a short essay for the user arguing that remote work boosts productivity because autonomy and fewer interruptions drive higher output.", "tags": ["writing", "remote-work"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+The assistant's reply is long. Never store the verbatim essay — distill it to topic + thesis. owner is "agent" because the assistant produced it. Bloated verbatim content makes memory unusable.
+
+## Example 3 — Composite extraction: basic_info + intention + condensed agent plan
+
+New Messages:
+[{"role": "user", "content": "Hi, I'm Kenji. I'm planning a trip to Japan next month — could you put together a 7-day itinerary?"},
+ {"role": "assistant", "content": "# 7-Day Classic Japan Golden Route (Tokyo → Kyoto → Nara → Osaka)\\nFly into Tokyo, Shinkansen south to Kyoto, day-trip Nara, depart from Osaka (Kansai).\\n\\n## Day 1: Arrival in Tokyo\\n- Land at Haneda/Narita, drop bags at hotel near Tokyo Station.\\n- Late afternoon: Sensoji Temple (Asakusa), wander Nakamise Street, try taiyaki.\\n- Evening: Shibuya Crossing + Shibuya Sky rooftop for sunset; izakaya dinner (yakitori, sake).\\n\\n## Day 2: Tokyo markets & landmarks — [omitted]\\n## Day 3: Shinkansen to Kyoto, Fushimi Inari, Gion — [omitted]\\n## Day 4: Kyoto temples (Kiyomizu-dera, Kinkaku-ji, Ginkaku-ji) — [omitted]\\n## Day 5: Nara day trip (Nara Park deer, Todai-ji) — [omitted]\\n## Day 6: Osaka (Osaka Castle, Dotonbori street food) — [omitted]\\n## Day 7: Osaka sightseeing + depart from Kansai Airport — [omitted]\\n\\nTip: buy a 7-day JR Pass before arriving. Want me to adjust anything?"}]
+Memory Date: 2025-09-15
+
+Output:
+```json
+{
+ "memory": [
+ {"content": "The assistant created a 7-day Japan itinerary for the user along the classic golden route: Tokyo (Asakusa, Shibuya), Shinkansen to Kyoto (Fushimi Inari, Kiyomizu-dera, Kinkaku-ji, Gion), a Nara day trip (deer park, Todai-ji), then Osaka (Osaka Castle, Dotonbori), departing from Kansai Airport.", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
+ ],
+ "intentions": [
+ {"content": "The user plans to take a 7-day trip to Japan in October 2025.", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
+ ],
+ "basic_info": {"name": "Kenji"}
+}
+```
+One turn produces three outputs in different buckets: the name goes to basic_info, the trip is a forward-looking intention with a deadline, and the assistant's long multi-section itinerary is condensed into ONE dense agent memory — the route and key stops per city, NOT every day's bullets, tips, or food lists. Storing the whole reply verbatim would bloat memory; storing the skeleton keeps it queryable.
+
+## Example 4 — A later message confirming/adopting an earlier recommendation is itself a fact
+
+New Messages:
+[{"role": "user", "content": "My 6-year-old won't eat any vegetables. Any ideas?"},
+ {"role": "assistant", "content": "Try blending spinach or carrots into pasta sauce — the color and flavor mostly disappear, and many kids accept it without noticing."},
+ {"role": "user", "content": "Oh nice, we'll try that tonight. By the way, what's a good bedtime for that age?"},
+ {"role": "assistant", "content": "For a 6-year-old, aim for 7–9 PM with about 10–11 hours of sleep."}]
+Memory Date: 2025-06-20
+
+Output:
+```json
+{
+ "memory": [
+ {"content": "The user has a 6-year-old child who refuses to eat vegetables, and accepted the assistant's suggestion to blend spinach or carrots into pasta sauce to hide them.", "tags": ["parenting", "food"], "owner": "user"},
+ {"content": "The assistant advised the user that a 6-year-old should aim for a 7–9 PM bedtime with about 10–11 hours of sleep.", "tags": ["parenting", "sleep"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+In the third message the user said "we'll try that tonight" — explicitly adopting the earlier suggestion. That acceptance is valuable and must be recorded ("accepted the assistant's suggestion to ..."), not discarded as small talk. The bedtime advice was just given and not yet adopted, so it is recorded as advice (owner "agent").
+
+## Example 5 — RAG/injected context: never store the injected text
+
+New Messages:
+[{"role": "user", "content": "[Retrieved context: The Eiffel Tower is 330m tall and was completed in 1889.] Given the above, I'm going to propose to my girlfriend at the top of the Eiffel Tower this summer."}]
+Memory Date: 2025-05-02
+
+Output:
+```json
+{
+ "memory": [],
+ "intentions": [
+ {"content": "The user plans to propose to his girlfriend at the top of the Eiffel Tower in summer 2025.", "tags": ["relationship", "travel"], "valid_until": "2025-08-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+The bracketed retrieved context (the tower's height and year) is RAG-injected reference material, NOT something the user told us about themselves — do NOT store it. Only the user's own forward-looking plan is extracted. System/RAG-injected text is context for the model, never a memory.
+
+## Example 6 — Shared reference material: extract the content, not the sharing action
+
+New Messages:
+[{"role": "user", "content": "Remember my grandma's dumpling recipe so I don't lose it. Filling: 500g ground pork, 300g napa cabbage, 2 tbsp soy sauce, 1 tbsp sesame oil, a thumb of ginger minced. Cabbage salted 15 min then squeezed dry. Boil dumplings, add cold water twice, ready when they float."},
+ {"role": "assistant", "content": "Got it, saved!"}]
+Memory Date: 2025-07-01
+
+Output:
+```json
+{
+ "memory": [
+ {"content": "The user's grandmother's dumpling recipe: filling of 500g ground pork, 300g napa cabbage (salted 15 minutes then squeezed dry), 2 tbsp soy sauce, 1 tbsp sesame oil, and a thumb of minced ginger; boil the dumplings, add cold water twice, and they are done when they float.", "tags": ["food", "recipe", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Extract the actual factual content (ingredients, quantities, the salt-and-squeeze step, the boiling method) — NOT "the user shared a recipe" or "the user asked to remember the recipe". The sharing action is worthless; the content is what's queryable.
+
+## Example 7 — Structured numbers and attributes preserved exactly
+
+New Messages:
+[{"role": "user", "content": "Logging my home-gym PRs this cycle: Squat 140kg x 3, Bench 100kg x 5, Deadlift 180kg x 2, Overhead Press 60kg x 6. Bodyweight 78kg, 3 sets per lift, 3 min rest."},
+ {"role": "assistant", "content": "Logged — strong numbers!"}]
+Memory Date: 2026-01-20
+
+Output:
+```json
+{
+ "memory": [
+ {"content": "The user's current lifting PRs are Squat 140kg x 3, Bench 100kg x 5, Deadlift 180kg x 2, and Overhead Press 60kg x 6, at a bodyweight of 78kg.", "tags": ["fitness", "strength"], "owner": "user"},
+ {"content": "The user trains with 3 sets per lift and 3 minutes of rest between sets.", "tags": ["fitness", "training"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Every number and unit (kg, reps, sets, rest time) is preserved exactly — dropping them would destroy the most queryable information. Split into two clean topics (PRs vs. training protocol), but never round or omit the specifics.
+
+## Example 8 — Long multi-topic conversation: do not stop after the first topic
+
+New Messages:
+[{"role": "user", "content": "Big week — I finally defended my PhD thesis on Tuesday!"},
+ {"role": "assistant", "content": "Huge congrats! How do you feel?"},
+ {"role": "user", "content": "Relieved! I also signed a lease on an apartment in Berlin and move next month. And I've started learning German on Duolingo — 30-day streak. My partner Sofia is staying in Madrid for now, which is hard."}]
+Memory Date: 2025-11-08
+
+Output:
+```json
+{
+ "memory": [
+ {"content": "The user defended their PhD thesis on 2025-11-04.", "tags": ["education", "milestone"], "owner": "user"},
+ {"content": "The user signed a lease on an apartment in Berlin.", "tags": ["housing"], "owner": "user"},
+ {"content": "The user has been learning German on Duolingo and has a 30-day streak.", "tags": ["language", "learning"], "owner": "user"},
+ {"content": "The user's partner Sofia is staying in Madrid for now, which the user finds hard.", "tags": ["relationship"], "owner": "user"}
+ ],
+ "intentions": [
+ {"content": "The user plans to move to Berlin next month (around December 2025).", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+Four+ topics — thesis defense, the Berlin apartment, learning German, and the partner in Madrid. Do not stop after the first topic. Note one turn split into a completed fact (lease signed) AND an intention (the upcoming move), and the emotional-but-substantive detail about Sofia is kept because it carries lasting relationship context.
+
+## Example 9 — Two real people: `name` on an assistant message means a real person
+
+New Messages:
+[{"role": "user", "name": "Tim", "content": "Just got back from the climbing gym, third time this week. Finally sent that overhang route."},
+ {"role": "assistant", "name": "John", "content": "Nice! I've been swimming instead — my shoulder still hurts from last month."}]
+Memory Date: 2025-08-14
+
+Output:
+```json
+{
+ "memory": [
+ {"content": "The user has been climbing three times a week and recently completed a difficult overhang route.", "tags": ["fitness", "climbing"], "owner": "user"},
+ {"content": "John has been swimming instead of other exercise because his shoulder still hurt after an injury around July 2025.", "tags": ["fitness", "health"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {"name": "Tim"}
+}
+```
+John carries `role: "assistant"` but he has a `name`, so he is another real person, NOT the AI: his memory uses "John ..." as the subject and is still `owner: "user"` (it belongs to the user's memory store). The user's own memory stays "The user ..." even though we know the name is Tim — never "Tim has been climbing". `basic_info.name` comes from `name: "Tim"` on the user message, which is authoritative even though Tim never said his own name out loud.
+
+## Example 10 — Counter-example: another person's attributes never go into basic_info
+
+New Messages:
+[{"role": "user", "name": "Tim", "content": "你最近在忙什么?"},
+ {"role": "assistant", "name": "John", "content": "我在柏林一家医院当护士,上的是夜班,挺累的。"}]
+Memory Date: 2025-09-02
+
+Output:
+```json
+{
+ "memory": [
+ {"content": "John是柏林一家医院的护士,上夜班,觉得很累。", "tags": ["work", "health"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {"name": "Tim"}
+}
+```
+John's occupation and location are HIS attributes, so they go into `memory` with "John" as the subject. They must NEVER land in `basic_info.occupation` / `basic_info.location` — `basic_info` is exclusively the user's own profile. Only `name` (Tim, from the user message's `name` field) belongs there.
+
+## Example 11 — Counter-example: small talk has no basic_info
+
+New Messages:
+[{"role": "user", "content": "Hi"},
+ {"role": "assistant", "content": "Hello! The user's name is The user. How can I help?"}]
+Memory Date: 2025-09-03
+
+Output:
+```json
+{
+ "memory": [],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+The user stated nothing about themselves. The assistant's line is not a user turn, and "The user" is a placeholder, not a name. Output `{}` — never `{"name": "The user"}` or `{"name": "user"}`.
+
+---
+"""
+
+EXTRACT_PROMPT = """## Last k Messages
+
+{last_messages}
+
+---
+
+## New Messages
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Output Format
+
+Return ONLY a JSON object inside a ```json fenced block.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "intentions": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "valid_until": "YYYY-MM-DD",
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Rules:
+
+* `memory` = durable info worth remembering: preferences, opinions, attitudes,
+ traits, events, plans, experiences, habits, decisions — about the user or
+ about any other named real person, with the subject written per "# SUBJECT"
+* `intentions` = forward-looking things the user (or another named person) plans /
+ intends to do in the future, with `valid_until` = the deadline/target date
+ (resolved against Memory Date) or `null` if none
+* `owner` (required on every memory & intention) = `"user"` or `"agent"`
+ (see "# OWNER" above; default `"user"` when unsure)
+* `basic_info` = the **user's own profile only**. Include stable profile
+ fields (e.g. name, age, location, occupation, employer) **explicitly stated**
+ in the NEW user messages. Never infer, never invent. If no field is explicitly
+ stated, output `{{}}`.
+ * HARD RULE: fill a field ONLY if the user stated it in a `user` turn.
+ Anything said only by the assistant (including the assistant quoting an
+ earlier memory such as "The user's name is X") does NOT count. If nothing
+ qualifies, output `"basic_info": {{}}`.
+ * NEVER write the field name itself or a placeholder as a value ("user",
+ "The user", "用户", "name", "N/A", "unknown", "none", "-"). Omit the field.
+ * Negative example: small talk such as `[user]: Hi` / `[assistant]: How can
+ I help?`, or `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
+ * Exception for `name`: the `name` field on the user's own message, or a leading
+ line "The user's name is X" / "用户名叫X", is an authoritative source for
+ `name` — even though the user never said it out loud.
+ * NEVER put another real person's attributes here. If John (an assistant-role
+ message carrying `name`) says "I'm a nurse in Berlin", that is a `memory`
+ ("John is a nurse in Berlin."), NOT `basic_info.occupation` / `.location`.
+* No duplicate information across sections
+* Tags must contain 1–3 concise lowercase keywords
+* Use empty arrays `[]` or `{{}}` when nothing is extracted
+* Return valid JSON only
+
+Output the JSON now."""
+
+EXTRACT_PROMPT_NO_INTENTION = """## Last k Messages
+
+{last_messages}
+
+---
+
+## New Messages
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Output Format
+
+Return ONLY a JSON object inside a ```json fenced block.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Rules:
+
+* `memory` = durable info worth remembering: preferences, opinions, attitudes,
+ traits, events, experiences, habits, decisions, **and future plans / upcoming
+ actions** — about the user or about any other named real person, with the
+ subject written per "# SUBJECT". Do **not** invent a separate intentions bucket.
+* `owner` (required on every memory) = `"user"` or `"agent"`
+ (see "# OWNER" above; default `"user"` when unsure)
+* `basic_info` = the **user's own profile only**. Include stable profile
+ fields (e.g. name, age, location, occupation, employer) **explicitly stated**
+ in the NEW user messages. Never infer, never invent. If no field is explicitly
+ stated, output `{{}}`.
+ * HARD RULE: fill a field ONLY if the user stated it in a `user` turn.
+ Anything said only by the assistant (including the assistant quoting an
+ earlier memory such as "The user's name is X") does NOT count. If nothing
+ qualifies, output `"basic_info": {{}}`.
+ * NEVER write the field name itself or a placeholder as a value ("user",
+ "The user", "用户", "name", "N/A", "unknown", "none", "-"). Omit the field.
+ * Negative example: small talk such as `[user]: Hi` / `[assistant]: How can
+ I help?`, or `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
+ * Exception for `name`: the `name` field on the user's own message, or a leading
+ line "The user's name is X" / "用户名叫X", is an authoritative source for
+ `name` — even though the user never said it out loud.
+ * NEVER put another real person's attributes here. If John (an assistant-role
+ message carrying `name`) says "I'm a nurse in Berlin", that is a `memory`
+ ("John is a nurse in Berlin."), NOT `basic_info.occupation` / `.location`.
+* No duplicate information across sections
+* Tags: 1–3 concise keywords; topical tags lowercase; proper nouns keep capitalization
+* Use empty arrays `[]` or `{{}}` when nothing is extracted
+* Return valid JSON only — **never** include an `intentions` key
+
+Output the JSON now."""
+
+
+# ================================================================
+# Chat reconcile (agent/reconciler.py)
+# ================================================================
+
+SEARCH_QUERY_PROMPT = """You are a search query generator. Given a list of newly extracted memories, generate a set of short search queries that can be used to find related existing memories in a vector database.
+
+The goal is to maximize recall — find existing memories that are semantically related to the new memories, even if the wording is very different.
+
+## New memories:
+{new_memories}
+
+## Instructions
+
+Generate search queries that cover:
+- Key topics, entities, and themes mentioned in the memories
+- Rephrased or abstracted versions of the core concepts
+- Related concepts that might exist in the user's memory store
+
+Output a JSON array of query strings (5-15 queries, short and focused):
+
+["query1", "query2", "query3", ...]
+
+Output JSON array only, no other text."""
+
+RECONCILE_PROMPT = """You are a memory management system.
+
+Your task is to merge new memories into an existing memory base while keeping it:
+
+* lossless
+* non-contradictory
+* compact
+* highly retrievable
+
+---
+
+# Operations
+
+## ADD
+
+Use when the information is entirely new.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## UPDATE
+
+Use when:
+
+* the new memory is compatible with an existing one
+* they describe the same topic
+* merging improves completeness or retrievability
+
+Rules:
+
+* merge losslessly
+* preserve all useful information
+* do NOT create duplicates
+* if the two disagree on a value, keep the value from the memory with the later
+ `memory_at`; never let an older memory overwrite a newer value
+
+### Same occurrence vs. another occurrence
+
+Use **UPDATE** only when the new memory adds detail to the same real-world
+occurrence or durable fact already recorded.
+
+If the same person does the same kind of activity/event again at another time
+(another trip, game, injury, purchase, health scare, etc.), keep the occurrence
+as a separate **ADD**. Preserve its own date and details. When an existing memory
+is clearly another occurrence in that same concrete series, link it with
+`related: [{{"memory_id":"...","relation":"same_series"}}]`.
+
+Do not merge separate dated occurrences into one long count/timeline memory.
+The retrieval layer builds timelines from the linked L2 memories.
+
+```json
+{{
+ "op": "UPDATE",
+ "memory_id": "...",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## SUPERSEDE
+
+Use ONLY when:
+
+* the new memory contradicts an existing memory
+* both cannot be true at the same time
+* the old memory would now give the wrong current-state answer
+* the new memory's `memory_at` is the same as or LATER than the existing memory's `memory_at`
+
+Examples:
+
+* city changed
+* employer changed
+* relationship status changed
+
+Do NOT use for:
+
+* added detail
+* compatible preferences
+* wording differences
+* semantic equivalence
+* a new memory whose `memory_at` is EARLIER than the existing memory's — it is an
+ older state and must never replace a newer one (see "Time order")
+
+Rules:
+
+* content must contain ONLY the new state
+* do NOT copy unchanged information
+* the system keeps the old node and links it onto the evolution chain automatically; you don't need to handle history
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_id": "...",
+ "content": "...",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+### Folding several existing memories into one chain
+
+If TWO OR MORE existing memories track the SAME dimension and the new memory is
+the latest change on that dimension — its `memory_at` is later than every folded
+memory's `memory_at` — you may fold them into a single evolution
+chain. Use `memory_ids` (an ordered list, OLDEST → NEWEST) instead of a single
+`memory_id`:
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_ids": ["<oldest_id>", "<newer_id>"],
+ "content": "<only the newest state>",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+The listed memories are chained oldest → newest and the new memory becomes the
+chain head. `content` still describes ONLY the newest state — never copy the
+older memories' text into it; they remain queryable in the chain history.
+
+---
+
+# Rules
+
+* Preserve all meaningful information.
+* Skip exact duplicates.
+* Prefer merging related fragments.
+* Separate dated occurrences stay separate ADDs; use `same_series` only for the
+ same subject and same concrete activity/event type.
+* Keep each memory focused on one coherent topic.
+* Follow "Time order" below.
+* **NEVER merge or supersede across different subjects.** The subject is whoever
+ the content is about: "The user ..." vs "John ..." vs "Mary ...". Memories about
+ different people are independent facts even when the sentence is otherwise
+ identical — "The user likes coffee" and "John likes coffee" are two separate
+ memories, never an UPDATE or a SUPERSEDE of each other.
+* `owner` (`user`/`agent`): copy it from the memory being written. NEVER merge or supersede across different owners — a user's fact and the assistant's fact are distinct even on the same topic.
+* A SUPERSEDE either targets ONE memory (`memory_id`) or folds several memories on the same dimension into one chain (`memory_ids`, oldest→newest). An UPDATE targets exactly ONE memory.
+* Never touch the same existing memory from more than one op.
+* Output language matches input memory language.
+
+---
+
+# Time order
+
+Every memory, new or existing, has `memory_at`: when it happened. Memories are
+NOT always written in the order they happened — history can be imported late,
+and a memory can be added while older history is still being processed. A new
+memory can therefore be OLDER than an existing one.
+
+* Decide which memory is newer ONLY by `memory_at`. "New memories" means "being
+ written now", not "more recent".
+* An older memory must never replace a newer one: no SUPERSEDE of a newer
+ memory, and no UPDATE that overwrites a newer value with an older one.
+* If a new memory is older than an existing memory it conflicts with, keep the
+ existing memory as the current state. ADD the new one as a past state, worded
+ in the past with its time (for example "In 2023 the user lived in Shanghai"),
+ or output nothing if it adds no information.
+* `memory_at: null` means unknown time. Unknown is NOT newer: never SUPERSEDE a
+ memory that has a known `memory_at` with one whose `memory_at` is null.
+* Do not invent chronology.
+
+---
+
+# Optional: `related`
+
+On any op you MAY add a `related` array recording how the memory being written
+relates to an EXISTING memory. This does not change what gets stored — it only
+records a link.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."],
+ "related": [{{"memory_id": "<existing_id>", "relation": "causes"}}]
+}}
+```
+
+Only these four relations are allowed:
+
+* `causes` — the two memories are in a cause/effect relationship
+ (e.g. "started running daily" → "knee started hurting")
+* `elaborates` — adds detail to, or is a later development of, the existing memory
+* `contrasts` — they are in tension but BOTH still true (if one makes the other
+ false, that is a SUPERSEDE, not a `contrasts` link)
+* `same_series` — separate dated occurrences of the same concrete activity or
+ event type for the same subject (for example, two different skiing trips)
+
+Rules:
+
+* Only link to memories that appear in "Existing memories" — never invent an id.
+* Only emit a link when the relationship is **explicit and specific**. Two memories
+ merely being about the same broad topic is NOT a relation — leave `related` out.
+* `same_series` requires the same subject and a concrete repeated action/event;
+ shared broad tags such as health, travel, sport, food, or work are insufficient.
+* Omit the field entirely when there is nothing to link. Zero links is the normal case.
+* Never use `related` as a substitute for UPDATE / SUPERSEDE.
+
+---
+{few_shot_section}
+###################
+Input Data
+###################
+
+Current date: {current_date}
+
+## Existing memories
+
+{existing_memories}
+
+## New memories
+
+{new_memories}
+
+---
+
+# Output
+
+Return ONLY a JSON array inside a fenced ```json code block.
+
+If no changes are needed:
+
+```json
+[]
+```
+
+Now produce the JSON array."""
+
+RECONCILE_STRUCTURE_METADATA_PROMPT = """
+
+Additional structural output contract:
+
+For every ADD, UPDATE, or SUPERSEDE result, preserve or refine `topic_paths`,
+`event_facet`, and `topic_assignments`. `event_facet` contains only `subject`,
+`participants`, `action`, `objects`, `locations`, and `state`.
+`topic_assignments` contains subject-specific `{subject, role, path}` entries;
+each path segment is `{name, type}` and type is `topic|facet|series|episode`.
+Types follow `topic -> facet -> series -> episode`; levels may be skipped but
+types may not repeat or move backward.
+Use Series only for repeated occurrences of one concrete activity/state line and
+Episode only for one bounded real-world occurrence. Never infer these types from
+depth, a broad shared tag, or unrelated co-occurrence. When an Existing memory
+already has a semantically equivalent subject-specific path, reuse its exact node
+names and types instead of creating a synonym fork. To request exact reuse, emit
+`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
+"through":"topic|facet|series|episode"}]`. The referenced ID must appear in
+Existing memories. `through` means copy that existing path prefix through the
+named structural type; an explicitly authored deeper suffix remains new. Reuse
+is forbidden when the subject, concrete activity/state line, or Episode boundary
+differs. These fields describe the memory, never a future query form such as
+"when", "how many", or "who".
+
+Series is a reconcile-time relation: establish it only when the new memory and
+at least one independent Existing memory are distinct occurrences of the same
+concrete activity/state line. Multiple propositions from the current write do
+not prove repetition.
+"""
+
+RECONCILE_FEW_SHOT = """
+###################
+Examples
+###################
+
+## Example 1 — One new memory: part conflicts with an existing chain, part is unrelated
+
+Existing memories:
+[
+ {"memory_id": "m1", "content": "The user works as a product manager at Stripe.", "owner": "user", "history_versions": [{"content": "The user works as a product manager at a fintech startup."}]}
+]
+New memories:
+[
+ {"content": "The user has left Stripe and is now a product lead at Notion, and has recently taken up pottery on weekends.", "owner": "user"}
+]
+
+Output:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "m1", "content": "The user works as a product lead at Notion.", "supersede_reason": "employer changed from Stripe to Notion", "owner": "user", "tags": ["work"]},
+ {"op": "ADD", "content": "The user has recently taken up pottery on weekends.", "owner": "user", "tags": ["hobby"]}
+]
+```
+A SINGLE new memory carries two things: the job change (same dimension as the existing employment chain m1, which already has history → SUPERSEDE, becomes the new chain head) and an unrelated detail (pottery → ADD). Split the one memory into the right op per part — the new head describes ONLY the employment state, never the pottery.
+
+## Example 2 — Fold two unlinked existing memories + the new change into one 3-node chain
+
+Existing memories:
+[
+ {"memory_id": "a1", "content": "The user is learning to play the guitar.", "owner": "user", "memory_at": "2024-02-10 09:00"},
+ {"memory_id": "a2", "content": "The user can now play a few full songs on the guitar.", "owner": "user", "memory_at": "2024-09-05 09:00"}
+]
+New memories:
+[
+ {"content": "The user now performs guitar at local open-mic nights.", "owner": "user"}
+]
+
+Output:
+```json
+[
+ {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "The user performs guitar at local open-mic nights.", "supersede_reason": "guitar skill progressed: learning → playing songs → performing live", "owner": "user", "tags": ["music", "hobby"]}
+]
+```
+a1 and a2 were never linked, but they track the same dimension (guitar progress) and the new memory is the latest step. Fold them with `memory_ids` ordered oldest→newest; they become a 3-node chain (a1 ← a2 ← new head). The head `content` describes ONLY the current state — it does not restate "learning" or "a few songs".
+
+## Example 3 — New head must NOT copy the old memory's content
+
+Existing memories:
+[
+ {"memory_id": "c1", "content": "The user lives in a rented one-bedroom apartment in Shibuya, Tokyo, pays ¥180,000/month, loves the 5-minute walk to the station, but complains the place is noisy at night and has no parking.", "owner": "user"}
+]
+New memories:
+[
+ {"content": "The user just bought and moved into a three-bedroom house in the suburbs of Yokohama with a garden and a two-car garage.", "owner": "user"}
+]
+
+Output:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "c1", "content": "The user bought and moved into a three-bedroom house in suburban Yokohama, with a garden and a two-car garage.", "supersede_reason": "residence changed from a rented Shibuya apartment to an owned Yokohama house", "owner": "user", "tags": ["housing"]}
+]
+```
+The new memory SUPERSEDEs c1 and becomes the chain head. The head `content` describes ONLY the new Yokohama house. Do NOT drag the old apartment's distinctive details (Shibuya, ¥180,000 rent, the station walk, the noise/parking complaints) into the new node — those clearly belong to the old residence, not the new one. They stay in chain history and remain retrievable; copying them would make the head self-contradictory (renting in Shibuya AND owning in Yokohama at once).
+
+## Example 4 — Different subjects are never merged, however similar the wording
+
+Existing memories:
+[
+ {"memory_id": "d1", "content": "The user drinks black coffee every morning.", "owner": "user"}
+]
+New memories:
+[
+ {"content": "John drinks black coffee every morning.", "owner": "user"},
+ {"content": "The user now drinks black coffee twice a day, morning and after lunch.", "owner": "user"}
+]
+
+Output:
+```json
+[
+ {"op": "ADD", "content": "John drinks black coffee every morning.", "owner": "user", "tags": ["food"]},
+ {"op": "UPDATE", "memory_id": "d1", "content": "The user drinks black coffee twice a day, in the morning and after lunch.", "owner": "user", "tags": ["food"]}
+]
+```
+The two new memories are near-identical in wording but have DIFFERENT subjects. "John ..." is about another person, so it is a plain ADD — never an UPDATE or SUPERSEDE of d1, even though d1 says almost the same thing about the user. Only the memory whose subject is also "The user" may merge with d1.
+
+## Example 5 — Recurring event: bump count and keep a timeline (UPDATE, not ADD)
+
+Existing memories:
+[
+ {"memory_id": "i1", "content": "John injured his ankle last season and needed time off plus physical therapy.", "owner": "user", "memory_at": "2023-05-21 19:48"}
+]
+New memories:
+[
+ {"content": "John twisted his ankle again during a recent game.", "owner": "user", "memory_at": "2023-10-13 13:50"}
+]
+
+Output:
+```json
+[
+ {"op": "UPDATE", "memory_id": "i1", "content": "John has injured his ankle two times: first last season (around the 2022–2023 season), needing time off and physical therapy; second during a game around 2023-10-13.", "owner": "user", "tags": ["health", "basketball", "injury"]}
+]
+```
+Same event type happening again → UPDATE the old memory. State the **count** and list occurrences with times when known. Do NOT ADD a second "John injured his ankle" fact, and do NOT SUPERSEDE (the first injury did not stop being true).
+"""
+
+
+# ================================================================
+# Working / coding memory (coding/)
+# ================================================================
+
+CODING_EXTRACT_PROMPT = """\
+You extract durable WORKING memories from a task-execution session segment.
+A "working" session is any hands-on task where the user operates a computer /
+system through tools — this covers BOTH software/code work (writing, debugging,
+refactoring, building, deploying, API/library usage) AND system & operations
+work (running shell/PowerShell commands, disk/storage analysis or cleanup, file
+& folder operations, installing/configuring software, environment/device setup,
+hardware/disk health inspection, backup, scheduling/automation, data processing).
+
+You produce TWO layers from the SAME segment:
+
+ EXPERIENCES (procedural, "how to do it") — reusable method, extracted only
+ when it clears the VALUE BAR below. A (task, search_keys, solution,
+ boundary_envs) bundle.
+
+ FACT (episodic, "what happened this time") — EXACTLY ONE record of THIS
+ session: what the user wanted, how it was gone about, how it came out. No
+ value bar, but there is never more than one.
+
+The two layers answer different questions and are stored separately. A method
+that generalizes goes in EXPERIENCES; the story of this particular session —
+only true for this system / this project / right now — goes in the FACT.
+
+═══════════════════════════════════════════════════════════════════
+VALUE BAR (EXPERIENCES ONLY) — DO NOT cross this lightly.
+═══════════════════════════════════════════════════════════════════
+A memory MUST satisfy ALL of:
+ (a) Solves a problem likely to recur for the same user
+ (b) Solution is non-trivial: combines multiple pieces of info / steps, OR
+ carries a decision rationale, OR captures a hard-won workaround, OR is a
+ reusable procedure/recipe for an operational task (e.g. how to analyze &
+ clean up disk usage, how to batch-organize files, how to inspect hardware
+ health, how to set up a scheduled job)
+ (c) A future agent / user would prefer looking it up over re-discovering it
+
+IMPORTANT — analysis / diagnostic / investigation tasks COUNT:
+A task does NOT have to make a change or "fix" something to be worth remembering.
+Read-only / analytical / troubleshooting work is valuable when its PROCEDURE or
+CONCLUSION is reusable. Explicitly extract:
+ - Analysis / diagnostic recipes: the reusable procedure + what it revealed
+ (e.g. "how to analyze which folders eat C-drive space" — the scan commands,
+ the gotchas hit, and the finding). "It only produced a report, no change"
+ is NOT a reason to skip — the reusable METHOD is the memory.
+ - Investigation outcomes, INCLUDING negative / not-found results
+ (e.g. "searched folder X across C: and D: with rg / fs_search / SQL index —
+ not found anywhere"). A recorded dead-end saves the next agent from repeating
+ the same fruitless search, so it clears the bar.
+Do NOT reject a memory merely because "the assistant could regenerate the
+commands" or "nothing was actually modified". If the procedure or the conclusion
+would save future effort, keep it.
+
+DO NOT extract:
+ - Truly trivial single-step ops with no reusable procedure ("rename one file",
+ "git status", "run ls once")
+ - One-off issues already resolved with no transferable lesson
+ - Information that is already in the repo/system (don't duplicate package.json)
+ - Per-PR / per-session throwaway tasks unless they encode a reusable pattern
+ - The act of ASKING THE USER for missing information. Requesting a parameter,
+ listing what is unknown, or eliciting required fields is conversational
+ behaviour, not a method: every agent already knows how to ask a question, so
+ there is nothing to look up later. Never emit an experience whose task or
+ search_keys are shaped like "how to ask for X", "gather the missing Y",
+ "eliciting required fields", "what to clarify before starting". Note this
+ stays out of EXPERIENCES only — that the session ended waiting on the user
+ is real state and belongs in the FACT.
+
+If the segment made no substantive progress because it stalled waiting on the
+user — the assistant only asked for parameters, or was blocked before doing any
+real work — emit "experiences": [] and write the FACT alone. Nothing was
+learned yet, so there is no method to store. This matters more than it looks:
+an experience distilled from a stall reads as a legitimate skill on retrieval,
+and a later segment of the same task will match it and ask the user again
+instead of proceeding, so the stall reproduces itself for the rest of the
+session. Judge substance by what the tools actually did, not by whether the
+turn produced fluent text.
+
+Heuristic: if the user (or a future agent doing the same kind of task) would
+want this written down instead of figuring it out again, keep it. A multi-step
+operational procedure (even a system/ops or read-only analysis/search one, not
+just code) usually qualifies. Only drop it if it is a single command any user
+would find via `--help` in 30 seconds AND carries no decision/gotcha worth
+remembering.
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE FIELDS
+═══════════════════════════════════════════════════════════════════
+
+task — Query-shaped name; phrase as how a user would later ASK.
+ "publish a release to the xx platform" not
+ "publish_release_internal"
+ Self-contained (no "this", "the file", "we").
+
+search_keys — 0 to 5 alternative phrasings capturing important aspects of
+ solution that `task` alone wouldn't match. Phrase as questions
+ or topics future users would ASK ABOUT. Distinct from task.
+ Omit if task already covers everything.
+
+solution — Complete, self-contained content the user actually needs:
+ commands, credential locations (NOT credential VALUES),
+ file paths, ordered steps, gotchas, decision rationale.
+ Aggregate multi-turn end-to-end work into ONE solution if it
+ forms a coherent task; split into multiple memories only when
+ the user did unrelated tasks.
+
+boundary_envs — Concrete pinning that solution depends on, multi-line "key: value":
+ runtime / SDK / library + version
+ API endpoint or method signature
+ external service / middleware version
+ env var NAME (not value)
+ config file path
+ host / cluster / region identifier
+ If solution is environment-agnostic, leave as "" (empty).
+ Purpose: when the underlying SDK/middleware upgrades, future
+ consumers can inspect this to decide if solution still applies.
+
+confidence — 0.0 to 1.0
+ 1.0 user explicitly stated this as a rule / instruction
+ 0.7 inferred with good evidence from tool actions
+ 0.5 weakly inferred; one observation; uncertain
+
+═══════════════════════════════════════════════════════════════════
+FACT FIELD — EXACTLY ONE per segment, no value bar
+═══════════════════════════════════════════════════════════════════
+
+You write ONE fact for the whole segment — a recoverable state record for this
+session, not a polished retrospective and never a list of separate findings. A
+future agent must be able to resume from it without mistaking a suggestion,
+inference, or partial search for something verified.
+
+subject — WHO or WHAT this session is about: the single entity the work was
+ performed on or for. One short noun phrase, no sentence, no verb.
+ Pick the most specific entity that the session is *about*, not the
+ tool it used:
+ a person's name when the session serves one named person
+ ("Dylan", "Matthew")
+ the file / module / symbol when the work targets code
+ ("auth/middleware.ts", "parse_plan_text")
+ the service / host / device / drive for ops work
+ ("D:\\WXWork", "redis-cache-prod", "ci.yml")
+ This is a HARD KEY, not prose: two sessions about different people
+ or different files MUST get different subjects, and two sessions
+ about the same one MUST get the same string, spelled identically.
+ Prefer the exact identifier as it appears in the trace over a
+ description of it. If the segment genuinely has no single subject,
+ output "".
+
+ Why it matters: subject is the gate that decides whether a later
+ session is allowed to overwrite this one as "the same task,
+ continued". Get it wrong and one person's state silently replaces
+ another's.
+
+statement — A compact record of THIS session. Two parts, and the second is the
+ one that gets lost.
+ Preserve task-scoped givens and concrete constraints instead of
+ replacing them with a generic evaluation of the outcome. State
+ each rule once: repeated instruction text competes with the data
+ the memory must retain.
+
+ PART 1 — what happened, about 300 latin characters (~150 CJK).
+ Start with the specific goal and object ("reclaim disk space taken
+ by D:\\WXWork", "locate the new_file_search folder"), not a generic
+ "fix a bug" / "find a file". Then roughly what was inspected, tried,
+ or changed. Then how it ended, with the semantics of exactly one of:
+ completed, partially completed, failed, blocked, or
+ still awaiting verification. Include negative results and dead ends
+ without overstating them.
+
+ PART 2 — the TASK-SCOPED GIVENS: everything the WHOLE task runs on,
+ even when this segment did not establish it and even when it feels
+ too elementary to state. Bindings (what each name/symbol/label
+ stands for), fixed values the task supplies rather than derives,
+ conventions adopted (indexing base, units, timezone, defaults), and
+ this segment's own result WITH its value ("x = 7", not "the value
+ was computed").
+
+ Write PART 2 as data, one item per line, values as given:
+ 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
+ A line should be almost entirely values. Keep the trace's notation —
+ symbols, units, numbers, spellings — and drop its sentences: strip
+ the phrases that announce a given rather than being one ("I would
+ prefer", "it should be somewhere between … and …"). They repeat once
+ per item, so a 15-item list pays for them 15 times.
+ Carry them on EVERY fact; never write "as above" or "same as the
+ previous session" — retrieval returns a handful of facts by
+ similarity and the referent may not be among them.
+
+ Aim under 1200 characters total. If PART 2 does not fit, fix the
+ notation, never the coverage: statement is the retrieval vector AND
+ the only field a later segment can read (details is neither embedded
+ nor injected), so anything cut from it is gone. Compress the wording
+ around a given; never the given.
+
+ The test: if the next segment cannot see the original material, can
+ it continue from this record alone? Only a yes counts. A missing
+ binding does not fail loudly — the name still looks meaningful, so
+ it gets read with its general-usage meaning and the answer that
+ follows is fluent and about a different question.
+
+ LANGUAGE — same language as the session trace: statement is the
+ retrieval vector and queries arrive in the user's working language,
+ so another language pays a cross-lingual penalty on every lookup.
+
+ EVIDENCE FIDELITY — record only actions actually executed and
+ evidence explicitly present in the trace. Preserve material
+ commands, flags, arguments, errors, and numbers verbatim.
+ NEVER complete a command with customary flags, and never turn
+ advice or plans into actions:
+ "ran Get-ChildItem -Force" → "ran Get-ChildItem"
+ (the trace did not contain `-Force`; do not invent it)
+ Scope every negative finding to what was actually searched, and
+ enumerate EVERY explicit coverage limit that could invalidate it,
+ especially permission failures and depth limits: keep the roots,
+ filters, and depth that were in effect ("not found under C:\\ and
+ D:\\ at depth 3; some directories were not covered due to Access
+ denied"), never widen it to "does not exist". Do not omit one limit
+ to make the record prettier.
+ Never promote a partial search to global absence.
+ A blocked attempt keeps its blocker.
+ Preserve the distinction among attempted, observed, verified,
+ inferred, and unresolved — express it naturally ("tried … but was
+ blocked by Access denied", "suspected …, not yet verified"), not as
+ labels. Without tool output or explicit confirmation, NEVER claim a
+ fix succeeded, a cause was established, or a path does not exist.
+
+ Do NOT record greetings or pure chatter — that is the only case
+ getting "fact": null. A segment that merely stated requirements, or
+ stalled before doing work, still established something.
+
+details — The session's concrete OUTPUT, copied over verbatim. `statement` is
+ a summary and a summary necessarily drops the individual values; a
+ later lookup almost always wants one specific value, not the gist.
+ So whatever addressable result this session produced, reproduce it
+ here in its original form and structure:
+ a plan / schedule / itinerary → keep every line, every day, every
+ slot, and every price exactly as written
+ a config or code block → keep the block
+ a command's material output → keep the lines that carry the
+ findings (sizes, counts, versions, error text)
+ a structured result (table, list of records) → keep the rows
+ Preserve the original layout — line breaks, `Day 1:` / key: value
+ prefixes, units, currency symbols, ids. Do not re-summarize, do not
+ reorder, do not round numbers, do not translate.
+
+ Copy ONLY what is present in the trace. Never fill a gap: if a slot
+ was left unfilled, leave it unfilled or say so — an invented value
+ is worse than a missing one, because it will be retrieved and used.
+ Cap around 4000 characters; if the output is longer, keep the parts
+ carrying concrete values and drop decorative prose, noting what was
+ dropped.
+
+ "" when the session produced no such artifact (pure investigation
+ with no findings yet, or a stall waiting on the user).
+
+ This field is NOT part of the retrieval vector — `statement` and
+ `subject` do the finding, `details` supplies the value once found.
+ So do not write retrieval bait here, and do not duplicate the
+ summary; write the raw thing.
+
+files — 0..N absolute or repo-relative FILE OR DIRECTORY paths actually
+ operated on or investigated during this session. Keep investigated
+ roots such as `C:\\` and `D:\\`. Only include paths that were
+ actually accessed/searched, not paths merely suggested or planned;
+ [] if none apply.
+═══════════════════════════════════════════════════════════════════
+HOST CONTEXT (given by SDK)
+═══════════════════════════════════════════════════════════════════
+- workspace_id present: {workspace_present}
+- branch present: {branch_present}
+
+When no workspace_id is present, the solution cannot rely on unstated
+project-local context — spell out any repo / path / service it needs inside
+`solution` or `boundary_envs` so the memory stays usable on its own.
+
+═══════════════════════════════════════════════════════════════════
+CONVERSATION
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT (strict JSON only, no markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "subject": "...",
+ "statement": "...",
+ "files": ["..."],
+ "details": "..."
+ }}
+}}
+
+DEFAULT TO EXTRACTING. When the segment did real work, you MUST output at least
+one experience — even if the task looks simple or was a one-shot success, still
+capture the reusable essence of what was done (the method / command / how-to).
+When the session is thin, the single most valuable experience is enough.
+
+The ONE exception is the stall case above: if the segment did no real work
+because it was blocked asking the user for missing information, output
+"experiences": [] and write only the fact. Do not manufacture an experience to
+satisfy this instruction — a fabricated one ("how to ask for the departure
+city") is worse than none, because it is later retrieved and followed. Empty is
+allowed ONLY for that reason, never as a shortcut when work was actually done.
+
+"fact" is a SINGLE object, never a list — one record per session.
+
+ALWAYS write the fact. The bar for the fact is not "was this valuable" but "did
+anything at all happen", and a segment reaching you has already cleared that.
+This includes segments that look like setup rather than work: a single
+user message stating requirements, parameters, or a starting state, with no
+tools run, is exactly the material a later session cannot reconstruct on its own
+— 把需求、参数、起始状态连同情形一起写进 `statement`(紧凑记法,不要照抄对话原句),
+不要推给 `details`(`details` 不进检索向量,读取侧也不再注入它)。Use
+"fact": null ONLY for greetings and pure chatter with no content whatsoever.
+When in doubt, write the fact: an unneeded record costs one row, while a dropped
+one costs every later session that needed it and has no way to know it existed.
+"""
+
+CODING_EXTRACT_PROMPT_CODING = """\
+╔═══════════════════════════════════════════════════════════════════════════╗
+║ HARD CONSTRAINT — read this before anything else, it overrides any ║
+║ phrasing later in this prompt that sounds like it wants a narrative. ║
+║ ║
+║ You are NOT writing a report of what a person did. You are writing what a ║
+║ FUTURE AGENT needs in order to act. That agent already has its own task; ║
+║ it does not care what this user wanted. It needs to know: what was decided ║
+║ here, at which code coordinates, what was tried and rejected, and whether ║
+║ it was verified. ║
+║ ║
+║ Concretely, in every `statement` and every `solution`: ║
+║ · The grammatical subject is the CODE or THE DECISION — never "the user" ║
+║ and never "the agent". Do not write "The user attempted to…", ║
+║ "The user wanted…", "The agent then checked…". ║
+║ · Never close with a bookkeeping phrase like "the session was completed", ║
+║ "the error was noted", "no solution was found yet". Close with the ║
+║ decision and its verification status. If nothing was decided, close ║
+║ with what was RULED OUT and the next unexplored lead — that is the ║
+║ reusable part. ║
+║ · Keep the concrete symptom (error string, failing command, wrong ║
+║ output) — that is what a future search will match on. ║
+║ ║
+║ bad: "The user attempted to write a QTable to RST with header_rows and ║
+║ hit a TypeError. The session was completed with the error noted." ║
+║ good: "ascii.rst's RST writer rejects header_rows: `tbl.write(..., \\ ║
+║ format='ascii.rst', header_rows=['name','unit'])` raises TypeError ║
+║ because RST.__init__ does not forward it, unlike ascii.fixed_width ║
+║ which accepts it. No fix written — the writer needs the same ║
+║ header_rows plumbing as fixed_width." ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+
+You extract durable WORKING memories from a task-execution session segment.
+A "working" session is any hands-on task where the user operates a computer /
+system through tools — this covers BOTH software/code work (writing, debugging,
+refactoring, building, deploying, API/library usage) AND system & operations
+work (running shell/PowerShell commands, disk/storage analysis or cleanup, file
+& folder operations, installing/configuring software, environment/device setup,
+hardware/disk health inspection, backup, scheduling/automation, data processing).
+
+You produce TWO layers from the SAME segment:
+
+ EXPERIENCES (procedural, "how to do it") — reusable method, extracted only
+ when it clears the VALUE BAR below. A (task, search_keys, solution,
+ boundary_envs) bundle.
+
+ FACT (episodic, "what was established this time") — EXACTLY ONE record of THIS
+ session. It is NOT a narrative of what the user did. It records, in this order:
+ the task and its concrete symptom (this is what makes it findable later), the
+ code coordinates, WHAT WAS SETTLED ON and what was rejected, and how far it was
+ verified. No value bar, but there is never more than one.
+
+The two layers answer different questions and are stored separately. A method
+that generalizes goes in EXPERIENCES; the story of this particular session —
+only true for this system / this project / right now — goes in the FACT.
+
+═══════════════════════════════════════════════════════════════════
+VALUE BAR (EXPERIENCES ONLY) — DO NOT cross this lightly.
+═══════════════════════════════════════════════════════════════════
+A memory MUST satisfy ALL of:
+ (a) Solves a problem likely to recur for the same user
+ (b) Solution is non-trivial: combines multiple pieces of info / steps, OR
+ carries a decision rationale, OR captures a hard-won workaround, OR is a
+ reusable procedure/recipe for an operational task (e.g. how to analyze &
+ clean up disk usage, how to batch-organize files, how to inspect hardware
+ health, how to set up a scheduled job)
+ (c) A future agent / user would prefer looking it up over re-discovering it
+
+IMPORTANT — analysis / diagnostic / investigation tasks COUNT:
+A task does NOT have to make a change or "fix" something to be worth remembering.
+Read-only / analytical / troubleshooting work is valuable when its PROCEDURE or
+CONCLUSION is reusable. Explicitly extract:
+ - Analysis / diagnostic recipes: the reusable procedure + what it revealed
+ (e.g. "how to analyze which folders eat C-drive space" — the scan commands,
+ the gotchas hit, and the finding). "It only produced a report, no change"
+ is NOT a reason to skip — the reusable METHOD is the memory.
+ - Investigation outcomes, INCLUDING negative / not-found results
+ (e.g. "searched folder X across C: and D: with rg / fs_search / SQL index —
+ not found anywhere"). A recorded dead-end saves the next agent from repeating
+ the same fruitless search, so it clears the bar.
+Do NOT reject a memory merely because "the assistant could regenerate the
+commands" or "nothing was actually modified". If the procedure or the conclusion
+would save future effort, keep it.
+
+DO NOT extract:
+ - Truly trivial single-step ops with no reusable procedure ("rename one file",
+ "git status", "run ls once")
+ - One-off issues already resolved with no transferable lesson
+ - Information that is already in the repo/system (don't duplicate package.json)
+ - Per-PR / per-session throwaway tasks unless they encode a reusable pattern
+
+Heuristic: if the user (or a future agent doing the same kind of task) would
+want this written down instead of figuring it out again, keep it. A multi-step
+operational procedure (even a system/ops or read-only analysis/search one, not
+just code) usually qualifies. Only drop it if it is a single command any user
+would find via `--help` in 30 seconds AND carries no decision/gotcha worth
+remembering.
+
+═══════════════════════════════════════════════════════════════════
+CODE WORK — what a future agent cannot re-derive, so it MUST be captured
+═══════════════════════════════════════════════════════════════════
+When the segment is software work on a repository, the reusable method is only
+half of it. The other half is WHERE the work lives and WHICH VERSION won. Those
+cannot be recovered by reading the code later — the code shows the current state,
+not which branch it sits on, nor what was already rejected.
+
+This section does NOT ask for a longer record. It asks you to SPEND THE SAME
+BUDGET on higher-value tokens: drop restated goals, narration of what the
+assistant "then decided to", and pasted code you are only echoing; spend those
+characters on the four items below instead. A record that omits the branch but
+quotes 30 lines of diff is a bad trade.
+
+1. BRANCH / WORKING LOCATION — verbatim, in the fact `statement`. If the segment
+ mentions or checks out `feat/x` / `fix/y`, that token MUST appear. An agent
+ that resumes on the wrong branch produces changes that are silently thrown
+ away, so this one token outranks every other detail.
+
+2. WHICH VERSION WON — when the user changed their mind, name the winner and mark
+ the loser in one clause: "settled on A; the interim B was dropped". Not both in
+ full — one clause. Keeping only the latest is wrong: an agent that meets the
+ rejected code must recognize it, or it will "fix" things back to the discarded
+ variant. Phrases like `scratch that / go back to / actually, let's / no, not that`
+ mark this: what follows is of record, what precedes is superseded.
+
+3. EXACT COORDINATES, NOT PASTED CODE — repo-relative path
+ (`qutebrowser/utils/debug.py`, never bare `debug.py`) plus the function /
+ class touched. If a signature changed, give the new signature. If a constant,
+ regex or literal was decided, quote THAT verbatim — but quote only it, not the
+ surrounding block. One accurate line beats a paragraph of approximation.
+
+4. VERIFIED vs MERELY WRITTEN — four words is enough ("tests run and passing" /
+ "confirmed by git diff only, tests not run"). "the edit is in" and "the edit is in
+ and tested" lead a future agent to do very different things next.
+
+Anti-pattern — summarizing the goal and dropping the coordinates:
+ bad: "refactored the colour parsing logic to be cleaner."
+ good: "on feat/q4, in qutebrowser/config/configtypes.py QtColor._parse_value:
+ settled on `mult = 360.0 if kind == 'h' else 255.0`; the interim version that
+ used 255.0 for everything was dropped. Tests not run."
+ (the good one is SHORTER than most bad ones — it just spends every character
+ on something that cannot be re-derived)
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE FIELDS
+═══════════════════════════════════════════════════════════════════
+
+task — Query-shaped name; phrase as how a user would later ASK.
+ "publish a release to the xx platform", not "publish_release_internal"
+ Self-contained (no "this", "the file", "we").
+
+search_keys — 0 to 5 alternative phrasings capturing important aspects of
+ solution that `task` alone wouldn't match. Phrase as questions
+ or topics future users would ASK ABOUT. Distinct from task.
+ Omit if task already covers everything.
+
+solution — Complete, self-contained content the user actually needs:
+ commands, credential locations (NOT credential VALUES),
+ file paths, ordered steps, gotchas, decision rationale.
+ Aggregate multi-turn end-to-end work into ONE solution if it
+ forms a coherent task; split into multiple memories only when
+ the user did unrelated tasks.
+
+boundary_envs — Concrete pinning that solution depends on, multi-line "key: value":
+ runtime / SDK / library + version
+ API endpoint or method signature
+ external service / middleware version
+ env var NAME (not value)
+ config file path
+ host / cluster / region identifier
+ If solution is environment-agnostic, leave as "" (empty).
+ Purpose: when the underlying SDK/middleware upgrades, future
+ consumers can inspect this to decide if solution still applies.
+
+confidence — 0.0 to 1.0
+ 1.0 user explicitly stated this as a rule / instruction
+ 0.7 inferred with good evidence from tool actions
+ 0.5 weakly inferred; one observation; uncertain
+
+═══════════════════════════════════════════════════════════════════
+FACT FIELD — EXACTLY ONE per segment, no value bar
+═══════════════════════════════════════════════════════════════════
+
+You write ONE fact for the whole segment — a recoverable state record for this
+session, not a polished retrospective and never a list of separate findings. A
+future agent must be able to resume from it without mistaking a suggestion,
+inference, or partial search for something verified.
+
+statement — A compact summary of THIS session. It has two jobs at once, and it
+ must do BOTH: it is the retrieval vector (a future agent finds it by
+ searching with a fresh issue report, phrased the way a user phrases a
+ problem), and it is the payload that agent then acts on. So:
+
+ OPEN with the task and the symptom, in the words a user would use.
+ This is what makes it findable — keep the surface form close to how
+ the problem would be reported. Name the specific goal and object
+ ("reclaim disk space under D:\\WXWork", "adjust the hue multiplier
+ in QtColor._parse_value on feat/q4", "locate the new_file_search
+ folder"), never a generic "fix a bug" / "look for a file". Include
+ the concrete symptom: the error string, the failing command, the
+ wrong output.
+
+ THEN give the coordinates and the decision.
+ repo-relative path, symbol, and branch for code work. State what was
+ SETTLED ON, and in the same clause mark what was dropped
+ ("settled on X; the interim Y was dropped"). This is the part that
+ cannot be re-derived by reading the code — the code only shows the
+ winner, never that Y was tried and rejected. An agent that meets the
+ rejected variant later must be able to recognize it, or it will
+ "fix" the code back to the discarded version.
+
+ CLOSE with the evidence status.
+ Exactly one of: completed, partially completed, failed, blocked, or
+ still awaiting verification — plus how it was checked ("tests run and
+ passing" / "confirmed by git diff only, tests not run"). Include
+ negative results and dead ends without overstating them.
+
+ ⚠️ Never stop at the narrative. "The user tried X and hit error Y; no
+ solution found yet" is a wasted record: it retrieves fine but gives a
+ future agent nothing to act on. If the session genuinely reached no
+ decision, say what was ruled out and what the next unexplored lead is —
+ that is the reusable part.
+
+ The subject of the sentences should be the code and the decision, not
+ "the user". 2 to 4 sentences, flowing prose, not labelled sections.
+ Hard ceiling ~400 latin characters (~200 CJK characters).
+
+ EVIDENCE FIDELITY — mandatory:
+ - Record only actions actually executed and evidence explicitly
+ present in the trace. Preserve material commands, flags,
+ arguments, errors, and numbers verbatim. NEVER complete a
+ command with customary flags or turn advice/plans into actions.
+ - Preserve the distinction among attempted, observed, verified,
+ inferred, and unresolved. Do not add those labels to the prose;
+ express their meaning naturally, e.g. "tried … but was blocked by
+ Access denied" or "suspect … , not yet verified".
+ - Without tool output or explicit confirmation, NEVER claim a fix
+ succeeded, a cause was established, a file/folder does not
+ exist, or tests passed.
+ - Scope every negative finding to what was actually searched and
+ enumerate EVERY explicit coverage limit that could invalidate
+ it, especially permission failures and maximum search depth:
+ "not found within the searched parts of C:\\ and D:\\; some
+ directories were skipped on Access denied, and the search was also
+ depth-limited". Do not omit one limit to make the
+ summary prettier. Never promote a partial search to global
+ absence.
+ - State causality as certain only when the trace directly verifies
+ it. Otherwise retain the hedge ("suspected" / "inferred" / "not yet
+ verified"); do not rewrite an
+ incorrect test assumption as the system's root cause.
+
+ CRITICAL — this text IS the retrieval vector, and it is the only
+ thing a future query gets matched against. A generic summary is
+ worthless, because EVERY session looks like a generic summary: it
+ would match every query and answer none of them. So you MUST name
+ the concrete anchors that make THIS session findable — real file
+ paths, function / symbol names, branch names, commands, error
+ strings, versions, config keys and values, host / service names.
+ If someone later searches for any one of those specifics, this
+ summary has to be the thing that comes back.
+ good: "fixing a failing `npm run build` in CI. Read
+ .github/workflows/ci.yml and package.json; traced it to webpack
+ 5.74 hitting ERR_OSSL_EVP_UNSUPPORTED under node 18. Bumping the
+ workflow's node to 20 made the build pass; node 18 still
+ reproduces locally."
+ good: "on branch feat/q0, in qutebrowser/utils/debug.py signal_name:
+ PyQt<5.11 only exposes the name via repr(sig), and repr comes in
+ both a bracketed and a parenthesised form. Settled on two patterns
+ tried in order with fullmatch, breaking on the first hit; the
+ single-regex version was dropped. Confirmed by git diff, tests not
+ run."
+ bad: "user wanted a build bug fixed, the agent looked at some config
+ files, changed some code, and fixed it."
+ (no path, no command, no error string, no version — nothing
+ to retrieve on; every session reads exactly like this)
+ bad: "fixed the signal-name parsing compatibility issue on a feature
+ branch."
+ (which branch? which file? which function? which of the two
+ competing versions won? nothing here survives being
+ retrieved a week later)
+ Fidelity examples (bad → good):
+ "ran Get-ChildItem -Force" → "ran Get-ChildItem"
+ (the trace did not contain `-Force`; do not invent it)
+ "confirmed new_file_search does not exist" →
+ "new_file_search was not found within the searched parts of C:\\ and
+ D:\\; some directories were skipped on Access denied or by the depth
+ limit, so the investigation is only partly done"
+ "identical payloads cause a spurious lock error" →
+ "the verification script assumed the last writer is always a fixed
+ rank; that assumption does not hold, so whether there is a lock bug
+ is still unverified"
+
+ Do NOT record greetings or pure chatter. If the segment established
+ nothing at all, output "fact": null.
+
+files — 0..N absolute or repo-relative FILE OR DIRECTORY paths actually
+ operated on or investigated during this session. Keep investigated
+ roots such as `C:\\` and `D:\\`. Only include paths that were
+ actually accessed/searched, not paths merely suggested or planned;
+ [] if none apply.
+
+═══════════════════════════════════════════════════════════════════
+HOST CONTEXT (given by SDK)
+═══════════════════════════════════════════════════════════════════
+- workspace_id present: {workspace_present}
+- branch present: {branch_present}
+
+When no workspace_id is present, the solution cannot rely on unstated
+project-local context — spell out any repo / path / service it needs inside
+`solution` or `boundary_envs` so the memory stays usable on its own.
+
+═══════════════════════════════════════════════════════════════════
+CONVERSATION
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT (strict JSON only, no markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "statement": "...",
+ "files": ["..."]
+ }}
+}}
+
+MANDATORY: You MUST output at least ONE experience. Do NOT return an empty list.
+Even if the task looks simple or is a one-shot success, still capture the
+reusable essence of what was done (the method / command / how-to). Only the
+single most valuable experience is required when the session is thin — but never
+output an empty "experiences" array.
+
+"fact" is a SINGLE object, never a list — one record per session. Use
+"fact": null only when the segment is pure chatter that established nothing.
+"""
+
+CODING_RECONCILE_PROMPT = """\
+You decide how to merge new coding memory drafts with the user's existing memories.
+
+For each new draft, decide one of:
+ ADD — no existing memory describes the same task/aspect
+ UPDATE — an existing memory describes the same task; the new draft replaces it
+ (solution may have changed, env may have upgraded, etc.)
+ SKIP — duplicate of existing; nothing new
+
+Additionally, you may emit DELETE ops on existing candidates when the new
+content makes them obsolete or invalid:
+ DELETE — the new conversation EXPLICITLY supersedes/cancels/invalidates an
+ existing memory that cannot be repaired via UPDATE. Examples:
+ * user says "don't use X anymore" and X is only present as a
+ separate memory (not the one being added/updated)
+ * candidate's boundary_envs (service / endpoint / SDK) is gone
+ and the new conversation confirms the deprecation
+
+Rules:
+- "Same task" means the existing memory and the new draft would both be valid
+ answers to the same future user query.
+- If solution differs, prefer UPDATE (we don't keep history).
+- If both task and solution match closely, SKIP.
+- DELETE only when there is EXPLICIT evidence the candidate is invalid/obsolete.
+ Never DELETE just because a candidate looks "stale".
+- Output ops can outnumber drafts when DELETEs are produced.
+
+═══════════════════════════════════════════════════════════════════
+NEW DRAFTS
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+EXISTING CANDIDATES (per draft, retrieved by task similarity)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT (strict JSON only, no 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": "user explicitly deprecated Y"}},
+ {{"draft_idx": 2, "action": "SKIP", "reason": "duplicate"}}
+ ]
+}}
+
+If there are no drafts, output {{"ops": []}}.
+"""
+
+CODING_FACT_RECONCILE_PROMPT = """\
+You maintain session-level WORKING FACTS. Each statement summarizes one whole
+trace/session: the user's task, the rough approach, and the result. It is not an
+atomic claim.
+
+Every new session fact below WILL be stored; that is not your decision. Your only
+job is to detect task continuation: is the new session continuing to advance the
+SAME user task as an existing session fact? If so, SUPERSEDE the older fact so
+the links form a cross-session progress chain for that task.
+
+Mark an existing fact as superseded ONLY when there is strong evidence that:
+ - The subjects match: both records are about the SAME entity — the same
+ person, the same file/module, the same host/service. A shared subject is
+ necessary but not sufficient; AND
+ - The user goal is materially the SAME, not merely in the same topic/project;
+ AND
+ - The new trace continues, retries, extends, verifies, or finishes the work
+ recorded by the existing trace.
+
+Do NOT supersede when:
+ - The two records name different subjects. Two people in one group, two files
+ in one module, two hosts in one cluster are PARALLEL, not successive: one
+ person's state is not a newer version of another's. Where a subject is shown
+ as (unspecified), fall back to judging by the statement alone.
+ - The sessions merely mention the same file, symbol, component, repository,
+ error, or technology but pursue different user goals.
+ - One task only supplies context or a technique for another task.
+ - The relationship is uncertain. Be conservative: INSERT is the safe default;
+ merging unrelated sessions destroys their separate task history.
+
+Treat each statement as evidence-bounded text. Do not reinterpret an inference
+inside it as an established cause or use a shared conjecture/error as proof that
+the user goals are the same. Your decision is only about task continuation; do
+not "correct", complete, or embellish either session record.
+
+Examples:
+ existing: "The user needed to fix CI's npm run build; traced it to
+ ERR_OSSL_EVP_UNSUPPORTED under Node 18, workflow not yet changed."
+ new: "The user continued fixing the same CI build; raised Node in
+ .github/workflows/ci.yml to 20 and npm run build passed."
+ → SUPERSEDE
+
+ existing: "The user needed to fix JWT expiry handling in
+ auth/middleware.ts; refresh logic was added."
+ new: "The user needed performance logging added to
+ auth/middleware.ts; a latency metric was introduced."
+ → keep both
+ (same file/project, different user goal)
+
+═══════════════════════════════════════════════════════════════════
+NEW SESSION FACTS
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+EXISTING SESSION FACTS (per new fact, retrieved by statement similarity)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT (strict JSON only, no markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "ops": [
+ {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "continues the same CI fix task"}},
+ {{"draft_idx": 1, "supersedes": []}}
+ ]
+}}
+
+Only use fact ids that appear in the candidate list for that same draft_idx.
+If nothing is superseded anywhere, output {{"ops": []}}.
+"""
+
+CODING_CHAIN_SUMMARY_PROMPT = """\
+A user task in a working-memory store has progressed across sessions. Below are
+the session summaries in that task's progress chain, oldest first, ending with
+the current session.
+
+Summarize how the SAME task progressed across sessions to its current state.
+Cover every important stage in chronological order. For each stage, preserve
+where available: the actual action or change, its direct result, and any
+unresolved issue or limiting condition. End with an explicit current status.
+
+Rules:
+ - This is compression only. Report ONLY what the entries say; never add or
+ complete a command, cause, motive, action, test result, success state, or
+ global negative conclusion.
+ - Preserve evidence status exactly: attempted is not completed, observed is
+ not verified, inferred is not established, and unresolved stays unresolved.
+ Keep uncertainty words and search/permission/coverage limits.
+ - State the current ending status faithfully (completed, partially completed,
+ failed, blocked, or still awaiting verification). Never upgrade it based on
+ a plausible causal story or on a later entry that did not verify it.
+ - When entries mention a suspected cause and a later result, connect them
+ causally only if an entry directly says that cause was verified.
+ - Preserve concrete retrieval anchors: file paths, symbols, commands, error
+ strings, versions, config keys/values, and important numeric values that
+ matter to the progress.
+ - For chains of 2-3 generations, do not over-compress the progression into one
+ sentence. Prefer 2-4 compact paragraphs when useful, or readable prose with
+ a clear task goal, stage-by-stage progression, and current status.
+ - Do not mechanically copy the full history. Omit repetition and low-value
+ detail while retaining important actions, direct results, and leftovers.
+ - Do not invent stage headings or dates. Mention a date only when the entries
+ make it meaningful; bare timestamps are noise.
+ - If the entries say older revisions were omitted, explicitly state that
+ earlier history was omitted; do not imply the supplied entries are complete.
+ - Write in the same language the entries are written in.
+ - No preamble or enclosing quotes.
+
+Example
+ entries:
+ (2026-07-20) The user needed to fix CI's npm run build; traced it to
+ ERR_OSSL_EVP_UNSUPPORTED under Node 18, workflow not yet
+ changed.
+ (2026-07-24) The user continued that CI fix; raised Node in
+ .github/workflows/ci.yml to 20, but the dependency cache
+ still reproduced the old error.
+ (now) The user continued verifying the same fix; after clearing the
+ npm cache, npm run build passed.
+ output:
+ The task goal is fixing CI's npm run build. It was first traced to
+ ERR_OSSL_EVP_UNSUPPORTED under Node 18, with the workflow not yet changed;
+ then .github/workflows/ci.yml was raised to Node 20, but the dependency
+ cache kept the old error present. Finally, after clearing the npm cache,
+ npm run build passed, so this build fix is currently verified as complete.
+
+═══════════════════════════════════════════════════════════════════
+ENTRIES
+═══════════════════════════════════════════════════════════════════
+{chain_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT (the summary itself, nothing else)
+═══════════════════════════════════════════════════════════════════
+"""
+
+
+# ================================================================
+# Episode / topic summaries
+# ================================================================
+
+EPISODE_SUMMARY_PROMPT = """You are summarizing ONE episode of conversation with the user.
+
+An episode is a single stretch of discussion — one thing that was talked about,
+possibly across several sessions of writing.
+
+## Memories captured during this episode (oldest → newest)
+
+{memories}
+
+---
+
+Write a single dense summary of what happened / what was discussed in this episode.
+
+Rules:
+
+* 2–4 sentences, third person, starting with "The user ..." (or the named person
+ if the memories are about someone else).
+* Tie the memories together into one coherent account — an episode usually has a
+ thread running through it (a plan, a problem, an outing, a decision).
+* Preserve concrete details: names, places, numbers, dates.
+* Do NOT invent anything that is not in the memories.
+* Do NOT enumerate the memories one by one; synthesize them.
+* Output language must match the language of the memories.
+
+Return ONLY the summary text, no preamble, no JSON, no quotes."""
+
+TOPIC_SUMMARY_PROMPT = """You are summarizing everything known about ONE topic.
+
+## Topic
+
+{topic_name}
+
+## Memories under this topic (oldest → newest)
+
+{memories}
+
+---
+
+Write a single dense summary of what is known about the user with respect to this
+topic.
+
+Rules:
+
+* 2–4 sentences, third person, starting with "The user ..." (or the named person
+ if the memories are about someone else).
+* Cover the topic as a whole — state the current situation, and mention how it
+ developed only when the change matters.
+* Preserve concrete details: names, places, numbers, dates.
+* Do NOT invent anything that is not in the memories.
+* Do NOT enumerate the memories one by one; synthesize them.
+* Output language must match the language of the memories.
+
+Return ONLY the summary text, no preamble, no JSON, no quotes."""
+
+
+# ================================================================
+# System 2 evolve (pipelines/system2_agent.py)
+# ================================================================
+
+SYSTEM2_AGENT_PROMPT = """You are a cognitive processing Agent. Your job is to evolve higher-order cognitive structures from a user's raw memory data.
+
+## Memory Architecture
+
+### VDB (Vector Database) — read-only
+| Layer | Description |
+|-------|-------------|
+| L0 BASIC_INFO | User attributes (name, age, occupation) |
+| L1 RAW | Original conversation transcripts |
+| L2 FACT | Atomic facts extracted from conversations |
+| L3 SUMMARY | Session summaries |
+| L4 IDENTITY | Identity traits, preferences, habits |
+| L5 KNOWLEDGE | Domain knowledge |
+
+### Graph (Knowledge Graph) — you are the sole writer
+| Layer | Description |
+|-------|-------------|
+| L6 SCHEMA | Behavioral patterns — domain-bound, atomic, immutable once created |
+
+## What is an L6 Schema?
+
+A Schema is one cross-event behavioral pattern in the long-term user model and
+contains the following three components:
+
+
+- **Circumstance**: The domain/topic/situation where this pattern is observed. A Schema MUST stay within its circumstance — do NOT generalize across domains. Cross-domain abstraction is handled separately by the system.
+- **Pattern**: The user's habitual behavior, thinking style, or action tendency in this circumstance.
+- **Insight**: The underlying psychological driver or mental model.
+
+### Content format
+Use a single sentence combining all three:
+"When [circumstance], the user [pattern] — reflecting [insight]."
+
+For durable emotional, therapy, stress, grief, or trauma-related patterns, do
+not erase the specific autobiographical background into a generic personality
+label. Prefer an anchored structure that preserves:
+"Trigger/background -> recurring emotional response -> observed coping resource."
+Only include triggers, responses, and coping resources present in user-owned
+evidence. Assistant advice is not an observed user coping resource.
+
+### Rules
+- **Atomic**: One pattern per Schema. Two distinct patterns → two Schemas.
+- **Immutable**: Once created, content NEVER changes.
+- **Evidence only**: New facts that merely support existing wording → call
+ `add_evidence`. If new evidence materially changes, corrects, or narrows the
+ current durable state, use `revise_schema` so the old version is retained for
+ audit but removed from active retrieval.
+- **Domain-bound**: Stay within the observed domain. Cross-domain abstraction is handled by a separate system process.
+- **Separate facts from patterns**: A single explicit identity, health state,
+ equipment use, affiliation, project, or preference belongs in L2 state memory,
+ not L6. L6 requires user-owned evidence representing at least two independent
+ raw writes or sessions. One reconciled L2 fact may represent multiple writes;
+ inspect its source_raw_memory_ids rather than counting fact nodes.
+- **Subject safety**: Facts sharing a source chunk may describe other people or
+ examples. Create a user Schema only when the material explicitly attributes
+ the pattern to the user. Otherwise output no operation for that material.
+- **Candidate coverage**: In a source-context review, account for every listed
+ candidate fact: either use it as evidence in `create_schema`/`add_evidence`,
+ or emit `skip_fact`. Raw context may confirm its subject or restore omitted
+ detail, but must not seed unrelated Schemas.
+- **Evidence threshold**: Creating L6 requires one or more user-owned evidence
+ facts representing at least two independent raw writes or sessions.
+ Assistant advice does not establish a user pattern by itself.
+
+### Good vs Bad examples
+✅ "When cooking, the user strictly follows recipe steps and precisely measures ingredients — reflecting a need for external structure to manage uncertainty."
+✅ "When gaming, the user always checks walkthroughs to achieve 100% completion — driven by low tolerance for incompleteness."
+✅ "After an unexpected mentor loss, mortality reminders can bring grief back suddenly; the user pauses to reflect and takes quiet walks to regain steadiness."
+❌ "The user approaches music as a medium for creative synthesis and cultural bridge-building, consistently blending diverse musical traditions..." (multiple patterns merged, too broad)
+❌ "The user is passionate about many things and values quality." (no circumstance, too vague)
+❌ "The user is meaning-driven and resilient." (erases the durable trigger and observed coping evidence)
+
+## Your Workflow
+
+Input materials (you are only invoked when at least one cluster exists):
+- **Cluster Results**: Primary input — facts grouped by semantic similarity
+- **Unclustered Facts (supplemental)**: Facts not in any cluster; lower priority than cluster results
+
+For each group of facts (clustered or unclustered):
+1. **Search existing Schemas**: If an existing Schema already captures this pattern, call `add_evidence`. Use `revise_schema` only when the old wording would become materially incomplete or misleading after adding the new evidence.
+2. **Create new Schema**: Only if no existing Schema covers this pattern. One sentence, three components.
+3. **Build relationships**: If two Schemas are thematically related, use `add_edge` (RELATED_TO).
+
+## Principles
+
+- All Graph operations MUST go through tools
+- Schema content is IMMUTABLE — never recreate what already exists
+- Prefer `add_evidence` over creating duplicates
+- Prefer not creating over creating low-quality nodes
+- One Schema = one atomic pattern in one domain
+- When tagging, prefer reusing tags from the existing tags list"""
+
+
+# ================================================================
+# Fragments assembled in code
+# ================================================================
+
+# Display name of this language, used in logs and docs.
+LANGUAGE_NAME = "English"
+
+# 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, so their prompts stay exactly as before.
+OUTPUT_LANGUAGE_DIRECTIVE = """
+
+---
+
+# OUTPUT LANGUAGE
+
+Write every natural-language value you output (memory text, summaries, reasons, queries) in English, whatever language the conversation or the existing memories use. This overrides any rule above that says to match the input language. Keep JSON keys, field names, enum values, operation names, IDs, code, file paths, commands, error messages and proper nouns exactly as they are.
+"""
+
+# 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"# TWO KINDS OF MEMORY.*?(?=\n# OWNER\n)"
+
+NO_INTENTION_MEMORY_SECTION = (
+ "# MEMORY\n"
+ "\n"
+ "You extract one kind of memory: **memory**.\n"
+ "\n"
+ "## memory\n"
+ "\n"
+ "Everything durable and worth remembering about the user — and about any other\n"
+ "named person in the conversation — goes here:\n"
+ "\n"
+ "* preferences, opinions, values, attitudes\n"
+ "* events, actions, experiences\n"
+ "* habits, behavioral patterns\n"
+ "* relationships, traits\n"
+ "* objective facts, decisions, constraints\n"
+ "* ongoing activities\n"
+ "* **future plans / upcoming actions** that are worth remembering\n"
+ " (put them in `memory`; do NOT invent a separate intentions bucket)\n"
+ "\n"
+ "Implicit preferences MUST be inferred when strongly suggested.\n"
+ "\n"
+ "Do NOT separate \"what kind of person the user is\" from \"what happened\".\n"
+ "Both go into `memory`.\n"
+ "\n"
+ "---\n"
+ "\n"
+)
+
+# (old, new) pairs applied in order after the section swap.
+NO_INTENTION_REPLACEMENTS = (
+ (
+ "Every memory and intention MUST carry an `owner`",
+ "Every memory MUST carry an `owner`",
+ ),
+)
+
+INTENTION_DISABLED_NOTE = (
+ "\n\n---\n\n# INTENTION DISABLED\n"
+ "Intention extraction is disabled. Even if few-shot examples show "
+ "`intentions`, do **not** emit that key; put future plans in `memory`.\n"
+)
+
+# Coding / working extractor: wraps the history and the new messages.
+CODING_CONVERSATION_BLOCK = (
+ "LAST 5 USER TURNS (CONTEXT ONLY; do not extract them again):\n"
+ "{history}"
+ "\n\nNEW MESSAGES (extract only from this complete write):\n"
+ "{new}"
+)
+CODING_EMPTY_BLOCK = "(none)"
+
+# 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 = "The user's name is {name}"
+
+# System 2 single-call mode: output contract appended to SYSTEM2_AGENT_PROMPT.
+SYSTEM2_OUTPUT_INSTRUCTIONS = """
+
+## Output Format
+
+Do NOT call tools. Output a JSON array of operations directly, wrapped in a ```json code block.
+
+Available operations:
+
+1. **create_schema** — Create a new L6 behavioral Schema
+ ```{"op": "create_schema", "schema_kind": "behavior_pattern", "content": "concise user-facing pattern", "retrieval_text": "behavior plus relevant situations", "evidence_list": ["fact_node_id_1", "fact_node_id_2"], "tags": ["tag1"]}```
+
+2. **add_evidence** — Add evidence to an existing Schema (content stays immutable)
+ ```{"op": "add_evidence", "node_id": "existing_schema_node_id", "evidence_list": ["new_fact_id_1"]}```
+
+3. **revise_schema** — Create a new version when new evidence materially changes the current state and retire the old version from active retrieval. Do not use it for compatible detail.
+ ```{"op": "revise_schema", "node_id": "old_schema_id", "schema_kind": "explicit_state", "content": "updated current profile", "retrieval_text": "updated retrieval text", "evidence_list": ["new_fact_id_1"], "tags": ["tag1"], "reason": "why the old wording would mislead"}```
+
+4. **add_edge** — Create a relationship between two Schemas
+ ```{"op": "add_edge", "source_id": "schema_id_1", "target_id": "schema_id_2", "reason": "relationship reason"}```
+
+5. **skip_fact** — Explicitly mark a candidate fact as reviewed without creating
+ a Schema. Use only for facts about another person, transient events, assistant
+ advice that does not establish a user trait, or facts already fully covered.
+ ```{"op": "skip_fact", "node_id": "candidate_fact_id", "reason": "not a durable user pattern"}```
+
+## Output Contract
+
+1. Output MUST be a JSON array wrapped in a ```json code block.
+2. If data is insufficient for reliable conclusions, output `[]`. In a
+ source-context review, `[]` means every candidate in that review was examined
+ and none supports a durable Schema.
+3. NO text outside the code block.
+4. evidence_list IDs must come from the fact node_ids provided in the materials.
+5. add_evidence / revise_schema node_id must come from existing Graph node IDs.
+6. For a source-context review, every candidate fact must appear in an evidence_list or skip_fact."""
+
+# Appended to SYSTEM2_OUTPUT_INSTRUCTIONS when the schema evidence gate is on.
+SYSTEM2_SCHEMA_EVIDENCE_GATE = """
+
+7. L6 represents cross-event behavioral patterns only. create_schema must use user-owned evidence representing at least two independent raw writes or sessions. A single reconciled fact can qualify when source_raw_memory_ids contains multiple independent writes.
+8. Do not create L6 for a single explicit identity, health state, equipment use, affiliation, project, or preference. Canonical L2 state projection owns those facts."""
+
+# (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
+# (or be harmless if it does not).
+SYSTEM2_SINGLE_CALL_REPLACEMENTS = (
+ ("- All Graph operations MUST go through tools\n", ""),
+ ("call `add_evidence`", "use add_evidence operation"),
+ ("use `add_edge` (RELATED_TO)", "use add_edge operation"),
+)
+
+# System 2 user message (materials). Keys are fixed; values are format
+# strings with the named fields shown.
+SYSTEM2_MATERIALS = {
+ "title": "## Preprocessed Materials\n",
+ "stats": (
+ "### Statistics\n- Total VDB facts: {total}\n"
+ "- Fresh facts (to process): {fresh} (evidenced_excluded={evidenced})\n"
+ "- Clusters found: {clusters}\n"
+ "- Facts in clusters: {clustered}, unclustered supplement: {unclustered}\n"
+ "- Graph Schemas total: {graph_total} (recalled={recalled})"
+ ),
+ "graph_status_empty": "- Graph status: **EMPTY** (first cognitive processing run)\n",
+ "clusters_header": "### Cluster Results\n",
+ "label_holistic": "{n} cross-session user facts; only evidence-backed durable emotional/therapy patterns",
+ "label_source_context": "{n} candidate facts; raw write is only for subject/detail validation",
+ "label_topic": "{n} facts, topic",
+ "raw_label": "Relevant raw excerpt per candidate",
+ "holistic_note": (
+ "This is one bounded nightly holistic consolidation pass. Create at most "
+ "{max_schemas} anchored therapy Schemas. "
+ "Prefer joining durable trigger/background, recurring emotional response, "
+ "and observed coping resource or decision constraint across different raw writes/sessions. "
+ "Before create_schema, union raw_sources for its evidence IDs and require at least two "
+ "distinct raw source IDs; two facts from one raw write are one event. "
+ "Output [] when evidence is insufficient.\n"
+ ),
+ "companion_header": "**Independent-source companion hints (candidates, not conclusions):**",
+ "unclustered_header": "### Unclustered Facts (supplemental)\n",
+ "unclustered_hint": "Facts below were not grouped into any cluster above. Review after cluster themes; lower priority than cluster results.\n",
+ "forward_header": "### Related Graph Nodes (retrieved via cluster centroid search, {count} hits)\n",
+ "graph_empty": "### Existing Graph Nodes\nThe Graph is currently EMPTY — this is the first cognitive processing run. Do NOT search the Graph (it will return nothing). Proceed directly to create Schemas from the cluster results.\n",
+ "graph_no_recall": (
+ "### Existing Graph Nodes\n"
+ "The Graph has {graph_total} Schemas, "
+ "but centroid-based vector recall found no matches. Decide based on cluster results whether new Schemas are needed.\n"
+ ),
+ "reverse_header": "### Graph Reverse References (VDB facts referenced by existing Schemas)\n",
+ "tags_header": "### Existing Tags (prefer reusing these over creating synonyms)\n",
+ "closing": (
+ "Analyze the materials above and output a JSON array of operations. "
+ "Decide whether to create new Schemas, or add evidence to existing ones. "
+ "If the data is insufficient for reliable conclusions, output an empty array `[]`. "
+ "When tagging, prefer reusing tags from the existing tags list above."
+ ),
+}
diff --git a/hy_memory/prompts/es.py b/hy_memory/prompts/es.py
new file mode 100644
index 0000000..dde677a
--- /dev/null
+++ b/hy_memory/prompts/es.py
@@ -0,0 +1,2307 @@
+# -*- coding: utf-8 -*-
+"""Spanish prompts (``es``).
+
+Translated from en.py; native-speaker review recommended.
+"""
+
+
+# ================================================================
+# Chat extraction (agent/extractor.py)
+# ================================================================
+
+EXTRACT_SYSTEM_PROMPT = """# ROL
+
+Eres un Extractor de Memoria (Memory Extractor).
+
+Extrae de las conversaciones memorias duraderas y de alto valor, y conviértelas en enunciados estructurados y autocontenidos.
+
+Extrae solo la información que probablemente importe en conversaciones futuras.
+
+---
+
+# ENTRADAS
+
+Recibirás:
+
+* Últimos k mensajes (Last k Messages)
+* Mensajes nuevos (New Messages)
+* Memory Date
+* Current Date
+
+Usa:
+
+* Últimos k mensajes solo para resolver correferencias
+* Memory Date como el ÚNICO ancla temporal
+* Current Date solo como metadato, nunca para resolver tiempos relativos
+
+---
+
+# QUÉ EXTRAER
+
+Extrae SOLO la información genuinamente nueva que aparece en los mensajes NUEVOS del usuario.
+
+Las buenas memorias incluyen:
+
+* preferencias
+* proyectos a largo plazo
+* hábitos
+* metas
+* actividades recurrentes
+* opiniones
+* relaciones
+* experiencias importantes
+* rasgos estables
+* planes futuros
+* decisiones
+* restricciones
+* recomendaciones aceptadas
+
+NO extraigas:
+
+* charla trivial
+* acuses de recibo
+* emociones genéricas
+* contexto conversacional temporal
+* recordatorios del asistente sobre memorias antiguas
+* información ya implícita en el contexto previo
+* juicios vagos sobre la personalidad
+
+---
+
+# SUJETO
+
+Cada memoria debe ser autocontenida, escrita en tercera persona y con un sujeto
+explícito. El sujeto que debes usar lo decide **quién habló**:
+
+| Hablante | Sujeto que escribir | Ejemplo |
+| --- | --- | --- |
+| `role: "user"` | el usuario | "El usuario ..." / "The user ..." / "用户..." |
+| cualquier hablante con un `name` distinto del usuario (p. ej. `name: "John"`) | esa persona, por su nombre | "John ..." |
+| `role: "assistant"` SIN `name` | el asistente de IA | "El asistente ..." |
+
+Las dos secciones de entrada expresan al hablante de forma distinta:
+
+* **Mensajes nuevos** es un array JSON: lee `role` y el campo opcional `name`.
+* **Últimos k mensajes** es texto renderizado: el hablante es la etiqueta entre corchetes,
+ `[user]:` / `[John]:` / `[assistant]:`, opcionalmente precedida de una línea
+ "El usuario se llama Tim" / "The user's name is Tim" / "用户名叫Tim".
+
+Reglas:
+
+* El usuario es la persona a quien pertenecen estas memorias. Aunque se conozca el
+ nombre propio del usuario (por el `name` de su mensaje o por la línea inicial con el
+ nombre), escribe igualmente "El usuario ...", NUNCA "Tim ...".
+* **Un `role: "assistant"` CON `name` es otra persona real, no la IA.**
+ Escribe sus memorias con su nombre como sujeto: "John ...".
+* Solo un `role: "assistant"` sin nombre es el asistente de IA.
+* Nunca inventes un nombre para el asistente de IA; no tiene ninguno.
+
+---
+
+# REGLAS DE IDIOMA
+
+* El idioma de salida debe coincidir con el idioma de entrada.
+* Conserva exactamente las escrituras originales y los términos técnicos.
+* Nunca translíteres nombres, marcas ni ecuaciones.
+
+---
+
+# DOS TIPOS DE MEMORIA
+
+Extraes dos tipos de memoria: **memory** (memorias) e **intentions** (intenciones).
+
+## memory
+
+Aquí va todo lo duradero y digno de recordar sobre el usuario, y sobre cualquier otra
+persona con nombre que aparezca en la conversación:
+
+* preferencias, opiniones, valores, actitudes
+* eventos, acciones, experiencias
+* hábitos, patrones de comportamiento
+* relaciones, rasgos
+* hechos objetivos, decisiones, restricciones
+* actividades en curso
+
+Las preferencias implícitas DEBEN inferirse cuando se sugieren con fuerza
+(p. ej. retomar una actividad → interés positivo; evitar algo →
+preferencia negativa; esfuerzo voluntario repetido → interés sostenido).
+
+NO separes "qué tipo de persona es el usuario" de "qué sucedió".
+Ambas cosas van en `memory`.
+
+## intentions
+
+Algo orientado al futuro que el usuario **planea o tiene intención de hacer**,
+sobre lo que se puede actuar y que deja de ser relevante una vez hecho o pasado.
+
+Ejemplos:
+
+* "El usuario tiene una entrevista de trabajo el próximo martes."
+* "El usuario planea mudarse de apartamento a fin de mes."
+* "El usuario tiene intención de terminar el informe antes del viernes."
+
+NO son intenciones (estas van en `memory`):
+
+* preferencias / rasgos estables ("Al usuario le gusta el baloncesto")
+* eventos pasados ya completados ("El usuario se mudó a Pekín el año pasado")
+* metas generales sin un paso futuro accionable
+
+### valid_until
+
+Para cada intención, proporciona `valid_until`: la fecha a partir de la cual la
+intención deja de importar (la fecha límite / fecha objetivo), resuelta
+respecto a **Memory Date** (p. ej. "el próximo martes" → esa fecha absoluta).
+Si no se puede determinar una fecha límite, pon `valid_until` en `null`.
+
+---
+
+# OWNER
+
+Cada memoria e intención DEBE llevar un `owner` que indique a qué almacén de memoria
+pertenece. Hay exactamente dos valores:
+
+* `"user"`: todo lo que pertenece al almacén de memoria propio del usuario. Incluye
+ hechos/preferencias/rasgos del propio usuario, Y hechos sobre otras personas reales
+ con nombre en la conversación, porque también son cosas que la memoria del
+ usuario debe guardar.
+* `"agent"`: información que aporta el asistente de IA (un `role: "assistant"` sin
+ nombre) (recomendaciones, confirmaciones, cosas que investigó), o una acción futura
+ que el usuario quiere que realice el **asistente** ("recuérdamelo dentro de 8 horas").
+
+Una persona con nombre NUNCA es `owner: "agent"`: es una persona real, no la IA,
+aunque sus mensajes lleven `role: "assistant"`. Sus memorias son
+`owner: "user"` con su nombre como sujeto del contenido.
+
+Decide el `owner` elemento por elemento. En caso de duda, usa `"user"` por defecto.
+
+---
+
+# REGLAS TEMPORALES
+
+Resuelve los tiempos relativos usando Memory Date.
+
+Ejemplos:
+
+* "la próxima semana"
+* "el mes pasado"
+* "mañana"
+
+Si el tiempo no puede resolverse con seguridad:
+
+* elimina la expresión relativa
+* deja la memoria sin referencia temporal
+
+No inventes cronología.
+
+**Los eventos recién ocurridos son eventos: consérvalos.** Cuando el usuario cuenta algo
+como recién terminado ("acabo de volver", "acabo de terminar", "esta mañana", "ayer"), la
+fecha de finalización es Memory Date. Emite **el evento en sí** con esa fecha; no lo
+diluyas en un enunciado de contexto general.
+
+* "Acabo de volver de un viaje con mi familia"
+ → "El usuario volvió de un viaje familiar el <Memory Date>."
+ NO → "El usuario hace viajes en familia." (la fecha de regreso es la respuesta a "¿cuándo
+ volvió?", y descartarla hace que la pregunta no tenga respuesta)
+
+Cuando un evento tiene un inicio y un fin que la conversación da por separado,
+registra ambos en lugar de reducirlos a un único intervalo.
+
+---
+
+# REGLAS DE CALIDAD
+
+Cada memoria debe ser:
+
+* autocontenida
+* completa en contexto
+* fácil de recuperar
+* densa en información
+
+Conserva los detalles importantes:
+
+* nombres
+* productos
+* lugares
+* números
+* ecuaciones
+* restricciones
+
+Nunca generalices algo específico convirtiéndolo en una categoría. Escribe lo que realmente se dijo.
+
+* "Banff" → conserva "Banff", NO "las Montañas Rocosas"
+* "una border collie de 3 años llamada Luna" → conserva la raza, la edad y el nombre
+
+**Los datos concretos aportados por el otro hablante también cuentan.** Un hecho suele
+construirse a lo largo de varios turnos: el otro hablante nombra la cosa y el usuario lo
+confirma. Las reglas de sujeto deciden *de quién* es la memoria; no autorizan a descartar
+detalles.
+
+* [Sam]: "¿Aprovechaste para esquiar en Banff?"
+ [user]: "¡Sí, fue genial para esquiar!"
+ → "El usuario fue a esquiar a Banff y la nieve le pareció increíble."
+ NO → "Al usuario le gustan los deportes de invierno." (tanto el lugar como la actividad
+ quedaron establecidos, uno por cada hablante)
+
+Evita memorias fragmentarias que carezcan de contexto.
+
+Elige el menor número de memorias que aún preserve las distintas necesidades de
+recuperación futuras.
+
+* Comprimir significa combinar, no omitir. Cada proposición duradera explícita
+ de los mensajes nuevos debe aparecer exactamente una vez en la salida.
+* Combina detalles cuando comparten el mismo sujeto y el mismo evento, estado,
+ preferencia, plan o decisión del mundo real. Un evento coherente puede ocupar 1–3 frases.
+* No emitas a la vez un enunciado amplio y reformulaciones más estrechas de la misma evidencia.
+* Separa solo cuando el sujeto es distinto, los eventos ocurrieron de forma independiente o las
+ memorias describen estados diferentes.
+* Mantén una causa, recomendación o consecuencia junto al hecho que explica cuando
+ separarlas haría perder la relación.
+* Nunca fusiones ocurrencias fechadas distintas solo porque comparten tema.
+* Conserva la precisión temporal de la fuente. No conviertas expresiones vagas como "el
+ fin de semana pasado" o "el verano pasado" en fechas exactas de calendario a menos que la
+ fecha sea explícita o esté determinada de forma única; "el fin de semana anterior a <Memory Date>" es aceptable.
+
+---
+
+# TAGS
+
+Cada memoria debe incluir 1–3 etiquetas (tags) concisas.
+- Las palabras clave temáticas van en minúsculas y en inglés (travel, health, work).
+- Los nombres propios conservan las mayúsculas (Jasper, Canada, Banff, Prius).
+
+Ejemplos:
+
+* work
+* travel
+* Jasper
+* Canada
+* health
+
+---
+"""
+
+STRUCTURE_METADATA_PROMPT = """
+
+---
+
+# ORGANIZACIÓN ESTRUCTURAL
+
+Para cada `memory`, genera también:
+
+* `topic_paths`: una lista retrocompatible de cero a tres rutas semánticas
+ de lo general a lo específico.
+* `event_facet`: un objeto con solo `subject`, `participants`, `action`,
+ `objects`, `locations` y `state`; state es `planned`, `ongoing`,
+ `completed` o `unknown`.
+* `topic_assignments`: de cero a seis pertenencias específicas de un sujeto. Cada elemento es
+ `{subject, role, path}`, donde `path` es una lista de segmentos `{name, type}` y
+ `type` es uno de `topic`, `facet`, `series` o `episode`. Usa `topic` para un
+ dominio amplio, `facet` para una actividad concreta/aspecto semántico, `series` solo
+ para ocurrencias repetidas de la misma línea concreta de actividad/estado, y
+ `episode` solo para una única ocurrencia acotada del mundo real. Un evento compartido puede tener
+ una asignación por cada participante explícito manteniendo una única memoria canónica.
+ Los tipos siguen `topic -> facet -> series -> episode`; se pueden saltar niveles, pero
+ los tipos no pueden repetirse ni retroceder.
+
+Este extractor solo ve la escritura actual y, por tanto, no debe emitir un
+segmento `series`. Emite aquí Topic/Facet/Episode. Reconcile puede establecer más tarde una
+Series tras comparar ocurrencias almacenadas independientes.
+
+Esta es una organización en el momento de escritura. No infieras Series/Episode a partir de la
+profundidad de la ruta, no fabriques jerarquía a partir de un nombre propio o una etiqueta amplia, ni asignes una persona solo
+porque coincide en un contexto no relacionado. Detente en el nivel más específico respaldado
+y usa valores vacíos cuando no estés seguro. Nunca codifiques formas de consulta como
+"cuándo", "cuántos", "quién", pluralidad o expresiones ordinales.
+"""
+
+EXTRACT_FEW_SHOT = """
+---
+
+# EJEMPLOS
+
+## Ejemplo 1 — Límite: el contexto antiguo solo sirve para resolver referencias, nunca se vuelve a extraer
+
+Últimos k mensajes:
+[{"role": "user", "content": "He estado mirando perros rescatados en el refugio del centro."},
+ {"role": "assistant", "content": "¡Qué bonito! ¿Encontraste alguno que te guste?"}]
+Mensajes nuevos:
+[{"role": "user", "content": "Sí, la recogí ayer: una border collie de 3 años llamada Luna."}]
+Memory Date: 2025-04-10
+
+Salida:
+```json
+{
+ "memory": [
+ {"content": "El usuario adoptó el 2025-04-09 una border collie de 3 años llamada Luna en un refugio del centro.", "tags": ["pets", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Los mensajes antiguos solo resuelven "la" y aportan contexto ("refugio del centro"). NO emitas una memoria obsoleta como "el usuario está pensando en adoptar un perro": solo se extrae el hecho genuinamente nuevo (la adopción completada), con "ayer" resuelto respecto a Memory Date.
+
+## Ejemplo 2 — Condensar una respuesta larga del asistente
+
+Mensajes nuevos:
+[{"role": "user", "content": "Escríbeme un ensayo breve sobre por qué el teletrabajo aumenta la productividad."},
+ {"role": "assistant", "content": "Claro. Inicio: 'El teletrabajo ha transformado la forma en que operan los equipos...' [~2000 palabras de cuerpo omitidas] ...cierre: 'En resumen, la autonomía y las menores interrupciones impulsan un mayor rendimiento.'"}]
+Memory Date: 2025-03-22
+
+Salida:
+```json
+{
+ "memory": [
+ {"content": "El asistente redactó para el usuario un ensayo breve que sostiene que el teletrabajo aumenta la productividad porque la autonomía y las menores interrupciones impulsan un mayor rendimiento.", "tags": ["writing", "remote-work"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+La respuesta del asistente es larga. Nunca guardes el ensayo literal: destílalo en tema + tesis. owner es "agent" porque lo produjo el asistente. El contenido literal inflado hace que la memoria sea inservible.
+
+## Ejemplo 3 — Extracción compuesta: basic_info + intención + plan del agente condensado
+
+Mensajes nuevos:
+[{"role": "user", "content": "Hola, soy Kenji. Estoy planeando un viaje a Japón el mes que viene. ¿Podrías prepararme un itinerario de 7 días?"},
+ {"role": "assistant", "content": "# Ruta Dorada clásica de Japón en 7 días (Tokio → Kioto → Nara → Osaka)\\nLlega en avión a Tokio, baja en Shinkansen a Kioto, excursión de un día a Nara y sal desde Osaka (Kansai).\\n\\n## Día 1: Llegada a Tokio\\n- Aterriza en Haneda/Narita, deja el equipaje en un hotel cerca de la estación de Tokio.\\n- Al final de la tarde: templo Sensoji (Asakusa), pasea por la calle Nakamise, prueba el taiyaki.\\n- Noche: cruce de Shibuya + mirador Shibuya Sky al atardecer; cena en un izakaya (yakitori, sake).\\n\\n## Día 2: Mercados y lugares emblemáticos de Tokio — [omitido]\\n## Día 3: Shinkansen a Kioto, Fushimi Inari, Gion — [omitido]\\n## Día 4: Templos de Kioto (Kiyomizu-dera, Kinkaku-ji, Ginkaku-ji) — [omitido]\\n## Día 5: Excursión a Nara (ciervos del parque de Nara, Todai-ji) — [omitido]\\n## Día 6: Osaka (castillo de Osaka, comida callejera en Dotonbori) — [omitido]\\n## Día 7: Visitas en Osaka + salida desde el aeropuerto de Kansai — [omitido]\\n\\nConsejo: compra un JR Pass de 7 días antes de llegar. ¿Quieres que ajuste algo?"}]
+Memory Date: 2025-09-15
+
+Salida:
+```json
+{
+ "memory": [
+ {"content": "El asistente creó para el usuario un itinerario de 7 días por Japón siguiendo la ruta dorada clásica: Tokio (Asakusa, Shibuya), Shinkansen a Kioto (Fushimi Inari, Kiyomizu-dera, Kinkaku-ji, Gion), excursión de un día a Nara (parque de los ciervos, Todai-ji) y luego Osaka (castillo de Osaka, Dotonbori), con salida desde el aeropuerto de Kansai.", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
+ ],
+ "intentions": [
+ {"content": "El usuario planea hacer un viaje de 7 días a Japón en octubre de 2025.", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
+ ],
+ "basic_info": {"name": "Kenji"}
+}
+```
+Un solo turno produce tres salidas en distintos apartados: el nombre va a basic_info, el viaje es una intención orientada al futuro con fecha límite, y el largo itinerario del asistente, con varias secciones, se condensa en UNA sola memoria densa del agente: la ruta y las paradas clave de cada ciudad, NO las viñetas de cada día, los consejos ni las listas de comida. Guardar la respuesta completa literalmente inflaría la memoria; guardar el esqueleto la mantiene consultable.
+
+## Ejemplo 4 — Un mensaje posterior que confirma/adopta una recomendación anterior es en sí un hecho
+
+Mensajes nuevos:
+[{"role": "user", "content": "Mi hijo de 6 años no quiere comer ninguna verdura. ¿Alguna idea?"},
+ {"role": "assistant", "content": "Prueba a triturar espinacas o zanahorias en la salsa de la pasta: el color y el sabor casi desaparecen, y muchos niños la aceptan sin darse cuenta."},
+ {"role": "user", "content": "¡Buena idea, lo probaremos esta noche! Por cierto, ¿a qué hora debería acostarse un niño de esa edad?"},
+ {"role": "assistant", "content": "Para un niño de 6 años, lo ideal es acostarse entre las 19:00 y las 21:00 y dormir unas 10–11 horas."}]
+Memory Date: 2025-06-20
+
+Salida:
+```json
+{
+ "memory": [
+ {"content": "El usuario tiene un hijo de 6 años que se niega a comer verduras, y aceptó la sugerencia del asistente de triturar espinacas o zanahorias en la salsa de la pasta para esconderlas.", "tags": ["parenting", "food"], "owner": "user"},
+ {"content": "El asistente aconsejó al usuario que un niño de 6 años debería acostarse entre las 19:00 y las 21:00 y dormir unas 10–11 horas.", "tags": ["parenting", "sleep"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+En el tercer mensaje el usuario dijo "lo probaremos esta noche", adoptando explícitamente la sugerencia anterior. Esa aceptación es valiosa y debe registrarse ("aceptó la sugerencia del asistente de ..."), no descartarse como charla trivial. El consejo sobre la hora de dormir acaba de darse y aún no se ha adoptado, así que se registra como consejo (owner "agent").
+
+## Ejemplo 5 — Contexto RAG/inyectado: nunca guardes el texto inyectado
+
+Mensajes nuevos:
+[{"role": "user", "content": "[Contexto recuperado: La Torre Eiffel mide 330 m de altura y se terminó en 1889.] Teniendo en cuenta lo anterior, voy a pedirle matrimonio a mi novia en lo alto de la Torre Eiffel este verano."}]
+Memory Date: 2025-05-02
+
+Salida:
+```json
+{
+ "memory": [],
+ "intentions": [
+ {"content": "El usuario planea pedirle matrimonio a su novia en lo alto de la Torre Eiffel en el verano de 2025.", "tags": ["relationship", "travel"], "valid_until": "2025-08-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+El contexto recuperado entre corchetes (la altura de la torre y el año) es material de referencia inyectado por RAG, NO algo que el usuario nos haya contado sobre sí mismo: NO lo guardes. Solo se extrae el plan del propio usuario orientado al futuro. El texto inyectado por el sistema/RAG es contexto para el modelo, nunca una memoria.
+
+## Ejemplo 6 — Material de referencia compartido: extrae el contenido, no la acción de compartir
+
+Mensajes nuevos:
+[{"role": "user", "content": "Recuerda la receta de empanadillas de mi abuela para que no la pierda. Relleno: 500 g de carne de cerdo picada, 300 g de col china, 2 cucharadas de salsa de soja, 1 cucharada de aceite de sésamo, un trozo de jengibre del tamaño de un pulgar picado. La col se sala 15 min y luego se escurre bien. Hierve las empanadillas, añade agua fría dos veces, están listas cuando flotan."},
+ {"role": "assistant", "content": "¡Entendido, guardada!"}]
+Memory Date: 2025-07-01
+
+Salida:
+```json
+{
+ "memory": [
+ {"content": "Receta de empanadillas de la abuela del usuario: relleno de 500 g de carne de cerdo picada, 300 g de col china (salada 15 minutos y luego bien escurrida), 2 cucharadas de salsa de soja, 1 cucharada de aceite de sésamo y un trozo de jengibre picado del tamaño de un pulgar; se hierven las empanadillas, se añade agua fría dos veces y están listas cuando flotan.", "tags": ["food", "recipe", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Extrae el contenido factual real (ingredientes, cantidades, el paso de salar y escurrir, el método de cocción), NO "el usuario compartió una receta" ni "el usuario pidió recordar la receta". La acción de compartir no vale nada; el contenido es lo consultable.
+
+## Ejemplo 7 — Números y atributos estructurados conservados con exactitud
+
+Mensajes nuevos:
+[{"role": "user", "content": "Apunto mis récords del gimnasio de casa de este ciclo: Sentadilla 140kg x 3, Press de banca 100kg x 5, Peso muerto 180kg x 2, Press militar 60kg x 6. Peso corporal 78kg, 3 series por ejercicio, 3 min de descanso."},
+ {"role": "assistant", "content": "Apuntado. ¡Muy buenas marcas!"}]
+Memory Date: 2026-01-20
+
+Salida:
+```json
+{
+ "memory": [
+ {"content": "Los récords actuales de levantamiento del usuario son Sentadilla 140kg x 3, Press de banca 100kg x 5, Peso muerto 180kg x 2 y Press militar 60kg x 6, con un peso corporal de 78kg.", "tags": ["fitness", "strength"], "owner": "user"},
+ {"content": "El usuario entrena con 3 series por ejercicio y 3 minutos de descanso entre series.", "tags": ["fitness", "training"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Cada número y unidad (kg, repeticiones, series, tiempo de descanso) se conserva con exactitud: descartarlos destruiría la información más consultable. Se divide en dos temas limpios (récords frente a protocolo de entrenamiento), pero nunca se redondean ni se omiten los datos concretos.
+
+## Ejemplo 8 — Conversación larga con varios temas: no te detengas tras el primer tema
+
+Mensajes nuevos:
+[{"role": "user", "content": "¡Semana intensa: por fin defendí mi tesis doctoral el martes!"},
+ {"role": "assistant", "content": "¡Enhorabuena! ¿Cómo te sientes?"},
+ {"role": "user", "content": "¡Aliviado! También firmé el contrato de alquiler de un apartamento en Berlín y me mudo el mes que viene. Y he empezado a aprender alemán en Duolingo: racha de 30 días. Mi pareja, Sofía, se queda en Madrid por ahora, y eso es duro."}]
+Memory Date: 2025-11-08
+
+Salida:
+```json
+{
+ "memory": [
+ {"content": "El usuario defendió su tesis doctoral el 2025-11-04.", "tags": ["education", "milestone"], "owner": "user"},
+ {"content": "El usuario firmó el contrato de alquiler de un apartamento en Berlín.", "tags": ["housing"], "owner": "user"},
+ {"content": "El usuario está aprendiendo alemán en Duolingo y lleva una racha de 30 días.", "tags": ["language", "learning"], "owner": "user"},
+ {"content": "La pareja del usuario, Sofía, se queda en Madrid por ahora, algo que al usuario le resulta duro.", "tags": ["relationship"], "owner": "user"}
+ ],
+ "intentions": [
+ {"content": "El usuario planea mudarse a Berlín el mes que viene (hacia diciembre de 2025).", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+Cuatro o más temas: la defensa de la tesis, el apartamento en Berlín, el aprendizaje de alemán y la pareja en Madrid. No te detengas tras el primer tema. Observa que un mismo turno se divide en un hecho completado (contrato firmado) Y una intención (la mudanza próxima), y que el detalle emocional pero sustantivo sobre Sofía se conserva porque aporta contexto duradero sobre la relación.
+
+## Ejemplo 9 — Dos personas reales: `name` en un mensaje del asistente significa una persona real
+
+Mensajes nuevos:
+[{"role": "user", "name": "Tim", "content": "Acabo de volver del rocódromo, tercera vez esta semana. Por fin encadené esa vía con desplome."},
+ {"role": "assistant", "name": "John", "content": "¡Genial! Yo estoy nadando en su lugar: el hombro todavía me duele desde el mes pasado."}]
+Memory Date: 2025-08-14
+
+Salida:
+```json
+{
+ "memory": [
+ {"content": "El usuario escala tres veces por semana y hace poco completó una vía difícil con desplome.", "tags": ["fitness", "climbing"], "owner": "user"},
+ {"content": "John está nadando en lugar de hacer otros ejercicios porque el hombro todavía le dolía tras una lesión hacia julio de 2025.", "tags": ["fitness", "health"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {"name": "Tim"}
+}
+```
+John lleva `role: "assistant"`, pero tiene un `name`, así que es otra persona real, NO la IA: su memoria usa "John ..." como sujeto y sigue siendo `owner: "user"` (pertenece al almacén de memoria del usuario). La memoria propia del usuario sigue siendo "El usuario ..." aunque sepamos que se llama Tim; nunca "Tim escala". `basic_info.name` sale de `name: "Tim"` en el mensaje del usuario, que es una fuente autorizada aunque Tim nunca dijera su nombre en voz alta.
+
+## Ejemplo 10 — Contraejemplo: los atributos de otra persona nunca van en basic_info
+
+Mensajes nuevos:
+[{"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
+
+Salida:
+```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"}
+}
+```
+La profesión y la ubicación de John son atributos SUYOS, así que van en `memory` con "John" como sujeto. NUNCA deben acabar en `basic_info.occupation` / `basic_info.location`: `basic_info` es exclusivamente el perfil propio del usuario. Solo `name` (Tim, del campo `name` del mensaje del usuario) va ahí. Observa que el idioma de salida sigue al de la entrada (este ejemplo está en inglés).
+
+## Ejemplo 11 — Contraejemplo: la charla trivial no tiene basic_info
+
+Mensajes nuevos:
+[{"role": "user", "content": "Hola"},
+ {"role": "assistant", "content": "¡Hola! El usuario se llama El usuario. ¿En qué puedo ayudarte?"}]
+Memory Date: 2025-09-03
+
+Salida:
+```json
+{
+ "memory": [],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+El usuario no dijo nada sobre sí mismo. La frase del asistente no es un turno del usuario, y "El usuario" es un marcador de posición, no un nombre. Devuelve `{}`; nunca `{"name": "El usuario"}` ni `{"name": "usuario"}`.
+
+---
+"""
+
+EXTRACT_PROMPT = """## Últimos k mensajes
+
+{last_messages}
+
+---
+
+## Mensajes nuevos
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Formato de salida
+
+Devuelve SOLO un objeto JSON dentro de un bloque delimitado ```json.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "intentions": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "valid_until": "YYYY-MM-DD",
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Reglas:
+
+* `memory` = información duradera digna de recordar: preferencias, opiniones, actitudes,
+ rasgos, eventos, planes, experiencias, hábitos, decisiones, sobre el usuario o
+ sobre cualquier otra persona real con nombre, con el sujeto escrito según "# SUJETO"
+* `intentions` = cosas orientadas al futuro que el usuario (u otra persona con nombre) planea /
+ tiene intención de hacer, con `valid_until` = la fecha límite/fecha objetivo
+ (resuelta respecto a Memory Date) o `null` si no la hay
+* `owner` (obligatorio en cada memoria e intención) = `"user"` o `"agent"`
+ (ver "# OWNER" más arriba; `"user"` por defecto en caso de duda)
+* `basic_info` = **solo el perfil propio del usuario**. Incluye campos de perfil
+ estables (p. ej. nombre, edad, ubicación, profesión, empleador) **declarados explícitamente**
+ en los mensajes NUEVOS del usuario. Nunca infieras, nunca inventes. Si ningún campo se
+ declara explícitamente, devuelve `{{}}`.
+ * REGLA ESTRICTA: rellena un campo SOLO si el usuario lo declaró en un turno `user`.
+ Lo que solo dijo el asistente (incluido el asistente citando una memoria
+ anterior como "El usuario se llama X") NO cuenta. Si nada
+ cumple el requisito, devuelve `"basic_info": {{}}`.
+ * NUNCA escribas como valor el propio nombre del campo ni un marcador de posición ("user",
+ "The user", "el usuario", "用户", "name", "N/A", "unknown", "none", "-"). Omite el campo.
+ * Ejemplo negativo: charla trivial como `[user]: Hola` / `[assistant]: ¿En qué
+ puedo ayudarte?`, o `[user]: Responde exactamente: PONG` → `"basic_info": {{}}`.
+ * Excepción para `name`: el campo `name` del propio mensaje del usuario, o una línea
+ inicial "El usuario se llama X" / "The user's name is X" / "用户名叫X", es una fuente autorizada para
+ `name`, aunque el usuario nunca lo haya dicho en voz alta.
+ * NUNCA pongas aquí los atributos de otra persona real. Si John (un mensaje con rol de
+ asistente que lleva `name`) dice "Soy enfermero en Berlín", eso es una `memory`
+ ("John es enfermero en Berlín."), NO `basic_info.occupation` / `.location`.
+* Sin información duplicada entre secciones
+* Las etiquetas deben contener 1–3 palabras clave concisas en minúsculas
+* Usa arrays vacíos `[]` o `{{}}` cuando no se extraiga nada
+* Devuelve solo JSON válido
+
+Genera el JSON ahora."""
+
+EXTRACT_PROMPT_NO_INTENTION = """## Últimos k mensajes
+
+{last_messages}
+
+---
+
+## Mensajes nuevos
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Formato de salida
+
+Devuelve SOLO un objeto JSON dentro de un bloque delimitado ```json.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Reglas:
+
+* `memory` = información duradera digna de recordar: preferencias, opiniones, actitudes,
+ rasgos, eventos, experiencias, hábitos, decisiones, **y planes futuros / acciones
+ próximas**, sobre el usuario o sobre cualquier otra persona real con nombre, con el
+ sujeto escrito según "# SUJETO". **No** inventes un apartado de intentions separado.
+* `owner` (obligatorio en cada memoria) = `"user"` o `"agent"`
+ (ver "# OWNER" más arriba; `"user"` por defecto en caso de duda)
+* `basic_info` = **solo el perfil propio del usuario**. Incluye campos de perfil
+ estables (p. ej. nombre, edad, ubicación, profesión, empleador) **declarados explícitamente**
+ en los mensajes NUEVOS del usuario. Nunca infieras, nunca inventes. Si ningún campo se
+ declara explícitamente, devuelve `{{}}`.
+ * REGLA ESTRICTA: rellena un campo SOLO si el usuario lo declaró en un turno `user`.
+ Lo que solo dijo el asistente (incluido el asistente citando una memoria
+ anterior como "El usuario se llama X") NO cuenta. Si nada
+ cumple el requisito, devuelve `"basic_info": {{}}`.
+ * NUNCA escribas como valor el propio nombre del campo ni un marcador de posición ("user",
+ "The user", "el usuario", "用户", "name", "N/A", "unknown", "none", "-"). Omite el campo.
+ * Ejemplo negativo: charla trivial como `[user]: Hola` / `[assistant]: ¿En qué
+ puedo ayudarte?`, o `[user]: Responde exactamente: PONG` → `"basic_info": {{}}`.
+ * Excepción para `name`: el campo `name` del propio mensaje del usuario, o una línea
+ inicial "El usuario se llama X" / "The user's name is X" / "用户名叫X", es una fuente autorizada para
+ `name`, aunque el usuario nunca lo haya dicho en voz alta.
+ * NUNCA pongas aquí los atributos de otra persona real. Si John (un mensaje con rol de
+ asistente que lleva `name`) dice "Soy enfermero en Berlín", eso es una `memory`
+ ("John es enfermero en Berlín."), NO `basic_info.occupation` / `.location`.
+* Sin información duplicada entre secciones
+* Etiquetas: 1–3 palabras clave concisas; etiquetas temáticas en minúsculas; los nombres propios conservan las mayúsculas
+* Usa arrays vacíos `[]` o `{{}}` cuando no se extraiga nada
+* Devuelve solo JSON válido; **nunca** incluyas una clave `intentions`
+
+Genera el JSON ahora."""
+
+
+# ================================================================
+# Chat reconcile (agent/reconciler.py)
+# ================================================================
+
+SEARCH_QUERY_PROMPT = """Eres un generador de consultas de búsqueda. Dada una lista de memorias recién extraídas, genera un conjunto de consultas de búsqueda cortas que sirvan para encontrar memorias existentes relacionadas en una base de datos vectorial.
+
+El objetivo es maximizar el recall: encontrar memorias existentes semánticamente relacionadas con las nuevas, aunque la redacción sea muy distinta.
+
+## Memorias nuevas:
+{new_memories}
+
+## Instrucciones
+
+Genera consultas de búsqueda que cubran:
+- Los temas, entidades y asuntos clave mencionados en las memorias
+- Versiones reformuladas o abstraídas de los conceptos centrales
+- Conceptos relacionados que podrían existir en el almacén de memoria del usuario
+
+Devuelve un array JSON de cadenas de consulta (5-15 consultas, cortas y enfocadas):
+
+["query1", "query2", "query3", ...]
+
+Devuelve solo el array JSON, sin ningún otro texto."""
+
+RECONCILE_PROMPT = """Eres un sistema de gestión de memoria.
+
+Tu tarea es integrar memorias nuevas en una base de memoria existente manteniéndola:
+
+* sin pérdidas
+* sin contradicciones
+* compacta
+* altamente recuperable
+
+---
+
+# Operaciones
+
+## ADD
+
+Úsala cuando la información sea completamente nueva.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## UPDATE
+
+Úsala cuando:
+
+* la memoria nueva es compatible con una existente
+* ambas describen el mismo tema
+* fusionarlas mejora la completitud o la recuperabilidad
+
+Reglas:
+
+* fusiona sin pérdidas
+* conserva toda la información útil
+* NO crees duplicados
+* si las dos discrepan en un valor, conserva el valor de la memoria con el `memory_at`
+ más tardío; nunca dejes que una memoria más antigua sobrescriba un valor más reciente
+
+### Misma ocurrencia frente a otra ocurrencia
+
+Usa **UPDATE** solo cuando la memoria nueva añade detalle a la misma ocurrencia
+del mundo real o al mismo hecho duradero ya registrado.
+
+Si la misma persona realiza otra vez el mismo tipo de actividad/evento en otro momento
+(otro viaje, partido, lesión, compra, susto de salud, etc.), mantén la ocurrencia
+como un **ADD** separado. Conserva su propia fecha y sus detalles. Cuando una memoria existente
+sea claramente otra ocurrencia de esa misma serie concreta, enlázala con
+`related: [{{"memory_id":"...","relation":"same_series"}}]`.
+
+No fusiones ocurrencias fechadas distintas en una única memoria larga de recuento/cronología.
+La capa de recuperación construye las cronologías a partir de las memorias L2 enlazadas.
+
+```json
+{{
+ "op": "UPDATE",
+ "memory_id": "...",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## SUPERSEDE
+
+Úsala SOLO cuando:
+
+* la memoria nueva contradice una memoria existente
+* ambas no pueden ser ciertas al mismo tiempo
+* la memoria antigua daría ahora una respuesta errónea sobre el estado actual
+* el `memory_at` de la memoria nueva es igual o POSTERIOR al `memory_at` de la memoria existente
+
+Ejemplos:
+
+* cambió de ciudad
+* cambió de empleador
+* cambió su situación sentimental
+
+NO la uses para:
+
+* detalle añadido
+* preferencias compatibles
+* diferencias de redacción
+* equivalencia semántica
+* una memoria nueva cuyo `memory_at` sea ANTERIOR al de la memoria existente: es un
+ estado más antiguo y nunca debe reemplazar uno más reciente (ver "Orden temporal")
+
+Reglas:
+
+* content debe contener SOLO el nuevo estado
+* NO copies la información que no ha cambiado
+* el sistema conserva el nodo antiguo y lo enlaza automáticamente en la cadena de evolución; no necesitas gestionar el historial
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_id": "...",
+ "content": "...",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+### Plegar varias memorias existentes en una sola cadena
+
+Si DOS O MÁS memorias existentes siguen la MISMA dimensión y la memoria nueva es
+el último cambio en esa dimensión (su `memory_at` es posterior al `memory_at` de todas las
+memorias plegadas), puedes plegarlas en una única cadena de
+evolución. Usa `memory_ids` (una lista ordenada, de la MÁS ANTIGUA → a la MÁS RECIENTE) en lugar de un único
+`memory_id`:
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_ids": ["<oldest_id>", "<newer_id>"],
+ "content": "<solo el estado más reciente>",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+Las memorias listadas se encadenan de la más antigua → a la más reciente y la memoria nueva pasa a ser la
+cabeza de la cadena. `content` sigue describiendo SOLO el estado más reciente: nunca copies en él el texto de las
+memorias anteriores; siguen siendo consultables en el historial de la cadena.
+
+---
+
+# Reglas
+
+* Conserva toda la información significativa.
+* Omite los duplicados exactos.
+* Prefiere fusionar fragmentos relacionados.
+* Las ocurrencias fechadas distintas se mantienen como ADD separados; usa `same_series` solo para el
+ mismo sujeto y el mismo tipo concreto de actividad/evento.
+* Mantén cada memoria centrada en un único tema coherente.
+* Sigue el "Orden temporal" que aparece más abajo.
+* **NUNCA fusiones ni sustituyas entre sujetos distintos.** El sujeto es aquel de quien
+ trata el contenido: "El usuario ..." frente a "John ..." frente a "Mary ...". Las memorias sobre
+ personas distintas son hechos independientes aunque la frase sea por lo demás
+ idéntica: "Al usuario le gusta el café" y "A John le gusta el café" son dos memorias
+ separadas, nunca un UPDATE ni un SUPERSEDE la una de la otra.
+* `owner` (`user`/`agent`): cópialo de la memoria que se está escribiendo. NUNCA fusiones ni sustituyas entre owners distintos: un hecho del usuario y un hecho del asistente son distintos aunque traten el mismo tema.
+* Un SUPERSEDE o bien apunta a UNA memoria (`memory_id`) o bien pliega varias memorias de la misma dimensión en una cadena (`memory_ids`, de la más antigua a la más reciente). Un UPDATE apunta exactamente a UNA memoria.
+* Nunca toques la misma memoria existente desde más de una operación.
+* El idioma de salida coincide con el idioma de las memorias de entrada.
+
+---
+
+# Orden temporal
+
+Toda memoria, nueva o existente, tiene `memory_at`: cuándo ocurrió. Las memorias
+NO siempre se escriben en el orden en que ocurrieron: el historial puede importarse tarde,
+y una memoria puede añadirse mientras todavía se procesa historial más antiguo. Por tanto, una
+memoria nueva puede ser MÁS ANTIGUA que una existente.
+
+* Decide qué memoria es más reciente SOLO por `memory_at`. "Memorias nuevas" significa "que se
+ están escribiendo ahora", no "más recientes".
+* Una memoria más antigua nunca debe reemplazar a una más reciente: nada de SUPERSEDE de una
+ memoria más reciente, ni de UPDATE que sobrescriba un valor más reciente con uno más antiguo.
+* Si una memoria nueva es más antigua que una memoria existente con la que entra en conflicto, conserva la
+ memoria existente como estado actual. Haz ADD de la nueva como estado pasado, redactada
+ en pasado con su fecha (por ejemplo "En 2023 el usuario vivía en Shanghái"),
+ o no devuelvas nada si no aporta información.
+* `memory_at: null` significa tiempo desconocido. Desconocido NO es más reciente: nunca hagas SUPERSEDE de una
+ memoria que tiene un `memory_at` conocido con otra cuyo `memory_at` sea null.
+* No inventes cronología.
+
+---
+
+# Opcional: `related`
+
+En cualquier operación PUEDES añadir un array `related` que registre cómo se relaciona la memoria que se está escribiendo
+con una memoria EXISTENTE. Esto no cambia lo que se almacena: solo
+registra un enlace.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."],
+ "related": [{{"memory_id": "<existing_id>", "relation": "causes"}}]
+}}
+```
+
+Solo se permiten estas cuatro relaciones:
+
+* `causes`: las dos memorias están en una relación de causa/efecto
+ (p. ej. "empezó a correr a diario" → "empezó a dolerle la rodilla")
+* `elaborates`: añade detalle a la memoria existente, o es un desarrollo posterior de ella
+* `contrasts`: están en tensión pero AMBAS siguen siendo ciertas (si una hace falsa a la
+ otra, eso es un SUPERSEDE, no un enlace `contrasts`)
+* `same_series`: ocurrencias fechadas distintas del mismo tipo concreto de actividad o
+ evento para el mismo sujeto (por ejemplo, dos viajes de esquí diferentes)
+
+Reglas:
+
+* Enlaza solo con memorias que aparezcan en "Memorias existentes": nunca inventes un id.
+* Emite un enlace solo cuando la relación sea **explícita y específica**. Que dos memorias
+ traten simplemente del mismo tema amplio NO es una relación: omite `related`.
+* `same_series` requiere el mismo sujeto y una acción/evento concreto repetido;
+ compartir etiquetas amplias como health, travel, sport, food o work no basta.
+* Omite el campo por completo cuando no haya nada que enlazar. Cero enlaces es el caso normal.
+* Nunca uses `related` como sustituto de UPDATE / SUPERSEDE.
+
+---
+{few_shot_section}
+###################
+Datos de entrada
+###################
+
+Fecha actual: {current_date}
+
+## Memorias existentes
+
+{existing_memories}
+
+## Memorias nuevas
+
+{new_memories}
+
+---
+
+# Salida
+
+Devuelve SOLO un array JSON dentro de un bloque de código delimitado ```json.
+
+Si no se necesita ningún cambio:
+
+```json
+[]
+```
+
+Genera ahora el array JSON."""
+
+RECONCILE_STRUCTURE_METADATA_PROMPT = """
+
+Contrato adicional de salida estructural:
+
+Para cada resultado ADD, UPDATE o SUPERSEDE, conserva o refina `topic_paths`,
+`event_facet` y `topic_assignments`. `event_facet` contiene solo `subject`,
+`participants`, `action`, `objects`, `locations` y `state`.
+`topic_assignments` contiene entradas `{subject, role, path}` específicas de un sujeto;
+cada segmento de la ruta es `{name, type}` y type es `topic|facet|series|episode`.
+Los tipos siguen `topic -> facet -> series -> episode`; se pueden saltar niveles, pero
+los tipos no pueden repetirse ni retroceder.
+Usa Series solo para ocurrencias repetidas de una línea concreta de actividad/estado y
+Episode solo para una única ocurrencia acotada del mundo real. Nunca infieras estos tipos a partir de
+la profundidad, de una etiqueta amplia compartida o de una coincidencia no relacionada. Cuando una memoria existente
+ya tenga una ruta específica del sujeto semánticamente equivalente, reutiliza exactamente sus nombres de nodo
+y sus tipos en lugar de crear una bifurcación sinónima. Para solicitar una reutilización exacta, emite
+`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
+"through":"topic|facet|series|episode"}]`. El ID referenciado debe aparecer en
+las Memorias existentes. `through` significa copiar ese prefijo de ruta existente hasta el
+tipo estructural indicado; un sufijo más profundo redactado explícitamente sigue siendo nuevo. La reutilización
+está prohibida cuando difieren el sujeto, la línea concreta de actividad/estado o el límite del Episode.
+Estos campos describen la memoria, nunca una forma de consulta futura como
+"cuándo", "cuántos" o "quién".
+
+Series es una relación del momento de reconciliación: establécela solo cuando la memoria nueva y
+al menos una memoria existente independiente sean ocurrencias distintas de la misma
+línea concreta de actividad/estado. Varias proposiciones de la escritura actual no
+demuestran repetición.
+"""
+
+RECONCILE_FEW_SHOT = """
+###################
+Ejemplos
+###################
+
+## Ejemplo 1 — Una memoria nueva: una parte entra en conflicto con una cadena existente y otra no está relacionada
+
+Memorias existentes:
+[
+ {"memory_id": "m1", "content": "El usuario trabaja como product manager en Stripe.", "owner": "user", "history_versions": [{"content": "El usuario trabaja como product manager en una startup fintech."}]}
+]
+Memorias nuevas:
+[
+ {"content": "El usuario ha dejado Stripe y ahora es product lead en Notion, y hace poco ha empezado a hacer cerámica los fines de semana.", "owner": "user"}
+]
+
+Salida:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "m1", "content": "El usuario trabaja como product lead en Notion.", "supersede_reason": "el empleador cambió de Stripe a Notion", "owner": "user", "tags": ["work"]},
+ {"op": "ADD", "content": "El usuario ha empezado hace poco a hacer cerámica los fines de semana.", "owner": "user", "tags": ["hobby"]}
+]
+```
+UNA SOLA memoria nueva contiene dos cosas: el cambio de trabajo (misma dimensión que la cadena de empleo existente m1, que ya tiene historial → SUPERSEDE, pasa a ser la nueva cabeza de la cadena) y un detalle no relacionado (cerámica → ADD). Divide esa memoria en la operación adecuada para cada parte: la nueva cabeza describe SOLO la situación laboral, nunca la cerámica.
+
+## Ejemplo 2 — Plegar dos memorias existentes no enlazadas + el nuevo cambio en una cadena de 3 nodos
+
+Memorias existentes:
+[
+ {"memory_id": "a1", "content": "El usuario está aprendiendo a tocar la guitarra.", "owner": "user", "memory_at": "2024-02-10 09:00"},
+ {"memory_id": "a2", "content": "El usuario ya sabe tocar algunas canciones completas a la guitarra.", "owner": "user", "memory_at": "2024-09-05 09:00"}
+]
+Memorias nuevas:
+[
+ {"content": "El usuario ahora toca la guitarra en noches de micrófono abierto locales.", "owner": "user"}
+]
+
+Salida:
+```json
+[
+ {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "El usuario toca la guitarra en noches de micrófono abierto locales.", "supersede_reason": "progreso con la guitarra: aprendiendo → tocando canciones → actuando en directo", "owner": "user", "tags": ["music", "hobby"]}
+]
+```
+a1 y a2 nunca se enlazaron, pero siguen la misma dimensión (progreso con la guitarra) y la memoria nueva es el último paso. Pliégalas con `memory_ids` ordenados de la más antigua a la más reciente; forman una cadena de 3 nodos (a1 ← a2 ← nueva cabeza). El `content` de la cabeza describe SOLO el estado actual: no repite "aprendiendo" ni "algunas canciones".
+
+## Ejemplo 3 — La nueva cabeza NO debe copiar el contenido de la memoria antigua
+
+Memorias existentes:
+[
+ {"memory_id": "c1", "content": "El usuario vive de alquiler en un apartamento de un dormitorio en Shibuya, Tokio, paga ¥180,000/mes, le encanta estar a 5 minutos a pie de la estación, pero se queja de que el piso es ruidoso por la noche y no tiene aparcamiento.", "owner": "user"}
+]
+Memorias nuevas:
+[
+ {"content": "El usuario acaba de comprar una casa de tres dormitorios en las afueras de Yokohama, con jardín y garaje para dos coches, y se ha mudado a ella.", "owner": "user"}
+]
+
+Salida:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "c1", "content": "El usuario compró una casa de tres dormitorios en las afueras de Yokohama, con jardín y garaje para dos coches, y se mudó a ella.", "supersede_reason": "la vivienda cambió de un apartamento de alquiler en Shibuya a una casa en propiedad en Yokohama", "owner": "user", "tags": ["housing"]}
+]
+```
+La memoria nueva hace SUPERSEDE de c1 y pasa a ser la cabeza de la cadena. El `content` de la cabeza describe SOLO la nueva casa de Yokohama. NO arrastres al nuevo nodo los detalles distintivos del apartamento antiguo (Shibuya, el alquiler de ¥180,000, el paseo a la estación, las quejas por ruido/aparcamiento): pertenecen claramente a la vivienda antigua, no a la nueva. Se quedan en el historial de la cadena y siguen siendo recuperables; copiarlos haría que la cabeza se contradijera a sí misma (alquilar en Shibuya Y ser propietario en Yokohama a la vez).
+
+## Ejemplo 4 — Los sujetos distintos nunca se fusionan, por parecida que sea la redacción
+
+Memorias existentes:
+[
+ {"memory_id": "d1", "content": "El usuario toma café solo todas las mañanas.", "owner": "user"}
+]
+Memorias nuevas:
+[
+ {"content": "John toma café solo todas las mañanas.", "owner": "user"},
+ {"content": "El usuario ahora toma café solo dos veces al día, por la mañana y después de comer.", "owner": "user"}
+]
+
+Salida:
+```json
+[
+ {"op": "ADD", "content": "John toma café solo todas las mañanas.", "owner": "user", "tags": ["food"]},
+ {"op": "UPDATE", "memory_id": "d1", "content": "El usuario toma café solo dos veces al día, por la mañana y después de comer.", "owner": "user", "tags": ["food"]}
+]
+```
+Las dos memorias nuevas tienen una redacción casi idéntica pero sujetos DISTINTOS. "John ..." trata de otra persona, así que es un ADD simple: nunca un UPDATE ni un SUPERSEDE de d1, aunque d1 diga casi lo mismo sobre el usuario. Solo la memoria cuyo sujeto también es "El usuario" puede fusionarse con d1.
+
+## Ejemplo 5 — Evento recurrente: actualizar el recuento y mantener una cronología (UPDATE, no ADD)
+
+Memorias existentes:
+[
+ {"memory_id": "i1", "content": "John se lesionó el tobillo la temporada pasada y necesitó reposo y fisioterapia.", "owner": "user", "memory_at": "2023-05-21 19:48"}
+]
+Memorias nuevas:
+[
+ {"content": "John volvió a torcerse el tobillo en un partido reciente.", "owner": "user", "memory_at": "2023-10-13 13:50"}
+]
+
+Salida:
+```json
+[
+ {"op": "UPDATE", "memory_id": "i1", "content": "John se ha lesionado el tobillo dos veces: la primera la temporada pasada (hacia la temporada 2022–2023), con necesidad de reposo y fisioterapia; la segunda durante un partido hacia el 2023-10-13.", "owner": "user", "tags": ["health", "basketball", "injury"]}
+]
+```
+El mismo tipo de evento vuelve a ocurrir → UPDATE de la memoria antigua. Indica el **recuento** y enumera las ocurrencias con sus fechas cuando se conozcan. NO hagas ADD de un segundo hecho "John se lesionó el tobillo", y NO hagas SUPERSEDE (la primera lesión no dejó de ser cierta).
+"""
+
+
+# ================================================================
+# Working / coding memory (coding/)
+# ================================================================
+
+CODING_EXTRACT_PROMPT = """\
+Extraes memorias de TRABAJO (working memories) duraderas de un segmento de sesión de ejecución de tareas.
+Una sesión de "trabajo" es cualquier tarea práctica en la que el usuario maneja un ordenador /
+sistema mediante herramientas; abarca TANTO el trabajo de software/código (escribir, depurar,
+refactorizar, compilar, desplegar, uso de APIs/bibliotecas) COMO el trabajo de sistemas y operaciones
+(ejecutar comandos de shell/PowerShell, análisis o limpieza de disco/almacenamiento, operaciones con
+archivos y carpetas, instalar/configurar software, preparar el entorno/dispositivo,
+inspeccionar la salud del hardware/disco, copias de seguridad, programación/automatización, procesamiento de datos).
+
+Produces DOS capas a partir del MISMO segmento:
+
+ EXPERIENCES (procedimental, "cómo hacerlo"): método reutilizable, extraído solo
+ cuando supera el UMBRAL DE VALOR de abajo. Un paquete (task, search_keys, solution,
+ boundary_envs).
+
+ FACT (episódico, "qué pasó esta vez"): EXACTAMENTE UN registro de ESTA
+ sesión: qué quería el usuario, cómo se abordó y cómo terminó. Sin
+ umbral de valor, pero nunca hay más de uno.
+
+Las dos capas responden a preguntas distintas y se almacenan por separado. Un método
+que se generaliza va en EXPERIENCES; la historia de esta sesión concreta,
+válida solo para este sistema / este proyecto / ahora mismo, va en el FACT.
+
+═══════════════════════════════════════════════════════════════════
+UMBRAL DE VALOR (SOLO EXPERIENCES): NO lo cruces a la ligera.
+═══════════════════════════════════════════════════════════════════
+Una memoria DEBE cumplir TODO lo siguiente:
+ (a) Resuelve un problema que probablemente se repita para el mismo usuario
+ (b) La solución no es trivial: combina varias piezas de información / pasos, O
+ incluye la justificación de una decisión, O recoge una solución alternativa difícil de conseguir, O es un
+ procedimiento/receta reutilizable para una tarea operativa (p. ej. cómo analizar y
+ limpiar el uso de disco, cómo organizar archivos por lotes, cómo inspeccionar la salud
+ del hardware, cómo configurar una tarea programada)
+ (c) Un futuro agente / usuario preferiría consultarla antes que volver a descubrirla
+
+IMPORTANTE: las tareas de análisis / diagnóstico / investigación CUENTAN:
+Una tarea NO tiene que hacer un cambio ni "arreglar" algo para merecer ser recordada.
+El trabajo de solo lectura / analítico / de resolución de problemas es valioso cuando su PROCEDIMIENTO o su
+CONCLUSIÓN son reutilizables. Extrae explícitamente:
+ - Recetas de análisis / diagnóstico: el procedimiento reutilizable + lo que reveló
+ (p. ej. "cómo analizar qué carpetas ocupan el espacio de la unidad C:": los comandos de escaneo,
+ los problemas encontrados y el hallazgo). "Solo produjo un informe, sin cambios"
+ NO es motivo para omitirla: el MÉTODO reutilizable es la memoria.
+ - Resultados de investigación, INCLUIDOS los negativos / de no encontrado
+ (p. ej. "se buscó la carpeta X en C: y D: con rg / fs_search / índice SQL;
+ no se encontró en ningún sitio"). Un callejón sin salida registrado evita que el próximo agente repita
+ la misma búsqueda infructuosa, así que supera el umbral.
+NO rechaces una memoria solo porque "el asistente podría regenerar los
+comandos" o porque "en realidad no se modificó nada". Si el procedimiento o la conclusión
+ahorrarían esfuerzo en el futuro, consérvala.
+
+NO extraigas:
+ - Operaciones de un solo paso realmente triviales sin procedimiento reutilizable ("renombrar un archivo",
+ "git status", "ejecutar ls una vez")
+ - Problemas puntuales ya resueltos sin lección transferible
+ - Información que ya está en el repositorio/sistema (no dupliques package.json)
+ - Tareas desechables por PR / por sesión, salvo que codifiquen un patrón reutilizable
+ - El acto de PEDIRLE AL USUARIO información que falta. Solicitar un parámetro,
+ enumerar lo que se desconoce o recabar campos obligatorios es comportamiento
+ conversacional, no un método: todo agente ya sabe hacer una pregunta, así que
+ no hay nada que consultar después. Nunca emitas una experiencia cuyo task o
+ search_keys tengan la forma "cómo pedir X", "recabar el Y que falta",
+ "obtener los campos obligatorios", "qué aclarar antes de empezar". Ten en cuenta que esto
+ queda fuera solo de EXPERIENCES: que la sesión terminara esperando al usuario
+ es un estado real y pertenece al FACT.
+
+Si el segmento no hizo ningún avance sustancial porque se quedó esperando al
+usuario (el asistente solo pidió parámetros, o quedó bloqueado antes de hacer ningún
+trabajo real), emite "experiences": [] y escribe solo el FACT. Todavía no se ha
+aprendido nada, así que no hay ningún método que guardar. Esto importa más de lo que parece:
+una experiencia destilada de un bloqueo parece una habilidad legítima al recuperarse,
+y un segmento posterior de la misma tarea coincidirá con ella y volverá a preguntar al usuario
+en lugar de avanzar, de modo que el bloqueo se reproduce durante el resto de la
+sesión. Juzga la sustancia por lo que realmente hicieron las herramientas, no por si el
+turno produjo un texto fluido.
+
+Heurística: si el usuario (o un futuro agente que haga el mismo tipo de tarea) querría
+tener esto por escrito en lugar de averiguarlo de nuevo, consérvalo. Un procedimiento
+operativo de varios pasos (incluso uno de sistemas/operaciones o de análisis/búsqueda de solo lectura, no
+solo de código) normalmente califica. Descártalo solo si es un único comando que cualquier usuario
+encontraría con `--help` en 30 segundos Y no incluye ninguna decisión/trampa digna de
+recordarse.
+
+═══════════════════════════════════════════════════════════════════
+CAMPOS DE EXPERIENCE
+═══════════════════════════════════════════════════════════════════
+
+task — Nombre con forma de consulta; formúlalo como un usuario lo PREGUNTARÍA más adelante.
+ "publicar una versión en la plataforma xx", no
+ "publish_release_internal"
+ Autocontenido (sin "esto", "el archivo", "nosotros").
+
+search_keys — De 0 a 5 formulaciones alternativas que capten aspectos importantes de
+ la solución que `task` por sí solo no cubriría. Formúlalas como preguntas
+ o temas sobre los que futuros usuarios PREGUNTARÍAN. Distintas de task.
+ Omítelas si task ya lo cubre todo.
+
+solution — Contenido completo y autocontenido que el usuario realmente necesita:
+ comandos, ubicaciones de credenciales (NO los VALORES de las credenciales),
+ rutas de archivos, pasos ordenados, trampas, justificación de las decisiones.
+ Agrega el trabajo de extremo a extremo de varios turnos en UNA sola solution si
+ forma una tarea coherente; divídelo en varias memorias solo cuando
+ el usuario hizo tareas no relacionadas.
+
+boundary_envs — Fijación concreta de la que depende la solution, en varias líneas "clave: valor":
+ runtime / SDK / biblioteca + versión
+ endpoint de la API o firma del método
+ servicio externo / versión del middleware
+ NOMBRE de la variable de entorno (no su valor)
+ ruta del archivo de configuración
+ identificador de host / clúster / región
+ Si la solution no depende del entorno, déjalo como "" (vacío).
+ Propósito: cuando el SDK/middleware subyacente se actualice, los futuros
+ consumidores pueden revisarlo para decidir si la solution sigue siendo válida.
+
+confidence — de 0.0 a 1.0
+ 1.0 el usuario lo indicó explícitamente como regla / instrucción
+ 0.7 inferido con buena evidencia a partir de las acciones de las herramientas
+ 0.5 inferido débilmente; una sola observación; incierto
+
+═══════════════════════════════════════════════════════════════════
+CAMPO FACT: EXACTAMENTE UNO por segmento, sin umbral de valor
+═══════════════════════════════════════════════════════════════════
+
+Escribes UN solo fact para todo el segmento: un registro de estado recuperable de esta
+sesión, no una retrospectiva pulida y nunca una lista de hallazgos separados. Un
+futuro agente debe poder retomar el trabajo a partir de él sin confundir una sugerencia,
+una inferencia o una búsqueda parcial con algo verificado.
+
+subject — QUIÉN o QUÉ es el objeto de esta sesión: la única entidad sobre la que o para la que se
+ realizó el trabajo. Un sintagma nominal corto, sin frase, sin verbo.
+ Elige la entidad más específica de la que *trata* la sesión, no la
+ herramienta que usó:
+ el nombre de una persona cuando la sesión atiende a una persona concreta
+ ("Dylan", "Matthew")
+ el archivo / módulo / símbolo cuando el trabajo apunta a código
+ ("auth/middleware.ts", "parse_plan_text")
+ el servicio / host / dispositivo / unidad en trabajo de operaciones
+ ("D:\\WXWork", "redis-cache-prod", "ci.yml")
+ Es una CLAVE ESTRICTA, no prosa: dos sesiones sobre personas distintas
+ o archivos distintos DEBEN tener subjects distintos, y dos sesiones
+ sobre el mismo DEBEN tener la misma cadena, escrita de forma idéntica.
+ Prefiere el identificador exacto tal como aparece en la traza antes que una
+ descripción del mismo. Si el segmento realmente no tiene un único sujeto,
+ devuelve "".
+
+ Por qué importa: subject es la compuerta que decide si una sesión posterior
+ puede sobrescribir esta como "la misma tarea,
+ continuada". Si te equivocas, el estado de una persona reemplaza silenciosamente
+ el de otra.
+
+statement — Un registro compacto de ESTA sesión. Tiene dos partes, y la segunda es la
+ que se pierde.
+ Conserva los datos dados propios de la tarea y las restricciones concretas en lugar de
+ sustituirlos por una valoración genérica del resultado. Enuncia
+ cada regla una sola vez: el texto de instrucciones repetido compite con los datos
+ que la memoria debe retener.
+
+ PARTE 1 — qué pasó, unos 300 caracteres latinos (~150 CJK).
+ Empieza con el objetivo y el objeto concretos ("recuperar el espacio en disco ocupado
+ por D:\\WXWork", "localizar la carpeta new_file_search"), no con un genérico
+ "arreglar un bug" / "encontrar un archivo". Luego, a grandes rasgos, qué se inspeccionó, se probó
+ o se cambió. Luego cómo terminó, con la semántica de exactamente uno de:
+ completado, parcialmente completado, fallido, bloqueado o
+ pendiente de verificación. Incluye los resultados negativos y los callejones sin salida
+ sin exagerarlos.
+
+ PARTE 2 — los DATOS DADOS DE LA TAREA: todo aquello sobre lo que funciona la tarea COMPLETA,
+ aunque este segmento no lo haya establecido y aunque parezca
+ demasiado elemental para mencionarlo. Vinculaciones (qué representa cada nombre/símbolo/etiqueta),
+ valores fijos que la tarea proporciona en lugar de derivarlos,
+ convenciones adoptadas (base de indexación, unidades, zona horaria, valores por defecto) y
+ el propio resultado de este segmento CON su valor ("x = 7", no "se
+ calculó el valor").
+
+ Escribe la PARTE 2 como datos, un elemento por línea, con los valores tal como se dieron:
+ presupuesto de reintentos = 5; timeout 30s; el índice empieza en 0
+ entrada del paso 3: n=64, tolerancia 1e-6
+ franja B: tipo=privada, coste 688.7-721.3 por unidad
+ Una línea debería ser casi por completo valores. Mantén la notación de la traza
+ (símbolos, unidades, números, grafías) y elimina sus frases: quita
+ las expresiones que anuncian un dato en lugar de serlo ("preferiría",
+ "debería estar entre … y …"). Se repiten una vez
+ por elemento, así que una lista de 15 elementos las paga 15 veces.
+ Inclúyelos en CADA fact; nunca escribas "como arriba" ni "igual que en la
+ sesión anterior": la recuperación devuelve un puñado de facts por
+ similitud y puede que el referente no esté entre ellos.
+
+ Apunta a menos de 1200 caracteres en total. Si la PARTE 2 no cabe, ajusta la
+ notación, nunca la cobertura: statement es el vector de recuperación Y
+ el único campo que un segmento posterior puede leer (details no se embebe
+ ni se inyecta), así que lo que se recorte de él se pierde. Comprime la redacción
+ en torno a un dato; nunca el dato.
+
+ La prueba: si el siguiente segmento no puede ver el material original, ¿puede
+ continuar solo a partir de este registro? Solo cuenta un sí. Una
+ vinculación que falta no falla de forma ruidosa: el nombre sigue pareciendo significativo, así que
+ se lee con su significado de uso general y la respuesta que
+ sigue es fluida y trata de otra pregunta.
+
+ IDIOMA — el mismo idioma que la traza de la sesión: statement es el
+ vector de recuperación y las consultas llegan en el idioma de trabajo del usuario,
+ así que otro idioma paga una penalización interlingüística en cada búsqueda.
+
+ FIDELIDAD A LA EVIDENCIA — registra solo las acciones realmente ejecutadas y
+ la evidencia explícitamente presente en la traza. Conserva literalmente los
+ comandos, flags, argumentos, errores y números relevantes.
+ NUNCA completes un comando con flags habituales, y nunca conviertas
+ consejos o planes en acciones:
+ "se ejecutó Get-ChildItem -Force" → "se ejecutó Get-ChildItem"
+ (la traza no contenía `-Force`; no lo inventes)
+ Limita cada hallazgo negativo a lo que realmente se buscó, y
+ enumera CADA límite de cobertura explícito que pudiera invalidarlo,
+ especialmente los fallos de permisos y los límites de profundidad: conserva las raíces,
+ los filtros y la profundidad que estaban en vigor ("no se encontró bajo C:\\ ni
+ D:\\ con profundidad 3; algunos directorios no se cubrieron por Access
+ denied"), nunca lo amplíes a "no existe". No omitas un límite
+ para que el registro quede más bonito.
+ Nunca conviertas una búsqueda parcial en una ausencia global.
+ Un intento bloqueado conserva lo que lo bloqueó.
+ Conserva la distinción entre intentado, observado, verificado,
+ inferido y sin resolver; exprésala de forma natural ("se intentó … pero lo
+ bloqueó Access denied", "se sospecha …, aún no verificado"), no como
+ etiquetas. Sin salida de herramientas o confirmación explícita, NUNCA afirmes que un
+ arreglo funcionó, que se estableció una causa o que una ruta no existe.
+
+ NO registres saludos ni pura charla: es el único caso
+ que recibe "fact": null. Un segmento que solo enunció requisitos, o que
+ se bloqueó antes de hacer trabajo, aun así estableció algo.
+
+details — La SALIDA concreta de la sesión, copiada literalmente. `statement` es
+ un resumen y un resumen necesariamente descarta los valores individuales;
+ una búsqueda posterior casi siempre quiere un valor concreto, no la idea general.
+ Así que, sea cual sea el resultado direccionable que produjo esta sesión, reprodúcelo
+ aquí en su forma y estructura originales:
+ un plan / horario / itinerario → conserva cada línea, cada día, cada
+ franja y cada precio exactamente como se escribieron
+ un bloque de configuración o de código → conserva el bloque
+ la salida relevante de un comando → conserva las líneas que contienen los
+ hallazgos (tamaños, recuentos, versiones, texto de error)
+ un resultado estructurado (tabla, lista de registros) → conserva las filas
+ Conserva el formato original: saltos de línea, prefijos `Day 1:` / clave: valor,
+ unidades, símbolos de moneda, ids. No vuelvas a resumir, no
+ reordenes, no redondees números, no traduzcas.
+
+ Copia SOLO lo que está presente en la traza. Nunca rellenes un hueco: si una franja
+ quedó sin rellenar, déjala sin rellenar o dilo; un valor inventado
+ es peor que uno ausente, porque se recuperará y se usará.
+ Límite de unos 4000 caracteres; si la salida es más larga, conserva las partes
+ que contienen valores concretos y descarta la prosa decorativa, indicando lo que se
+ descartó.
+
+ "" cuando la sesión no produjo ningún artefacto de ese tipo (investigación pura
+ todavía sin hallazgos, o un bloqueo esperando al usuario).
+
+ Este campo NO forma parte del vector de recuperación: `statement` y
+ `subject` se encargan de encontrar, y `details` aporta el valor una vez encontrado.
+ Así que no escribas aquí cebo para la recuperación, y no dupliques el
+ resumen; escribe el material en bruto.
+
+files — 0..N rutas absolutas o relativas al repositorio de ARCHIVOS O DIRECTORIOS realmente
+ manipulados o investigados durante esta sesión. Conserva las raíces investigadas
+ como `C:\\` y `D:\\`. Incluye solo rutas que se hayan
+ accedido/buscado realmente, no rutas meramente sugeridas o planificadas;
+ [] si no aplica ninguna.
+═══════════════════════════════════════════════════════════════════
+CONTEXTO DEL HOST (proporcionado por el SDK)
+═══════════════════════════════════════════════════════════════════
+- workspace_id presente: {workspace_present}
+- branch presente: {branch_present}
+
+Cuando no hay workspace_id, la solution no puede depender de contexto
+local del proyecto no explicitado: detalla cualquier repositorio / ruta / servicio que necesite dentro de
+`solution` o `boundary_envs` para que la memoria siga siendo utilizable por sí sola.
+
+═══════════════════════════════════════════════════════════════════
+CONVERSACIÓN
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+SALIDA (solo JSON estricto, sin markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "subject": "...",
+ "statement": "...",
+ "files": ["..."],
+ "details": "..."
+ }}
+}}
+
+POR DEFECTO, EXTRAE. Cuando el segmento hizo trabajo real, DEBES devolver al menos
+una experiencia, aunque la tarea parezca simple o haya sido un éxito a la primera;
+recoge igualmente la esencia reutilizable de lo que se hizo (el método / comando / cómo hacerlo).
+Cuando la sesión es escasa, basta con la experiencia más valiosa.
+
+La ÚNICA excepción es el caso de bloqueo descrito arriba: si el segmento no hizo trabajo real
+porque quedó bloqueado pidiendo al usuario información que faltaba, devuelve
+"experiences": [] y escribe solo el fact. No fabriques una experiencia para
+cumplir esta instrucción: una inventada ("cómo pedir la ciudad
+de salida") es peor que ninguna, porque luego se recupera y se sigue. El vacío está
+permitido SOLO por ese motivo, nunca como atajo cuando realmente se hizo trabajo.
+
+"fact" es un ÚNICO objeto, nunca una lista: un registro por sesión.
+
+Escribe SIEMPRE el fact. El listón para el fact no es "¿fue valioso?" sino "¿pasó
+algo en absoluto?", y un segmento que te llega ya lo ha superado.
+Esto incluye los segmentos que parecen preparación más que trabajo: un único
+mensaje del usuario que enuncia requisitos, parámetros o un estado inicial, sin
+ejecutar herramientas, es justo el material que una sesión posterior no puede reconstruir por sí sola
+— escribe en `statement` los requisitos, los parámetros y el estado inicial junto con la situación (en notación compacta, sin copiar literalmente las frases de la conversación),
+y no los relegues a `details` (`details` no entra en el vector de recuperación y el lado de lectura tampoco lo inyecta). Usa
+"fact": null SOLO para saludos y pura charla sin contenido alguno.
+En caso de duda, escribe el fact: un registro innecesario cuesta una fila, mientras que uno
+descartado cuesta cada sesión posterior que lo necesitaba y no tiene forma de saber que existía.
+"""
+
+CODING_EXTRACT_PROMPT_CODING = """\
+╔═══════════════════════════════════════════════════════════════════════════╗
+║ RESTRICCIÓN ESTRICTA: léela antes que nada; prevalece sobre cualquier ║
+║ formulación posterior de este prompt que parezca pedir una narración. ║
+║ ║
+║ NO estás escribiendo un informe de lo que hizo una persona. Escribes lo ║
+║ que un AGENTE FUTURO necesita para actuar. Ese agente ya tiene su propia ║
+║ tarea; no le importa lo que quería este usuario. Necesita saber: qué se ║
+║ decidió aquí, en qué coordenadas del código, qué se probó y se descartó, ║
+║ y si se verificó. ║
+║ ║
+║ En concreto, en cada `statement` y en cada `solution`: ║
+║ · El sujeto gramatical es el CÓDIGO o LA DECISIÓN, nunca "el usuario" ║
+║ y nunca "el agente". No escribas "El usuario intentó…", ║
+║ "El usuario quería…", "Luego el agente comprobó…". ║
+║ · Nunca cierres con una frase administrativa como "la sesión se ║
+║ completó", "se tomó nota del error", "aún no se encontró solución". ║
+║ Cierra con la decisión y su estado de verificación. Si no se decidió ║
+║ nada, cierra con lo que se DESCARTÓ y la siguiente pista sin ║
+║ explorar: esa es la parte reutilizable. ║
+║ · Conserva el síntoma concreto (cadena de error, comando que falla, ║
+║ salida incorrecta): es lo que coincidirá con una búsqueda futura. ║
+║ ║
+║ mal: "El usuario intentó escribir una QTable en RST con header_rows y ║
+║ obtuvo un TypeError. La sesión se completó anotando el error." ║
+║ bien: "el writer RST de ascii.rst rechaza header_rows: `tbl.write(..., \\ ║
+║ format='ascii.rst', header_rows=['name','unit'])` lanza TypeError ║
+║ porque RST.__init__ no lo reenvía, a diferencia de ║
+║ ascii.fixed_width, que sí lo acepta. No se escribió ningún ║
+║ arreglo: el writer necesita la misma canalización de header_rows ║
+║ que fixed_width." ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+
+Extraes memorias de TRABAJO (working memories) duraderas de un segmento de sesión de ejecución de tareas.
+Una sesión de "trabajo" es cualquier tarea práctica en la que el usuario maneja un ordenador /
+sistema mediante herramientas; abarca TANTO el trabajo de software/código (escribir, depurar,
+refactorizar, compilar, desplegar, uso de APIs/bibliotecas) COMO el trabajo de sistemas y operaciones
+(ejecutar comandos de shell/PowerShell, análisis o limpieza de disco/almacenamiento, operaciones con
+archivos y carpetas, instalar/configurar software, preparar el entorno/dispositivo,
+inspeccionar la salud del hardware/disco, copias de seguridad, programación/automatización, procesamiento de datos).
+
+Produces DOS capas a partir del MISMO segmento:
+
+ EXPERIENCES (procedimental, "cómo hacerlo"): método reutilizable, extraído solo
+ cuando supera el UMBRAL DE VALOR de abajo. Un paquete (task, search_keys, solution,
+ boundary_envs).
+
+ FACT (episódico, "qué quedó establecido esta vez"): EXACTAMENTE UN registro de ESTA
+ sesión. NO es una narración de lo que hizo el usuario. Registra, en este orden:
+ la tarea y su síntoma concreto (esto es lo que la hace localizable después), las
+ coordenadas del código, EN QUÉ SE QUEDÓ y qué se descartó, y hasta dónde se
+ verificó. Sin umbral de valor, pero nunca hay más de uno.
+
+Las dos capas responden a preguntas distintas y se almacenan por separado. Un método
+que se generaliza va en EXPERIENCES; la historia de esta sesión concreta,
+válida solo para este sistema / este proyecto / ahora mismo, va en el FACT.
+
+═══════════════════════════════════════════════════════════════════
+UMBRAL DE VALOR (SOLO EXPERIENCES): NO lo cruces a la ligera.
+═══════════════════════════════════════════════════════════════════
+Una memoria DEBE cumplir TODO lo siguiente:
+ (a) Resuelve un problema que probablemente se repita para el mismo usuario
+ (b) La solución no es trivial: combina varias piezas de información / pasos, O
+ incluye la justificación de una decisión, O recoge una solución alternativa difícil de conseguir, O es un
+ procedimiento/receta reutilizable para una tarea operativa (p. ej. cómo analizar y
+ limpiar el uso de disco, cómo organizar archivos por lotes, cómo inspeccionar la salud
+ del hardware, cómo configurar una tarea programada)
+ (c) Un futuro agente / usuario preferiría consultarla antes que volver a descubrirla
+
+IMPORTANTE: las tareas de análisis / diagnóstico / investigación CUENTAN:
+Una tarea NO tiene que hacer un cambio ni "arreglar" algo para merecer ser recordada.
+El trabajo de solo lectura / analítico / de resolución de problemas es valioso cuando su PROCEDIMIENTO o su
+CONCLUSIÓN son reutilizables. Extrae explícitamente:
+ - Recetas de análisis / diagnóstico: el procedimiento reutilizable + lo que reveló
+ (p. ej. "cómo analizar qué carpetas ocupan el espacio de la unidad C:": los comandos de escaneo,
+ los problemas encontrados y el hallazgo). "Solo produjo un informe, sin cambios"
+ NO es motivo para omitirla: el MÉTODO reutilizable es la memoria.
+ - Resultados de investigación, INCLUIDOS los negativos / de no encontrado
+ (p. ej. "se buscó la carpeta X en C: y D: con rg / fs_search / índice SQL;
+ no se encontró en ningún sitio"). Un callejón sin salida registrado evita que el próximo agente repita
+ la misma búsqueda infructuosa, así que supera el umbral.
+NO rechaces una memoria solo porque "el asistente podría regenerar los
+comandos" o porque "en realidad no se modificó nada". Si el procedimiento o la conclusión
+ahorrarían esfuerzo en el futuro, consérvala.
+
+NO extraigas:
+ - Operaciones de un solo paso realmente triviales sin procedimiento reutilizable ("renombrar un archivo",
+ "git status", "ejecutar ls una vez")
+ - Problemas puntuales ya resueltos sin lección transferible
+ - Información que ya está en el repositorio/sistema (no dupliques package.json)
+ - Tareas desechables por PR / por sesión, salvo que codifiquen un patrón reutilizable
+
+Heurística: si el usuario (o un futuro agente que haga el mismo tipo de tarea) querría
+tener esto por escrito en lugar de averiguarlo de nuevo, consérvalo. Un procedimiento
+operativo de varios pasos (incluso uno de sistemas/operaciones o de análisis/búsqueda de solo lectura, no
+solo de código) normalmente califica. Descártalo solo si es un único comando que cualquier usuario
+encontraría con `--help` en 30 segundos Y no incluye ninguna decisión/trampa digna de
+recordarse.
+
+═══════════════════════════════════════════════════════════════════
+TRABAJO CON CÓDIGO: lo que un agente futuro no puede volver a deducir, así que DEBE recogerse
+═══════════════════════════════════════════════════════════════════
+Cuando el segmento es trabajo de software sobre un repositorio, el método reutilizable es solo
+la mitad. La otra mitad es DÓNDE vive el trabajo y QUÉ VERSIÓN ganó. Eso
+no se puede recuperar leyendo el código más tarde: el código muestra el estado actual,
+no en qué rama está ni qué se descartó ya.
+
+Esta sección NO pide un registro más largo. Pide que GASTES EL MISMO
+PRESUPUESTO en tokens de mayor valor: elimina los objetivos repetidos, la narración de lo que el
+asistente "decidió luego" y el código pegado que solo estás repitiendo; dedica esos
+caracteres a los cuatro elementos de abajo. Un registro que omite la rama pero
+cita 30 líneas de diff es un mal intercambio.
+
+1. RAMA / UBICACIÓN DE TRABAJO: literal, en el `statement` del fact. Si el segmento
+ menciona o hace checkout de `feat/x` / `fix/y`, ese token DEBE aparecer. Un agente
+ que retoma el trabajo en la rama equivocada produce cambios que se descartan en silencio,
+ así que este único token pesa más que cualquier otro detalle.
+
+2. QUÉ VERSIÓN GANÓ: cuando el usuario cambió de opinión, nombra la ganadora y marca
+ la perdedora en una sola cláusula: "se optó por A; se descartó la B intermedia". No ambas
+ completas: una cláusula. Quedarse solo con la última es un error: un agente que se encuentre el
+ código descartado debe reconocerlo, o "arreglará" las cosas volviendo a la variante descartada.
+ Expresiones como `scratch that / go back to / actually, let's / no, not that`
+ lo señalan: lo que sigue es lo que vale, lo que precede queda sustituido.
+
+3. COORDENADAS EXACTAS, NO CÓDIGO PEGADO: ruta relativa al repositorio
+ (`qutebrowser/utils/debug.py`, nunca solo `debug.py`) más la función /
+ clase modificada. Si cambió una firma, da la nueva firma. Si se decidió una constante,
+ regex o literal, cita ESO literalmente, pero cita solo eso, no el
+ bloque que lo rodea. Una línea precisa vale más que un párrafo de aproximación.
+
+4. VERIFICADO frente a SOLO ESCRITO: bastan unas pocas palabras ("tests ejecutados y pasando" /
+ "confirmado solo con git diff, tests no ejecutados"). "el cambio está hecho" y "el cambio está hecho
+ y probado" llevan a un agente futuro a hacer cosas muy distintas a continuación.
+
+Antipatrón: resumir el objetivo y descartar las coordenadas:
+ mal: "se refactorizó la lógica de parseo de colores para que quedara más limpia."
+ bien: "en feat/q4, en qutebrowser/config/configtypes.py QtColor._parse_value:
+ se optó por `mult = 360.0 if kind == 'h' else 255.0`; se descartó la versión intermedia que
+ usaba 255.0 para todo. Tests no ejecutados."
+ (la buena es MÁS CORTA que la mayoría de las malas: simplemente dedica cada carácter
+ a algo que no se puede volver a deducir)
+
+═══════════════════════════════════════════════════════════════════
+CAMPOS DE EXPERIENCE
+═══════════════════════════════════════════════════════════════════
+
+task — Nombre con forma de consulta; formúlalo como un usuario lo PREGUNTARÍA más adelante.
+ "publicar una versión en la plataforma xx", no "publish_release_internal"
+ Autocontenido (sin "esto", "el archivo", "nosotros").
+
+search_keys — De 0 a 5 formulaciones alternativas que capten aspectos importantes de
+ la solución que `task` por sí solo no cubriría. Formúlalas como preguntas
+ o temas sobre los que futuros usuarios PREGUNTARÍAN. Distintas de task.
+ Omítelas si task ya lo cubre todo.
+
+solution — Contenido completo y autocontenido que el usuario realmente necesita:
+ comandos, ubicaciones de credenciales (NO los VALORES de las credenciales),
+ rutas de archivos, pasos ordenados, trampas, justificación de las decisiones.
+ Agrega el trabajo de extremo a extremo de varios turnos en UNA sola solution si
+ forma una tarea coherente; divídelo en varias memorias solo cuando
+ el usuario hizo tareas no relacionadas.
+
+boundary_envs — Fijación concreta de la que depende la solution, en varias líneas "clave: valor":
+ runtime / SDK / biblioteca + versión
+ endpoint de la API o firma del método
+ servicio externo / versión del middleware
+ NOMBRE de la variable de entorno (no su valor)
+ ruta del archivo de configuración
+ identificador de host / clúster / región
+ Si la solution no depende del entorno, déjalo como "" (vacío).
+ Propósito: cuando el SDK/middleware subyacente se actualice, los futuros
+ consumidores pueden revisarlo para decidir si la solution sigue siendo válida.
+
+confidence — de 0.0 a 1.0
+ 1.0 el usuario lo indicó explícitamente como regla / instrucción
+ 0.7 inferido con buena evidencia a partir de las acciones de las herramientas
+ 0.5 inferido débilmente; una sola observación; incierto
+
+═══════════════════════════════════════════════════════════════════
+CAMPO FACT: EXACTAMENTE UNO por segmento, sin umbral de valor
+═══════════════════════════════════════════════════════════════════
+
+Escribes UN solo fact para todo el segmento: un registro de estado recuperable de esta
+sesión, no una retrospectiva pulida y nunca una lista de hallazgos separados. Un
+futuro agente debe poder retomar el trabajo a partir de él sin confundir una sugerencia,
+una inferencia o una búsqueda parcial con algo verificado.
+
+statement — Un resumen compacto de ESTA sesión. Tiene dos funciones a la vez, y
+ debe cumplir AMBAS: es el vector de recuperación (un agente futuro lo encuentra
+ buscando con un informe de incidencia nuevo, redactado como un usuario redacta un
+ problema), y es la carga útil sobre la que ese agente actúa después. Así que:
+
+ ABRE con la tarea y el síntoma, con las palabras que usaría un usuario.
+ Esto es lo que la hace localizable: mantén la forma superficial cercana a cómo
+ se reportaría el problema. Nombra el objetivo y el objeto concretos
+ ("recuperar espacio en disco bajo D:\\WXWork", "ajustar el multiplicador de tono
+ en QtColor._parse_value en feat/q4", "localizar la carpeta
+ new_file_search"), nunca un genérico "arreglar un bug" / "buscar un archivo". Incluye
+ el síntoma concreto: la cadena de error, el comando que falla, la
+ salida incorrecta.
+
+ LUEGO da las coordenadas y la decisión.
+ ruta relativa al repositorio, símbolo y rama en el trabajo con código. Indica en qué
+ SE QUEDÓ, y en la misma cláusula marca lo que se descartó
+ ("se optó por X; se descartó la Y intermedia"). Esta es la parte que
+ no se puede volver a deducir leyendo el código: el código solo muestra la
+ ganadora, nunca que se probó Y y se rechazó. Un agente que se encuentre la
+ variante rechazada más adelante debe poder reconocerla, o "arreglará"
+ el código volviendo a la versión descartada.
+
+ CIERRA con el estado de la evidencia.
+ Exactamente uno de: completado, parcialmente completado, fallido, bloqueado o
+ pendiente de verificación, más cómo se comprobó ("tests ejecutados y
+ pasando" / "confirmado solo con git diff, tests no ejecutados"). Incluye
+ los resultados negativos y los callejones sin salida sin exagerarlos.
+
+ ⚠️ Nunca te quedes en la narración. "El usuario probó X y obtuvo el error Y; aún no se
+ encontró solución" es un registro desperdiciado: se recupera bien pero no le da a un
+ agente futuro nada sobre lo que actuar. Si la sesión realmente no llegó a ninguna
+ decisión, di qué se descartó y cuál es la siguiente pista sin explorar:
+ esa es la parte reutilizable.
+
+ El sujeto de las frases debe ser el código y la decisión, no
+ "el usuario". De 2 a 4 frases, prosa fluida, sin secciones etiquetadas.
+ Techo estricto de ~400 caracteres latinos (~200 caracteres CJK).
+
+ FIDELIDAD A LA EVIDENCIA — obligatoria:
+ - Registra solo las acciones realmente ejecutadas y la evidencia explícitamente
+ presente en la traza. Conserva literalmente los comandos, flags,
+ argumentos, errores y números relevantes. NUNCA completes un
+ comando con flags habituales ni conviertas consejos/planes en acciones.
+ - Conserva la distinción entre intentado, observado, verificado,
+ inferido y sin resolver. No añadas esas etiquetas a la prosa;
+ expresa su significado de forma natural, p. ej. "se intentó … pero lo bloqueó
+ Access denied" o "se sospecha … , aún no verificado".
+ - Sin salida de herramientas o confirmación explícita, NUNCA afirmes que un arreglo
+ funcionó, que se estableció una causa, que un archivo/carpeta no
+ existe o que los tests pasaron.
+ - Limita cada hallazgo negativo a lo que realmente se buscó y
+ enumera CADA límite de cobertura explícito que pudiera invalidarlo,
+ especialmente los fallos de permisos y la profundidad máxima de búsqueda:
+ "no se encontró en las partes buscadas de C:\\ y D:\\; algunos
+ directorios se omitieron por Access denied, y la búsqueda también tenía
+ límite de profundidad". No omitas un límite para que el
+ resumen quede más bonito. Nunca conviertas una búsqueda parcial en una ausencia
+ global.
+ - Presenta la causalidad como cierta solo cuando la traza la verifica
+ directamente. En caso contrario, conserva la cautela ("se sospecha" / "se infiere" / "aún no
+ verificado"); no reescribas una
+ suposición incorrecta de un test como la causa raíz del sistema.
+
+ CRÍTICO: este texto ES el vector de recuperación, y es lo único
+ con lo que se compara una consulta futura. Un resumen genérico no
+ vale nada, porque TODAS las sesiones parecen un resumen genérico:
+ coincidiría con todas las consultas y no respondería a ninguna. Así que DEBES nombrar
+ los anclajes concretos que hacen que ESTA sesión sea localizable: rutas de archivo
+ reales, nombres de funciones / símbolos, nombres de ramas, comandos, cadenas de error,
+ versiones, claves y valores de configuración, nombres de hosts / servicios.
+ Si alguien busca más adelante cualquiera de esos datos concretos, este
+ resumen tiene que ser lo que aparezca.
+ bien: "arreglar un `npm run build` que falla en CI. Se leyeron
+ .github/workflows/ci.yml y package.json; se rastreó hasta webpack
+ 5.74 que da ERR_OSSL_EVP_UNSUPPORTED con node 18. Subir el node
+ del workflow a 20 hizo que la build pasara; node 18 sigue
+ reproduciéndolo en local."
+ bien: "en la rama feat/q0, en qutebrowser/utils/debug.py signal_name:
+ PyQt<5.11 solo expone el nombre mediante repr(sig), y repr aparece en
+ una forma con corchetes y otra con paréntesis. Se optó por dos patrones
+ probados en orden con fullmatch, cortando en la primera coincidencia; se
+ descartó la versión de una sola regex. Confirmado con git diff, tests no
+ ejecutados."
+ mal: "el usuario quería arreglar un bug de build, el agente miró algunos archivos
+ de configuración, cambió algo de código y lo arregló."
+ (sin ruta, sin comando, sin cadena de error, sin versión: nada
+ sobre lo que recuperar; todas las sesiones se leen exactamente así)
+ mal: "se arregló el problema de compatibilidad del parseo de nombres de señales en una
+ rama de funcionalidad."
+ (¿qué rama? ¿qué archivo? ¿qué función? ¿cuál de las dos
+ versiones en competencia ganó? nada de esto sobrevive a ser
+ recuperado una semana después)
+ Ejemplos de fidelidad (mal → bien):
+ "se ejecutó Get-ChildItem -Force" → "se ejecutó Get-ChildItem"
+ (la traza no contenía `-Force`; no lo inventes)
+ "se confirmó que new_file_search no existe" →
+ "new_file_search no se encontró en las partes buscadas de C:\\ y
+ D:\\; algunos directorios se omitieron por Access denied o por el límite
+ de profundidad, así que la investigación solo está hecha en parte"
+ "las cargas idénticas provocan un error de bloqueo espurio" →
+ "el script de verificación suponía que el último escritor es siempre un rank
+ fijo; esa suposición no se cumple, así que si hay un bug de bloqueo
+ sigue sin verificarse"
+
+ NO registres saludos ni pura charla. Si el segmento no estableció
+ nada en absoluto, devuelve "fact": null.
+
+files — 0..N rutas absolutas o relativas al repositorio de ARCHIVOS O DIRECTORIOS realmente
+ manipulados o investigados durante esta sesión. Conserva las raíces investigadas
+ como `C:\\` y `D:\\`. Incluye solo rutas que se hayan
+ accedido/buscado realmente, no rutas meramente sugeridas o planificadas;
+ [] si no aplica ninguna.
+
+═══════════════════════════════════════════════════════════════════
+CONTEXTO DEL HOST (proporcionado por el SDK)
+═══════════════════════════════════════════════════════════════════
+- workspace_id presente: {workspace_present}
+- branch presente: {branch_present}
+
+Cuando no hay workspace_id, la solution no puede depender de contexto
+local del proyecto no explicitado: detalla cualquier repositorio / ruta / servicio que necesite dentro de
+`solution` o `boundary_envs` para que la memoria siga siendo utilizable por sí sola.
+
+═══════════════════════════════════════════════════════════════════
+CONVERSACIÓN
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+SALIDA (solo JSON estricto, sin markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "statement": "...",
+ "files": ["..."]
+ }}
+}}
+
+OBLIGATORIO: DEBES devolver al menos UNA experiencia. NO devuelvas una lista vacía.
+Aunque la tarea parezca simple o haya sido un éxito a la primera, recoge igualmente la
+esencia reutilizable de lo que se hizo (el método / comando / cómo hacerlo). Cuando la sesión es escasa
+solo se requiere la experiencia más valiosa, pero nunca
+devuelvas un array "experiences" vacío.
+
+"fact" es un ÚNICO objeto, nunca una lista: un registro por sesión. Usa
+"fact": null solo cuando el segmento sea pura charla que no estableció nada.
+"""
+
+CODING_RECONCILE_PROMPT = """\
+Decides cómo fusionar los nuevos borradores de memoria de código con las memorias existentes del usuario.
+
+Para cada borrador nuevo, decide una de estas opciones:
+ ADD — ninguna memoria existente describe la misma tarea/aspecto
+ UPDATE — una memoria existente describe la misma tarea; el nuevo borrador la reemplaza
+ (puede que la solution haya cambiado, que el entorno se haya actualizado, etc.)
+ SKIP — duplicado de una existente; nada nuevo
+
+Además, puedes emitir operaciones DELETE sobre candidatos existentes cuando el nuevo
+contenido los deja obsoletos o inválidos:
+ DELETE — la nueva conversación sustituye/cancela/invalida EXPLÍCITAMENTE una
+ memoria existente que no se puede reparar con UPDATE. Ejemplos:
+ * el usuario dice "ya no uses X" y X solo está presente como una
+ memoria aparte (no la que se está añadiendo/actualizando)
+ * el boundary_envs del candidato (servicio / endpoint / SDK) ya no existe
+ y la nueva conversación confirma la retirada
+
+Reglas:
+- "Misma tarea" significa que la memoria existente y el nuevo borrador serían ambas respuestas
+ válidas a la misma consulta futura del usuario.
+- Si la solution difiere, prefiere UPDATE (no guardamos historial).
+- Si tanto task como solution coinciden estrechamente, SKIP.
+- DELETE solo cuando haya evidencia EXPLÍCITA de que el candidato es inválido/obsoleto.
+ Nunca hagas DELETE solo porque un candidato parezca "anticuado".
+- Las operaciones de salida pueden superar en número a los borradores cuando se producen DELETE.
+
+═══════════════════════════════════════════════════════════════════
+BORRADORES NUEVOS
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+CANDIDATOS EXISTENTES (por borrador, recuperados por similitud de task)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+SALIDA (solo JSON estricto, sin 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": "el usuario declaró explícitamente obsoleto Y"}},
+ {{"draft_idx": 2, "action": "SKIP", "reason": "duplicado"}}
+ ]
+}}
+
+Si no hay borradores, devuelve {{"ops": []}}.
+"""
+
+CODING_FACT_RECONCILE_PROMPT = """\
+Mantienes FACTS DE TRABAJO a nivel de sesión. Cada statement resume una
+traza/sesión completa: la tarea del usuario, el enfoque a grandes rasgos y el resultado. No es una
+afirmación atómica.
+
+Todo nuevo fact de sesión de abajo SE almacenará; esa no es tu decisión. Tu único
+trabajo es detectar la continuación de tareas: ¿la nueva sesión sigue avanzando en la
+MISMA tarea del usuario que un fact de sesión existente? Si es así, haz SUPERSEDE del fact más antiguo para que
+los enlaces formen una cadena de progreso entre sesiones para esa tarea.
+
+Marca un fact existente como sustituido SOLO cuando haya evidencia sólida de que:
+ - Los subjects coinciden: ambos registros tratan de la MISMA entidad: la misma
+ persona, el mismo archivo/módulo, el mismo host/servicio. Un subject compartido es
+ necesario pero no suficiente; Y
+ - El objetivo del usuario es sustancialmente el MISMO, no simplemente del mismo tema/proyecto;
+ Y
+ - La nueva traza continúa, reintenta, amplía, verifica o termina el trabajo
+ registrado por la traza existente.
+
+NO hagas SUPERSEDE cuando:
+ - Los dos registros nombran subjects distintos. Dos personas de un mismo grupo, dos archivos
+ de un mismo módulo, dos hosts de un mismo clúster son PARALELOS, no sucesivos: el
+ estado de una persona no es una versión más reciente del de otra. Cuando un subject se muestra
+ como (unspecified), juzga solo por el statement.
+ - Las sesiones simplemente mencionan el mismo archivo, símbolo, componente, repositorio,
+ error o tecnología, pero persiguen objetivos de usuario distintos.
+ - Una tarea solo aporta contexto o una técnica para otra tarea.
+ - La relación es incierta. Sé conservador: INSERT es la opción segura por defecto;
+ fusionar sesiones no relacionadas destruye su historial de tareas separado.
+
+Trata cada statement como texto acotado por la evidencia. No reinterpretes una inferencia
+contenida en él como una causa establecida, ni uses una conjetura/error compartido como prueba de que
+los objetivos del usuario son los mismos. Tu decisión trata solo de la continuación de la tarea; no
+"corrijas", completes ni adornes ninguno de los registros de sesión.
+
+Ejemplos:
+ existente: "El usuario necesitaba arreglar el npm run build de CI; se rastreó hasta
+ ERR_OSSL_EVP_UNSUPPORTED con Node 18, workflow aún sin cambiar."
+ nuevo: "El usuario siguió arreglando la misma build de CI; subió Node en
+ .github/workflows/ci.yml a 20 y npm run build pasó."
+ → SUPERSEDE
+
+ existente: "El usuario necesitaba arreglar el manejo de la caducidad de JWT en
+ auth/middleware.ts; se añadió la lógica de refresco."
+ nuevo: "El usuario necesitaba añadir logging de rendimiento a
+ auth/middleware.ts; se introdujo una métrica de latencia."
+ → conservar ambos
+ (mismo archivo/proyecto, distinto objetivo del usuario)
+
+═══════════════════════════════════════════════════════════════════
+NUEVOS FACTS DE SESIÓN
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+FACTS DE SESIÓN EXISTENTES (por fact nuevo, recuperados por similitud del statement)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+SALIDA (solo JSON estricto, sin markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "ops": [
+ {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "continúa la misma tarea de arreglo de CI"}},
+ {{"draft_idx": 1, "supersedes": []}}
+ ]
+}}
+
+Usa solo ids de fact que aparezcan en la lista de candidatos de ese mismo draft_idx.
+Si no se sustituye nada en ningún caso, devuelve {{"ops": []}}.
+"""
+
+CODING_CHAIN_SUMMARY_PROMPT = """\
+Una tarea del usuario en un almacén de memoria de trabajo ha avanzado a lo largo de varias sesiones. Abajo están
+los resúmenes de sesión de la cadena de progreso de esa tarea, del más antiguo al más reciente, terminando con
+la sesión actual.
+
+Resume cómo avanzó la MISMA tarea a lo largo de las sesiones hasta su estado actual.
+Cubre cada etapa importante en orden cronológico. Para cada etapa, conserva
+cuando estén disponibles: la acción o el cambio real, su resultado directo y cualquier
+problema sin resolver o condición limitante. Termina con un estado actual explícito.
+
+Reglas:
+ - Esto es solo compresión. Informa SOLO de lo que dicen las entradas; nunca añadas ni
+ completes un comando, causa, motivo, acción, resultado de test, estado de éxito o
+ conclusión negativa global.
+ - Conserva exactamente el estado de la evidencia: intentado no es completado, observado no es
+ verificado, inferido no es establecido, y lo no resuelto sigue sin resolver.
+ Mantén las palabras de incertidumbre y los límites de búsqueda/permisos/cobertura.
+ - Indica fielmente el estado final actual (completado, parcialmente completado,
+ fallido, bloqueado o pendiente de verificación). Nunca lo mejores basándote en
+ una historia causal plausible ni en una entrada posterior que no lo verificó.
+ - Cuando las entradas mencionen una causa sospechada y un resultado posterior, relaciónalos
+ causalmente solo si una entrada dice directamente que esa causa se verificó.
+ - Conserva los anclajes concretos de recuperación: rutas de archivo, símbolos, comandos, cadenas
+ de error, versiones, claves/valores de configuración y valores numéricos importantes que
+ importen para el progreso.
+ - Para cadenas de 2-3 generaciones, no comprimas en exceso la progresión en una sola
+ frase. Prefiere 2-4 párrafos compactos cuando sea útil, o prosa legible con
+ un objetivo de tarea claro, la progresión etapa por etapa y el estado actual.
+ - No copies mecánicamente todo el historial. Omite repeticiones y detalles de poco valor
+ conservando las acciones importantes, los resultados directos y lo pendiente.
+ - No inventes títulos de etapa ni fechas. Menciona una fecha solo cuando las entradas
+ la hagan significativa; las marcas de tiempo sueltas son ruido.
+ - Si las entradas dicen que se omitieron revisiones anteriores, indica explícitamente que
+ se omitió historial anterior; no des a entender que las entradas proporcionadas están completas.
+ - Escribe en el mismo idioma en que están escritas las entradas.
+ - Sin preámbulo ni comillas envolventes.
+
+Ejemplo
+ entradas:
+ (2026-07-20) El usuario necesitaba arreglar el npm run build de CI; se rastreó hasta
+ ERR_OSSL_EVP_UNSUPPORTED con Node 18, workflow aún sin
+ cambiar.
+ (2026-07-24) El usuario continuó ese arreglo de CI; subió Node en
+ .github/workflows/ci.yml a 20, pero la caché de dependencias
+ seguía reproduciendo el error antiguo.
+ (now) El usuario continuó verificando el mismo arreglo; tras limpiar la
+ caché de npm, npm run build pasó.
+ salida:
+ El objetivo de la tarea es arreglar el npm run build de CI. Primero se rastreó hasta
+ ERR_OSSL_EVP_UNSUPPORTED con Node 18, con el workflow aún sin cambiar;
+ después se subió .github/workflows/ci.yml a Node 20, pero la caché de
+ dependencias mantuvo presente el error antiguo. Por último, tras limpiar la caché de npm,
+ npm run build pasó, así que este arreglo de la build está actualmente verificado como completado.
+
+═══════════════════════════════════════════════════════════════════
+ENTRADAS
+═══════════════════════════════════════════════════════════════════
+{chain_block}
+
+═══════════════════════════════════════════════════════════════════
+SALIDA (solo el resumen, nada más)
+═══════════════════════════════════════════════════════════════════
+"""
+
+
+# ================================================================
+# Episode / topic summaries
+# ================================================================
+
+EPISODE_SUMMARY_PROMPT = """Estás resumiendo UN episodio de conversación con el usuario.
+
+Un episodio es un único tramo de conversación (un asunto del que se habló),
+posiblemente a lo largo de varias sesiones de escritura.
+
+## Memorias registradas durante este episodio (de la más antigua → a la más reciente)
+
+{memories}
+
+---
+
+Escribe un único resumen denso de lo que ocurrió / de lo que se habló en este episodio.
+
+Reglas:
+
+* De 2 a 4 frases, en tercera persona, empezando por "El usuario ..." (o por la persona con nombre
+ si las memorias tratan de otra persona).
+* Une las memorias en un único relato coherente: un episodio suele tener un
+ hilo conductor (un plan, un problema, una salida, una decisión).
+* Conserva los detalles concretos: nombres, lugares, números, fechas.
+* NO inventes nada que no esté en las memorias.
+* NO enumeres las memorias una por una; sintetízalas.
+* El idioma de salida debe coincidir con el idioma de las memorias.
+
+Devuelve SOLO el texto del resumen, sin preámbulo, sin JSON, sin comillas."""
+
+TOPIC_SUMMARY_PROMPT = """Estás resumiendo todo lo que se sabe sobre UN tema.
+
+## Tema
+
+{topic_name}
+
+## Memorias de este tema (de la más antigua → a la más reciente)
+
+{memories}
+
+---
+
+Escribe un único resumen denso de lo que se sabe sobre el usuario en relación con este
+tema.
+
+Reglas:
+
+* De 2 a 4 frases, en tercera persona, empezando por "El usuario ..." (o por la persona con nombre
+ si las memorias tratan de otra persona).
+* Cubre el tema en su conjunto: indica la situación actual y menciona cómo
+ evolucionó solo cuando el cambio importe.
+* Conserva los detalles concretos: nombres, lugares, números, fechas.
+* NO inventes nada que no esté en las memorias.
+* NO enumeres las memorias una por una; sintetízalas.
+* El idioma de salida debe coincidir con el idioma de las memorias.
+
+Devuelve SOLO el texto del resumen, sin preámbulo, sin JSON, sin comillas."""
+
+
+# ================================================================
+# System 2 evolve (pipelines/system2_agent.py)
+# ================================================================
+
+SYSTEM2_AGENT_PROMPT = """Eres un Agent de procesamiento cognitivo. Tu trabajo es hacer evolucionar estructuras cognitivas de orden superior a partir de los datos de memoria en bruto de un usuario.
+
+## Arquitectura de memoria
+
+### VDB (base de datos vectorial): solo lectura
+| Capa | Descripción |
+|-------|-------------|
+| L0 BASIC_INFO | Atributos del usuario (nombre, edad, profesión) |
+| L1 RAW | Transcripciones originales de las conversaciones |
+| L2 FACT | Hechos atómicos extraídos de las conversaciones |
+| L3 SUMMARY | Resúmenes de sesión |
+| L4 IDENTITY | Rasgos de identidad, preferencias, hábitos |
+| L5 KNOWLEDGE | Conocimiento de dominio |
+
+### Graph (grafo de conocimiento): eres el único que escribe en él
+| Capa | Descripción |
+|-------|-------------|
+| L6 SCHEMA | Patrones de comportamiento: ligados a un dominio, atómicos, inmutables una vez creados |
+
+## ¿Qué es un Schema L6?
+
+Un Schema es un patrón de comportamiento transversal a varios eventos dentro del modelo de usuario a largo plazo y
+contiene los tres componentes siguientes:
+
+
+- **Circunstancia**: El dominio/tema/situación en el que se observa este patrón. Un Schema DEBE mantenerse dentro de su circunstancia: NO generalices entre dominios. La abstracción entre dominios la gestiona el sistema por separado.
+- **Patrón**: El comportamiento habitual, el estilo de pensamiento o la tendencia de acción del usuario en esta circunstancia.
+- **Insight**: El impulsor psicológico o modelo mental subyacente.
+
+### Formato del contenido
+Usa una sola frase que combine los tres:
+"Cuando [circunstancia], el usuario [patrón], lo que refleja [insight]."
+
+Para patrones duraderos relacionados con emociones, terapia, estrés, duelo o trauma, no
+borres el trasfondo autobiográfico específico convirtiéndolo en una etiqueta genérica de
+personalidad. Prefiere una estructura anclada que conserve:
+"Desencadenante/trasfondo -> respuesta emocional recurrente -> recurso de afrontamiento observado."
+Incluye solo desencadenantes, respuestas y recursos de afrontamiento presentes en evidencia
+propia del usuario (user-owned). Los consejos del asistente no son un recurso de afrontamiento observado del usuario.
+
+### Reglas
+- **Atómico**: Un patrón por Schema. Dos patrones distintos → dos Schemas.
+- **Inmutable**: Una vez creado, el contenido NUNCA cambia.
+- **Solo evidencia**: Los hechos nuevos que simplemente respaldan la redacción existente → llama a
+ `add_evidence`. Si la nueva evidencia cambia, corrige o acota sustancialmente el
+ estado duradero actual, usa `revise_schema` para que la versión antigua se conserve para
+ auditoría pero se retire de la recuperación activa.
+- **Ligado al dominio**: Mantente dentro del dominio observado. La abstracción entre dominios la gestiona un proceso del sistema aparte.
+- **Separa hechos de patrones**: Una única identidad explícita, estado de salud,
+ uso de equipamiento, afiliación, proyecto o preferencia pertenece a la memoria de estado L2,
+ no a L6. L6 requiere evidencia propia del usuario que represente al menos dos escrituras raw
+ o sesiones independientes. Un solo hecho L2 reconciliado puede representar varias escrituras;
+ revisa sus source_raw_memory_ids en lugar de contar nodos de hecho.
+- **Seguridad del sujeto**: Los hechos que comparten un fragmento de origen pueden describir a otras personas o
+ ejemplos. Crea un Schema del usuario solo cuando el material atribuya explícitamente
+ el patrón al usuario. De lo contrario, no emitas ninguna operación para ese material.
+- **Cobertura de candidatos**: En una revisión source-context, da cuenta de cada hecho
+ candidato listado: o lo usas como evidencia en `create_schema`/`add_evidence`,
+ o emites `skip_fact`. El contexto raw puede confirmar su sujeto o restaurar detalles
+ omitidos, pero no debe dar pie a Schemas no relacionados.
+- **Umbral de evidencia**: Crear un L6 requiere uno o más hechos de evidencia propios
+ del usuario que representen al menos dos escrituras raw o sesiones independientes.
+ Los consejos del asistente no establecen por sí solos un patrón del usuario.
+
+### Ejemplos buenos y malos
+✅ "Cuando cocina, el usuario sigue estrictamente los pasos de la receta y mide con precisión los ingredientes, lo que refleja una necesidad de estructura externa para gestionar la incertidumbre."
+✅ "Cuando juega a videojuegos, el usuario siempre consulta guías para lograr el 100% de compleción, impulsado por una baja tolerancia a lo incompleto."
+✅ "Tras la pérdida inesperada de un mentor, los recordatorios de la mortalidad pueden reavivar el duelo de repente; el usuario se detiene a reflexionar y da paseos tranquilos para recuperar la estabilidad."
+❌ "El usuario aborda la música como un medio de síntesis creativa y de construcción de puentes culturales, mezclando constantemente diversas tradiciones musicales..." (varios patrones fusionados, demasiado amplio)
+❌ "Al usuario le apasionan muchas cosas y valora la calidad." (sin circunstancia, demasiado vago)
+❌ "El usuario se guía por el sentido y es resiliente." (borra el desencadenante duradero y la evidencia de afrontamiento observada)
+
+## Tu flujo de trabajo
+
+Materiales de entrada (solo se te invoca cuando existe al menos un clúster):
+- **Resultados de clústeres**: Entrada principal: hechos agrupados por similitud semántica
+- **Hechos sin clúster (complementarios)**: Hechos que no están en ningún clúster; menor prioridad que los resultados de clústeres
+
+Para cada grupo de hechos (con o sin clúster):
+1. **Busca Schemas existentes**: Si un Schema existente ya recoge este patrón, llama a `add_evidence`. Usa `revise_schema` solo cuando la redacción antigua quedaría sustancialmente incompleta o resultaría engañosa tras añadir la nueva evidencia.
+2. **Crea un Schema nuevo**: Solo si ningún Schema existente cubre este patrón. Una frase, tres componentes.
+3. **Construye relaciones**: Si dos Schemas están relacionados temáticamente, usa `add_edge` (RELATED_TO).
+
+## Principios
+
+- Todas las operaciones sobre el Graph DEBEN pasar por las tools
+- El contenido de un Schema es INMUTABLE: nunca vuelvas a crear lo que ya existe
+- Prefiere `add_evidence` antes que crear duplicados
+- Prefiere no crear antes que crear nodos de baja calidad
+- Un Schema = un patrón atómico en un dominio
+- Al etiquetar, prefiere reutilizar las etiquetas de la lista de etiquetas existentes"""
+
+
+# ================================================================
+# Fragments assembled in code
+# ================================================================
+
+# Display name of this language, used in logs and docs.
+LANGUAGE_NAME = "Español"
+
+# 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, so their prompts stay exactly as before.
+OUTPUT_LANGUAGE_DIRECTIVE = """
+
+---
+
+# IDIOMA DE SALIDA
+
+Escribe en español todos los valores en lenguaje natural que generes (texto de las memorias, resúmenes, motivos, consultas), sea cual sea el idioma de la conversación o de las memorias existentes. Esta regla prevalece sobre cualquier regla anterior que indique igualar el idioma de entrada. Mantén exactamente como están las claves JSON, los nombres de campo, los valores de enumeración, los nombres de operación, los IDs, el código, las rutas de archivo, los comandos, los mensajes de error y los nombres propios.
+"""
+
+# 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"# DOS TIPOS DE MEMORIA.*?(?=\n# OWNER\n)"
+
+NO_INTENTION_MEMORY_SECTION = (
+ "# MEMORIA\n"
+ "\n"
+ "Extraes un solo tipo de memoria: **memory** (memorias).\n"
+ "\n"
+ "## memory\n"
+ "\n"
+ "Aquí va todo lo duradero y digno de recordar sobre el usuario, y sobre cualquier otra\n"
+ "persona con nombre que aparezca en la conversación:\n"
+ "\n"
+ "* preferencias, opiniones, valores, actitudes\n"
+ "* eventos, acciones, experiencias\n"
+ "* hábitos, patrones de comportamiento\n"
+ "* relaciones, rasgos\n"
+ "* hechos objetivos, decisiones, restricciones\n"
+ "* actividades en curso\n"
+ "* **planes futuros / acciones próximas** que merezca la pena recordar\n"
+ " (ponlos en `memory`; NO inventes un apartado de intentions separado)\n"
+ "\n"
+ "Las preferencias implícitas DEBEN inferirse cuando se sugieren con fuerza.\n"
+ "\n"
+ "NO separes \"qué tipo de persona es el usuario\" de \"qué sucedió\".\n"
+ "Ambas cosas van en `memory`.\n"
+ "\n"
+ "---\n"
+ "\n"
+)
+
+# (old, new) pairs applied in order after the section swap.
+NO_INTENTION_REPLACEMENTS = (
+ (
+ "Cada memoria e intención DEBE llevar un `owner`",
+ "Cada memoria DEBE llevar un `owner`",
+ ),
+)
+
+INTENTION_DISABLED_NOTE = (
+ "\n\n---\n\n# INTENCIONES DESACTIVADAS\n"
+ "La extracción de intenciones está desactivada. Aunque los ejemplos few-shot muestren "
+ "`intentions`, **no** emitas esa clave; pon los planes futuros en `memory`.\n"
+)
+
+# Coding / working extractor: wraps the history and the new messages.
+CODING_CONVERSATION_BLOCK = (
+ "ÚLTIMOS 5 TURNOS DEL USUARIO (SOLO CONTEXTO; no vuelvas a extraerlos):\n"
+ "{history}"
+ "\n\nMENSAJES NUEVOS (extrae solo de esta escritura completa):\n"
+ "{new}"
+)
+CODING_EMPTY_BLOCK = "(ninguno)"
+
+# 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 = "El usuario se llama {name}"
+
+# System 2 single-call mode: output contract appended to SYSTEM2_AGENT_PROMPT.
+SYSTEM2_OUTPUT_INSTRUCTIONS = """
+
+## Formato de salida
+
+NO llames a tools. Devuelve directamente un array JSON de operaciones, envuelto en un bloque de código ```json.
+
+Operaciones disponibles:
+
+1. **create_schema** — Crea un nuevo Schema de comportamiento L6
+ ```{"op": "create_schema", "schema_kind": "behavior_pattern", "content": "patrón conciso de cara al usuario", "retrieval_text": "comportamiento más las situaciones relevantes", "evidence_list": ["fact_node_id_1", "fact_node_id_2"], "tags": ["tag1"]}```
+
+2. **add_evidence** — Añade evidencia a un Schema existente (el contenido sigue siendo inmutable)
+ ```{"op": "add_evidence", "node_id": "existing_schema_node_id", "evidence_list": ["new_fact_id_1"]}```
+
+3. **revise_schema** — Crea una nueva versión cuando la nueva evidencia cambia sustancialmente el estado actual y retira la versión antigua de la recuperación activa. No la uses para detalles compatibles.
+ ```{"op": "revise_schema", "node_id": "old_schema_id", "schema_kind": "explicit_state", "content": "perfil actual actualizado", "retrieval_text": "texto de recuperación actualizado", "evidence_list": ["new_fact_id_1"], "tags": ["tag1"], "reason": "por qué la redacción antigua induciría a error"}```
+
+4. **add_edge** — Crea una relación entre dos Schemas
+ ```{"op": "add_edge", "source_id": "schema_id_1", "target_id": "schema_id_2", "reason": "motivo de la relación"}```
+
+5. **skip_fact** — Marca explícitamente un hecho candidato como revisado sin crear
+ un Schema. Úsalo solo para hechos sobre otra persona, eventos pasajeros, consejos del
+ asistente que no establecen un rasgo del usuario, o hechos ya cubiertos por completo.
+ ```{"op": "skip_fact", "node_id": "candidate_fact_id", "reason": "no es un patrón duradero del usuario"}```
+
+## Contrato de salida
+
+1. La salida DEBE ser un array JSON envuelto en un bloque de código ```json.
+2. Si los datos no bastan para obtener conclusiones fiables, devuelve `[]`. En una
+ revisión source-context, `[]` significa que se examinaron todos los candidatos de esa revisión
+ y ninguno respalda un Schema duradero.
+3. NINGÚN texto fuera del bloque de código.
+4. Los IDs de evidence_list deben proceder de los node_ids de hechos proporcionados en los materiales.
+5. El node_id de add_evidence / revise_schema debe proceder de IDs de nodos existentes del Graph.
+6. En una revisión source-context, cada hecho candidato debe aparecer en un evidence_list o en un skip_fact."""
+
+# Appended to SYSTEM2_OUTPUT_INSTRUCTIONS when the schema evidence gate is on.
+SYSTEM2_SCHEMA_EVIDENCE_GATE = """
+
+7. L6 representa solo patrones de comportamiento transversales a varios eventos. create_schema debe usar evidencia propia del usuario (user-owned) que represente al menos dos escrituras raw o sesiones independientes. Un único hecho reconciliado puede bastar cuando source_raw_memory_ids contiene varias escrituras independientes.
+8. No crees L6 para una única identidad explícita, estado de salud, uso de equipamiento, afiliación, proyecto o preferencia. Esos hechos los gestiona la proyección de estado canónica de 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
+# (or be harmless if it does not).
+SYSTEM2_SINGLE_CALL_REPLACEMENTS = (
+ ("- Todas las operaciones sobre el Graph DEBEN pasar por las tools\n", ""),
+ ("llama a `add_evidence`", "usa la operación add_evidence"),
+ ("usa `add_edge` (RELATED_TO)", "usa la operación add_edge"),
+)
+
+# System 2 user message (materials). Keys are fixed; values are format
+# strings with the named fields shown.
+SYSTEM2_MATERIALS = {
+ "title": "## Materiales preprocesados\n",
+ "stats": (
+ "### Estadísticas\n- Total de hechos en la VDB: {total}\n"
+ "- Hechos nuevos (por procesar): {fresh} (excluidos_con_evidencia={evidenced})\n"
+ "- Clústeres encontrados: {clusters}\n"
+ "- Hechos en clústeres: {clustered}, complemento sin clúster: {unclustered}\n"
+ "- Total de Schemas en el Graph: {graph_total} (recuperados={recalled})"
+ ),
+ "graph_status_empty": "- Estado del Graph: **VACÍO** (primera ejecución de procesamiento cognitivo)\n",
+ "clusters_header": "### Resultados de clústeres\n",
+ "label_holistic": "{n} hechos del usuario de varias sesiones; solo patrones emocionales/terapéuticos duraderos respaldados por evidencia",
+ "label_source_context": "{n} hechos candidatos; la escritura raw solo sirve para validar el sujeto/los detalles",
+ "label_topic": "{n} hechos, tema",
+ "raw_label": "Fragmento raw relevante por candidato",
+ "holistic_note": (
+ "Esta es una pasada nocturna de consolidación holística acotada. Crea como máximo "
+ "{max_schemas} Schemas terapéuticos anclados. "
+ "Prefiere unir desencadenante/trasfondo duradero, respuesta emocional recurrente "
+ "y recurso de afrontamiento observado o restricción de decisión a través de distintas escrituras raw/sesiones. "
+ "Antes de create_schema, une los raw_sources de sus IDs de evidencia y exige al menos dos "
+ "IDs de fuente raw distintos; dos hechos de una misma escritura raw son un solo evento. "
+ "Devuelve [] cuando la evidencia sea insuficiente.\n"
+ ),
+ "companion_header": "**Pistas complementarias de fuentes independientes (candidatos, no conclusiones):**",
+ "unclustered_header": "### Hechos sin clúster (complementarios)\n",
+ "unclustered_hint": "Los hechos de abajo no se agruparon en ningún clúster anterior. Revísalos después de los temas de los clústeres; tienen menor prioridad que los resultados de clústeres.\n",
+ "forward_header": "### Nodos del Graph relacionados (recuperados mediante búsqueda por centroide de clúster, {count} resultados)\n",
+ "graph_empty": "### Nodos existentes del Graph\nEl Graph está VACÍO actualmente: esta es la primera ejecución de procesamiento cognitivo. NO busques en el Graph (no devolverá nada). Pasa directamente a crear Schemas a partir de los resultados de clústeres.\n",
+ "graph_no_recall": (
+ "### Nodos existentes del Graph\n"
+ "El Graph tiene {graph_total} Schemas, "
+ "pero la recuperación vectorial basada en centroides no encontró coincidencias. Decide, a partir de los resultados de clústeres, si se necesitan Schemas nuevos.\n"
+ ),
+ "reverse_header": "### Referencias inversas del Graph (hechos de la VDB referenciados por Schemas existentes)\n",
+ "tags_header": "### Etiquetas existentes (prefiere reutilizarlas antes que crear sinónimos)\n",
+ "closing": (
+ "Analiza los materiales anteriores y devuelve un array JSON de operaciones. "
+ "Decide si crear Schemas nuevos o añadir evidencia a los existentes. "
+ "Si los datos no bastan para obtener conclusiones fiables, devuelve un array vacío `[]`. "
+ "Al etiquetar, prefiere reutilizar las etiquetas de la lista de etiquetas existentes anterior."
+ ),
+}
diff --git a/hy_memory/prompts/fr.py b/hy_memory/prompts/fr.py
new file mode 100644
index 0000000..fc223eb
--- /dev/null
+++ b/hy_memory/prompts/fr.py
@@ -0,0 +1,2310 @@
+# -*- coding: utf-8 -*-
+"""French prompts (``fr``).
+
+Translated from en.py; native-speaker review recommended.
+"""
+
+
+# ================================================================
+# Chat extraction (agent/extractor.py)
+# ================================================================
+
+EXTRACT_SYSTEM_PROMPT = """# RÔLE
+
+Tu es un extracteur de mémoire (Memory Extractor).
+
+Extrais des conversations des souvenirs durables et à forte valeur, et convertis-les en énoncés structurés et autonomes.
+
+N'extrais que les informations susceptibles de compter dans les conversations futures.
+
+---
+
+# ENTRÉES
+
+Tu recevras :
+
+* Last k Messages (les k derniers messages)
+* New Messages (les nouveaux messages)
+* Memory Date
+* Current Date
+
+Utilise :
+
+* les Last k Messages uniquement pour la résolution des coréférences
+* la Memory Date comme SEUL ancrage temporel
+* la Current Date uniquement comme métadonnée, jamais pour résoudre un temps relatif
+
+---
+
+# CE QU'IL FAUT EXTRAIRE
+
+Extrais UNIQUEMENT les informations réellement nouvelles apportées par les NOUVEAUX messages de l'utilisateur.
+
+Les bons souvenirs incluent :
+
+* les préférences
+* les projets de long terme
+* les habitudes
+* les objectifs
+* les activités récurrentes
+* les opinions
+* les relations
+* les expériences importantes
+* les traits stables
+* les projets futurs
+* les décisions
+* les contraintes
+* les recommandations acceptées
+
+N'extrais PAS :
+
+* les bavardages
+* les simples accusés de réception
+* les émotions génériques
+* le contexte conversationnel temporaire
+* les rappels d'anciens souvenirs faits par l'assistant
+* les informations déjà impliquées par le contexte antérieur
+* les jugements de personnalité vagues
+
+---
+
+# SUJET
+
+Chaque souvenir doit être autonome, rédigé à la troisième personne, avec un sujet
+explicite. Le sujet à utiliser est déterminé par **qui a parlé** :
+
+| Locuteur | Sujet à écrire | Exemple |
+| --- | --- | --- |
+| `role: "user"` | l'utilisateur | "L'utilisateur ..." / "The user ..." |
+| tout locuteur ayant un `name` autre que l'utilisateur (p. ex. `name: "John"`) | cette personne, par son nom | "John ..." |
+| `role: "assistant"` SANS `name` | l'assistant IA | "L'assistant ..." |
+
+Les deux sections d'entrée expriment le locuteur différemment :
+
+* **New Messages** est un tableau JSON — lis `role` et le champ facultatif `name`.
+* **Last k Messages** est un texte rendu — le locuteur est l'étiquette entre crochets,
+ `[user]:` / `[John]:` / `[assistant]:`, éventuellement précédée d'une ligne
+ "Le nom de l'utilisateur est Tim" / "The user's name is Tim".
+
+Règles :
+
+* L'utilisateur est la personne à qui appartiennent ces souvenirs. Même lorsque le
+ nom de l'utilisateur est connu (par le `name` de son message ou par la ligne de nom
+ en tête), écris quand même "L'utilisateur ...", JAMAIS "Tim ...".
+* **Un `role: "assistant"` AVEC un `name` est une autre personne réelle, pas l'IA.**
+ Rédige ses souvenirs avec son nom comme sujet : "John ...".
+* Seul un `role: "assistant"` sans nom est l'assistant IA.
+* N'invente jamais de nom pour l'assistant IA, il n'en a pas.
+
+---
+
+# RÈGLES DE LANGUE
+
+* La langue de sortie doit correspondre à la langue d'entrée.
+* Conserve exactement les écritures d'origine et les termes techniques.
+* Ne translittère jamais les noms, les marques ou les équations.
+
+---
+
+# DEUX TYPES DE MÉMOIRE
+
+Tu extrais deux types de mémoire : **memory** (souvenirs) et **intentions**.
+
+## memory
+
+Tout ce qui est durable et mérite d'être retenu au sujet de l'utilisateur — et de
+toute autre personne nommée dans la conversation — va ici :
+
+* préférences, opinions, valeurs, attitudes
+* événements, actions, expériences
+* habitudes, motifs de comportement
+* relations, traits
+* faits objectifs, décisions, contraintes
+* activités en cours
+
+Les préférences implicites DOIVENT être inférées lorsqu'elles sont fortement suggérées
+(p. ex. reprendre une activité → intérêt positif ; éviter quelque chose →
+préférence négative ; effort volontaire répété → intérêt durable).
+
+Ne sépare PAS « quel genre de personne est l'utilisateur » de « ce qui s'est passé ».
+Les deux vont dans `memory`.
+
+## intentions
+
+Une chose tournée vers l'avenir que l'utilisateur **prévoit ou a l'intention de faire**,
+sur laquelle on peut agir et qui perd sa pertinence une fois réalisée ou passée.
+
+Exemples :
+
+* "L'utilisateur a un entretien d'embauche mardi prochain."
+* "L'utilisateur prévoit de déménager à la fin du mois."
+* "L'utilisateur a l'intention de terminer le rapport avant vendredi."
+
+Ce ne sont PAS des intentions (elles vont dans `memory`) :
+
+* préférences / traits stables ("L'utilisateur aime le basket")
+* événements passés terminés ("L'utilisateur a déménagé à Pékin l'an dernier")
+* objectifs généraux sans étape future concrète
+
+### valid_until
+
+Pour chaque intention, fournis `valid_until` : la date après laquelle
+l'intention n'a plus d'importance (l'échéance / la date cible), résolue
+par rapport à la **Memory Date** (p. ex. « mardi prochain » → cette date absolue).
+Si aucune échéance ne peut être déterminée, mets `valid_until` à `null`.
+
+---
+
+# OWNER (APPARTENANCE)
+
+Chaque souvenir et chaque intention DOIT porter un `owner` indiquant à quelle base de mémoire
+il appartient. Il y a exactement deux valeurs :
+
+* `"user"` — tout ce qui appartient à la propre base de mémoire de l'utilisateur. Cela inclut
+ les faits/préférences/traits concernant l'utilisateur lui-même, ET les faits concernant d'autres
+ personnes réelles nommées dans la conversation, car ce sont toujours des choses que la
+ mémoire de l'utilisateur doit contenir.
+* `"agent"` — les informations fournies par l'assistant IA (un `role: "assistant"` sans nom)
+ (recommandations, confirmations, choses qu'il a recherchées), ou une action future
+ que l'utilisateur veut que l'**assistant** accomplisse (« rappelle-moi dans 8 heures »).
+
+Une personne nommée n'est JAMAIS `owner: "agent"` — c'est une personne réelle, pas l'IA,
+même si ses messages portent `role: "assistant"`. Ses souvenirs sont
+`owner: "user"` avec son nom comme sujet du contenu.
+
+Décide de l'`owner` élément par élément. En cas de doute, utilise `"user"` par défaut.
+
+---
+
+# RÈGLES TEMPORELLES
+
+Résous les temps relatifs à l'aide de la Memory Date.
+
+Exemples :
+
+* « la semaine prochaine »
+* « le mois dernier »
+* « demain »
+
+Si le temps ne peut pas être résolu de façon sûre :
+
+* supprime la formulation relative
+* garde le souvenir intemporel
+
+N'invente pas de chronologie.
+
+**Les événements qui viennent de se produire sont des événements — garde-les.** Quand l'utilisateur
+rapporte quelque chose comme tout juste terminé (« je viens de rentrer », « je viens de finir », « ce matin », « hier »), la
+date d'achèvement est la Memory Date. Émets **l'événement lui-même** avec cette date ; ne le
+fonds pas dans un énoncé de contexte général.
+
+* « Je viens de rentrer d'un voyage en famille »
+ → "L'utilisateur est rentré d'un voyage en famille le <Memory Date>."
+ PAS → "L'utilisateur fait des voyages en famille." (la date de retour est la réponse à « quand
+ est-il rentré », et l'omettre rend la question sans réponse)
+
+Lorsqu'un événement a un début et une fin que la conversation donne séparément,
+enregistre les deux plutôt que de les fusionner en une seule période.
+
+---
+
+# RÈGLES DE QUALITÉ
+
+Chaque souvenir doit être :
+
+* autonome
+* complet sur le plan contextuel
+* facile à retrouver
+* dense en informations
+
+Conserve les détails importants :
+
+* noms
+* produits
+* lieux
+* nombres
+* équations
+* contraintes
+
+Ne généralise jamais un élément précis en catégorie. Écris ce qui a réellement été dit.
+
+* « Banff » → garde « Banff », PAS « les Rocheuses »
+* « un border collie de 3 ans nommé Luna » → garde la race, l'âge et le nom
+
+**Les précisions apportées par l'autre locuteur comptent aussi.** Un fait se construit souvent sur
+plusieurs tours : l'autre locuteur nomme la chose, l'utilisateur la confirme. Les règles de sujet
+décident *à qui* appartient le souvenir — elles n'autorisent pas à abandonner des détails.
+
+* [Sam]: « Tu as profité des possibilités de ski à Banff ? »
+ [user]: « Oui, c'était génial pour skier ! »
+ → "L'utilisateur a skié à Banff et a trouvé la neige incroyable."
+ PAS → "L'utilisateur aime les sports d'hiver." (le lieu et l'activité ont tous deux été
+ établis, chacun par un locuteur)
+
+Évite les souvenirs fragmentaires sans contexte.
+
+Choisis le plus petit nombre de souvenirs qui préserve encore les différents besoins
+de recherche futurs.
+
+* Compresser signifie combiner, pas omettre. Chaque proposition durable explicite
+ des nouveaux messages doit apparaître exactement une fois dans la sortie.
+* Combine les détails lorsqu'ils partagent le même sujet et le même événement réel,
+ état, préférence, projet ou décision. Un événement cohérent peut tenir en 1 à 3 phrases.
+* N'émets pas à la fois un énoncé général et des reformulations plus étroites des mêmes éléments.
+* Sépare uniquement lorsque le sujet diffère, que les événements se sont produits indépendamment, ou que
+ les souvenirs décrivent des états différents.
+* Garde une cause, une recommandation ou une conséquence avec le fait qu'elle explique lorsque
+ les séparer ferait perdre la relation.
+* Ne fusionne jamais des occurrences datées distinctes simplement parce qu'elles partagent un thème.
+* Préserve la précision temporelle de la source. Ne transforme pas des expressions vagues comme « le
+ week-end dernier » ou « l'été dernier » en dates calendaires exactes, sauf si la date est explicite
+ ou déterminée de manière unique ; « le week-end précédant la <Memory Date> » est acceptable.
+
+---
+
+# TAGS
+
+Chaque souvenir doit inclure 1 à 3 tags concis.
+- Les mots-clés thématiques restent en minuscules et en anglais (travel, health, work).
+- Les noms propres gardent leurs majuscules (Jasper, Canada, Banff, Prius).
+
+Exemples :
+
+* work
+* travel
+* Jasper
+* Canada
+* health
+
+---
+"""
+
+STRUCTURE_METADATA_PROMPT = """
+
+---
+
+# ORGANISATION STRUCTURELLE
+
+Pour chaque `memory`, produis aussi :
+
+* `topic_paths` : une liste rétrocompatible de zéro à trois chemins sémantiques
+ allant du général au particulier.
+* `event_facet` : un objet contenant uniquement `subject`, `participants`, `action`,
+ `objects`, `locations` et `state` ; state vaut `planned`, `ongoing`,
+ `completed` ou `unknown`.
+* `topic_assignments` : de zéro à six appartenances propres à un sujet. Chaque élément est
+ `{subject, role, path}`, où `path` est une liste de segments `{name, type}` et
+ `type` est l'un de `topic`, `facet`, `series` ou `episode`. Utilise `topic` pour un
+ domaine large, `facet` pour une activité concrète / un aspect sémantique, `series` uniquement
+ pour des occurrences répétées d'une même ligne concrète d'activité/d'état, et
+ `episode` uniquement pour une occurrence réelle unique et délimitée. Un événement partagé peut avoir
+ une appartenance par participant explicite tout en conservant un seul souvenir canonique.
+ Les types suivent `topic -> facet -> series -> episode` ; des niveaux peuvent être sautés, mais
+ les types ne peuvent ni se répéter ni revenir en arrière.
+
+Cet extracteur ne voit que l'écriture en cours et ne doit donc pas émettre de
+segment `series`. Émets ici Topic/Facet/Episode. La réconciliation pourra ensuite établir une
+Series après avoir comparé des occurrences stockées indépendantes.
+
+Il s'agit d'une organisation au moment de l'écriture. N'infère pas Series/Episode à partir de la profondeur du chemin,
+ne fabrique pas de hiérarchie à partir d'un nom propre ou d'un tag large, et n'assigne pas une personne uniquement
+parce qu'elle apparaît dans un contexte sans rapport. Arrête-toi au niveau le plus spécifique étayé
+et utilise des valeurs vides en cas de doute. N'encode jamais de formes de requête telles que
+« quand », « combien », « qui », le pluriel ou les formulations ordinales.
+"""
+
+EXTRACT_FEW_SHOT = """
+---
+
+# EXEMPLES
+
+## Exemple 1 — Limite : l'ancien contexte sert uniquement à la résolution, il n'est jamais ré-extrait
+
+Last k Messages:
+[{"role": "user", "content": "Je regarde des chiens à adopter au refuge du centre-ville."},
+ {"role": "assistant", "content": "C'est adorable — tu en as trouvé un qui te plaît ?"}]
+New Messages:
+[{"role": "user", "content": "Oui, je suis allé la chercher hier — une border collie de 3 ans qui s'appelle Luna."}]
+Memory Date: 2025-04-10
+
+Sortie :
+```json
+{
+ "memory": [
+ {"content": "L'utilisateur a adopté le 2025-04-09 une border collie de 3 ans nommée Luna, venant d'un refuge du centre-ville.", "tags": ["pets", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Les anciens messages servent seulement à résoudre « la » et à fournir du contexte (« refuge du centre-ville »). N'émets PAS un souvenir périmé du type « l'utilisateur envisage d'adopter un chien » — seul le fait réellement nouveau (l'adoption réalisée) est extrait, avec « hier » résolu par rapport à la Memory Date.
+
+## Exemple 2 — Condenser une longue réponse de l'assistant
+
+New Messages:
+[{"role": "user", "content": "Écris-moi un court essai expliquant pourquoi le télétravail augmente la productivité."},
+ {"role": "assistant", "content": "Bien sûr — introduction : « Le télétravail a transformé le fonctionnement des équipes... » [~2000 mots de développement omis] ...conclusion : « En somme, l'autonomie et la réduction des interruptions entraînent une production plus élevée. »"}]
+Memory Date: 2025-03-22
+
+Sortie :
+```json
+{
+ "memory": [
+ {"content": "L'assistant a rédigé pour l'utilisateur un court essai soutenant que le télétravail augmente la productivité, car l'autonomie et la réduction des interruptions entraînent une production plus élevée.", "tags": ["writing", "remote-work"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+La réponse de l'assistant est longue. Ne stocke jamais l'essai mot pour mot — réduis-le au sujet + thèse. owner vaut "agent" parce que c'est l'assistant qui l'a produit. Un contenu verbatim gonflé rend la mémoire inutilisable.
+
+## Exemple 3 — Extraction composite : basic_info + intention + plan de l'agent condensé
+
+New Messages:
+[{"role": "user", "content": "Salut, je suis Kenji. Je prévois un voyage au Japon le mois prochain — tu pourrais me préparer un itinéraire de 7 jours ?"},
+ {"role": "assistant", "content": "# Itinéraire classique de 7 jours sur la Route d'or du Japon (Tokyo → Kyoto → Nara → Osaka)\\nArrivée à Tokyo, Shinkansen vers le sud jusqu'à Kyoto, excursion d'une journée à Nara, départ d'Osaka (Kansai).\\n\\n## Jour 1 : Arrivée à Tokyo\\n- Atterrissage à Haneda/Narita, dépôt des bagages à l'hôtel près de la gare de Tokyo.\\n- Fin d'après-midi : temple Sensoji (Asakusa), balade dans la rue Nakamise, goûter des taiyaki.\\n- Soirée : carrefour de Shibuya + toit-terrasse Shibuya Sky pour le coucher de soleil ; dîner en izakaya (yakitori, saké).\\n\\n## Jour 2 : Marchés et monuments de Tokyo — [omis]\\n## Jour 3 : Shinkansen vers Kyoto, Fushimi Inari, Gion — [omis]\\n## Jour 4 : Temples de Kyoto (Kiyomizu-dera, Kinkaku-ji, Ginkaku-ji) — [omis]\\n## Jour 5 : Excursion à Nara (cerfs du parc de Nara, Todai-ji) — [omis]\\n## Jour 6 : Osaka (château d'Osaka, street food de Dotonbori) — [omis]\\n## Jour 7 : Visites à Osaka + départ de l'aéroport du Kansai — [omis]\\n\\nConseil : achète un JR Pass de 7 jours avant d'arriver. Tu veux que j'ajuste quelque chose ?"}]
+Memory Date: 2025-09-15
+
+Sortie :
+```json
+{
+ "memory": [
+ {"content": "L'assistant a créé pour l'utilisateur un itinéraire de 7 jours au Japon sur la Route d'or classique : Tokyo (Asakusa, Shibuya), Shinkansen jusqu'à Kyoto (Fushimi Inari, Kiyomizu-dera, Kinkaku-ji, Gion), une excursion à Nara (parc aux cerfs, Todai-ji), puis Osaka (château d'Osaka, Dotonbori), avec départ de l'aéroport du Kansai.", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
+ ],
+ "intentions": [
+ {"content": "L'utilisateur prévoit un voyage de 7 jours au Japon en octobre 2025.", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
+ ],
+ "basic_info": {"name": "Kenji"}
+}
+```
+Un seul tour produit trois sorties dans des catégories différentes : le nom va dans basic_info, le voyage est une intention tournée vers l'avenir avec une échéance, et le long itinéraire en plusieurs sections de l'assistant est condensé en UN seul souvenir d'agent dense — l'itinéraire et les étapes clés par ville, PAS les puces de chaque jour, les conseils ou les listes de plats. Stocker toute la réponse mot pour mot gonflerait la mémoire ; stocker le squelette la garde interrogeable.
+
+## Exemple 4 — Un message ultérieur qui confirme/adopte une recommandation antérieure est lui-même un fait
+
+New Messages:
+[{"role": "user", "content": "Mon enfant de 6 ans refuse de manger le moindre légume. Des idées ?"},
+ {"role": "assistant", "content": "Essaie de mixer des épinards ou des carottes dans la sauce des pâtes — la couleur et le goût disparaissent presque, et beaucoup d'enfants l'acceptent sans s'en rendre compte."},
+ {"role": "user", "content": "Oh, bonne idée, on essaie ce soir. Au fait, quelle est une bonne heure de coucher à cet âge ?"},
+ {"role": "assistant", "content": "Pour un enfant de 6 ans, vise un coucher entre 19 h et 21 h avec environ 10 à 11 heures de sommeil."}]
+Memory Date: 2025-06-20
+
+Sortie :
+```json
+{
+ "memory": [
+ {"content": "L'utilisateur a un enfant de 6 ans qui refuse de manger des légumes, et a accepté la suggestion de l'assistant de mixer des épinards ou des carottes dans la sauce des pâtes pour les cacher.", "tags": ["parenting", "food"], "owner": "user"},
+ {"content": "L'assistant a conseillé à l'utilisateur qu'un enfant de 6 ans devrait se coucher entre 19 h et 21 h avec environ 10 à 11 heures de sommeil.", "tags": ["parenting", "sleep"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Dans le troisième message, l'utilisateur a dit « on essaie ce soir » — il adopte explicitement la suggestion précédente. Cette acceptation a de la valeur et doit être enregistrée (« a accepté la suggestion de l'assistant de ... »), et non écartée comme du bavardage. Le conseil sur l'heure du coucher vient d'être donné et n'est pas encore adopté, il est donc enregistré comme un conseil (owner "agent").
+
+## Exemple 5 — Contexte RAG/injecté : ne stocke jamais le texte injecté
+
+New Messages:
+[{"role": "user", "content": "[Contexte récupéré : La tour Eiffel mesure 330 m et a été achevée en 1889.] Compte tenu de ce qui précède, je vais demander ma copine en mariage au sommet de la tour Eiffel cet été."}]
+Memory Date: 2025-05-02
+
+Sortie :
+```json
+{
+ "memory": [],
+ "intentions": [
+ {"content": "L'utilisateur prévoit de demander sa copine en mariage au sommet de la tour Eiffel à l'été 2025.", "tags": ["relationship", "travel"], "valid_until": "2025-08-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+Le contexte récupéré entre crochets (la hauteur de la tour et l'année) est du matériel de référence injecté par RAG, PAS quelque chose que l'utilisateur nous a dit sur lui-même — ne le stocke PAS. Seul le projet de l'utilisateur, tourné vers l'avenir, est extrait. Le texte injecté par le système/RAG est du contexte pour le modèle, jamais un souvenir.
+
+## Exemple 6 — Matériel de référence partagé : extrais le contenu, pas l'action de partager
+
+New Messages:
+[{"role": "user", "content": "Retiens la recette de raviolis de ma grand-mère pour que je ne la perde pas. Farce : 500 g de porc haché, 300 g de chou chinois, 2 c. à s. de sauce soja, 1 c. à s. d'huile de sésame, un pouce de gingembre émincé. Chou salé 15 min puis bien essoré. Faire bouillir les raviolis, ajouter deux fois de l'eau froide, c'est prêt quand ils flottent."},
+ {"role": "assistant", "content": "C'est noté, enregistré !"}]
+Memory Date: 2025-07-01
+
+Sortie :
+```json
+{
+ "memory": [
+ {"content": "La recette de raviolis de la grand-mère de l'utilisateur : farce de 500 g de porc haché, 300 g de chou chinois (salé 15 minutes puis bien essoré), 2 c. à s. de sauce soja, 1 c. à s. d'huile de sésame et un pouce de gingembre émincé ; faire bouillir les raviolis, ajouter deux fois de l'eau froide, ils sont prêts quand ils flottent.", "tags": ["food", "recipe", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Extrais le contenu factuel réel (ingrédients, quantités, l'étape de salage et d'essorage, la méthode de cuisson) — PAS « l'utilisateur a partagé une recette » ni « l'utilisateur a demandé de retenir la recette ». L'action de partager n'a aucune valeur ; c'est le contenu qui est interrogeable.
+
+## Exemple 7 — Nombres et attributs structurés conservés exactement
+
+New Messages:
+[{"role": "user", "content": "Je note mes records de salle à la maison pour ce cycle : Squat 140kg x 3, Bench 100kg x 5, Deadlift 180kg x 2, Overhead Press 60kg x 6. Poids de corps 78kg, 3 séries par mouvement, 3 min de repos."},
+ {"role": "assistant", "content": "C'est noté — de beaux chiffres !"}]
+Memory Date: 2026-01-20
+
+Sortie :
+```json
+{
+ "memory": [
+ {"content": "Les records actuels de musculation de l'utilisateur sont Squat 140kg x 3, Bench 100kg x 5, Deadlift 180kg x 2 et Overhead Press 60kg x 6, pour un poids de corps de 78kg.", "tags": ["fitness", "strength"], "owner": "user"},
+ {"content": "L'utilisateur s'entraîne avec 3 séries par mouvement et 3 minutes de repos entre les séries.", "tags": ["fitness", "training"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Chaque nombre et chaque unité (kg, répétitions, séries, temps de repos) est conservé exactement — les omettre détruirait l'information la plus interrogeable. Sépare en deux thèmes propres (records vs. protocole d'entraînement), mais n'arrondis ni n'omets jamais les détails.
+
+## Exemple 8 — Longue conversation multi-thèmes : ne t'arrête pas après le premier thème
+
+New Messages:
+[{"role": "user", "content": "Grosse semaine — j'ai enfin soutenu ma thèse de doctorat mardi !"},
+ {"role": "assistant", "content": "Félicitations ! Comment tu te sens ?"},
+ {"role": "user", "content": "Soulagé ! J'ai aussi signé le bail d'un appartement à Berlin et je déménage le mois prochain. Et j'ai commencé à apprendre l'allemand sur Duolingo — série de 30 jours. Ma compagne Sofia reste à Madrid pour l'instant, c'est dur."}]
+Memory Date: 2025-11-08
+
+Sortie :
+```json
+{
+ "memory": [
+ {"content": "L'utilisateur a soutenu sa thèse de doctorat le 2025-11-04.", "tags": ["education", "milestone"], "owner": "user"},
+ {"content": "L'utilisateur a signé le bail d'un appartement à Berlin.", "tags": ["housing"], "owner": "user"},
+ {"content": "L'utilisateur apprend l'allemand sur Duolingo et a une série de 30 jours.", "tags": ["language", "learning"], "owner": "user"},
+ {"content": "La compagne de l'utilisateur, Sofia, reste à Madrid pour l'instant, ce que l'utilisateur trouve difficile.", "tags": ["relationship"], "owner": "user"}
+ ],
+ "intentions": [
+ {"content": "L'utilisateur prévoit de déménager à Berlin le mois prochain (vers décembre 2025).", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+Quatre thèmes ou plus — la soutenance de thèse, l'appartement à Berlin, l'apprentissage de l'allemand et la compagne à Madrid. Ne t'arrête pas après le premier thème. Note qu'un même tour se divise en un fait accompli (bail signé) ET une intention (le déménagement à venir), et que le détail émotionnel mais substantiel sur Sofia est conservé car il porte un contexte relationnel durable.
+
+## Exemple 9 — Deux personnes réelles : un `name` sur un message assistant désigne une personne réelle
+
+New Messages:
+[{"role": "user", "name": "Tim", "content": "Je reviens de la salle d'escalade, troisième fois cette semaine. J'ai enfin enchaîné cette voie en dévers."},
+ {"role": "assistant", "name": "John", "content": "Bravo ! Moi je fais plutôt de la natation — mon épaule me fait encore mal depuis le mois dernier."}]
+Memory Date: 2025-08-14
+
+Sortie :
+```json
+{
+ "memory": [
+ {"content": "L'utilisateur grimpe trois fois par semaine et a récemment réussi une voie difficile en dévers.", "tags": ["fitness", "climbing"], "owner": "user"},
+ {"content": "John fait de la natation plutôt que d'autres exercices car son épaule lui fait encore mal après une blessure vers juillet 2025.", "tags": ["fitness", "health"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {"name": "Tim"}
+}
+```
+John porte `role: "assistant"` mais il a un `name`, c'est donc une autre personne réelle, PAS l'IA : son souvenir utilise « John ... » comme sujet et reste `owner: "user"` (il appartient à la base de mémoire de l'utilisateur). Le souvenir propre à l'utilisateur reste « L'utilisateur ... » même si nous savons qu'il s'appelle Tim — jamais « Tim grimpe ». `basic_info.name` provient de `name: "Tim"` sur le message de l'utilisateur, qui fait autorité même si Tim n'a jamais dit son nom à voix haute.
+
+## Exemple 10 — Contre-exemple : les attributs d'une autre personne ne vont jamais dans 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
+
+Sortie :
+```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"}
+}
+```
+La profession et le lieu de John sont SES attributs, ils vont donc dans `memory` avec « John » comme sujet. Ils ne doivent JAMAIS atterrir dans `basic_info.occupation` / `basic_info.location` — `basic_info` est exclusivement le profil propre de l'utilisateur. Seul `name` (Tim, issu du champ `name` du message de l'utilisateur) y a sa place. Note que la langue de sortie suit la langue d'entrée (cet exemple est en anglais).
+
+## Exemple 11 — Contre-exemple : le bavardage n'a pas de basic_info
+
+New Messages:
+[{"role": "user", "content": "Salut"},
+ {"role": "assistant", "content": "Bonjour ! Le nom de l'utilisateur est L'utilisateur. Comment puis-je t'aider ?"}]
+Memory Date: 2025-09-03
+
+Sortie :
+```json
+{
+ "memory": [],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+L'utilisateur n'a rien dit sur lui-même. La réplique de l'assistant n'est pas un tour de l'utilisateur, et « L'utilisateur » est un espace réservé, pas un nom. Produis `{}` — jamais `{"name": "L'utilisateur"}` ni `{"name": "user"}`.
+
+---
+"""
+
+EXTRACT_PROMPT = """## Last k Messages
+
+{last_messages}
+
+---
+
+## New Messages
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Format de sortie
+
+Renvoie UNIQUEMENT un objet JSON dans un bloc délimité ```json.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "intentions": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "valid_until": "YYYY-MM-DD",
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Règles :
+
+* `memory` = informations durables qui méritent d'être retenues : préférences, opinions, attitudes,
+ traits, événements, projets, expériences, habitudes, décisions — sur l'utilisateur ou
+ sur toute autre personne réelle nommée, avec le sujet rédigé selon « # SUJET »
+* `intentions` = choses tournées vers l'avenir que l'utilisateur (ou une autre personne nommée) prévoit /
+ a l'intention de faire, avec `valid_until` = l'échéance/la date cible
+ (résolue par rapport à la Memory Date) ou `null` s'il n'y en a pas
+* `owner` (obligatoire sur chaque souvenir et chaque intention) = `"user"` ou `"agent"`
+ (voir « # OWNER » ci-dessus ; `"user"` par défaut en cas de doute)
+* `basic_info` = **uniquement le profil propre de l'utilisateur**. Inclus les champs de profil
+ stables (p. ex. nom, âge, lieu de résidence, profession, employeur) **explicitement énoncés**
+ dans les NOUVEAUX messages de l'utilisateur. N'infère jamais, n'invente jamais. Si aucun champ n'est explicitement
+ énoncé, produis `{{}}`.
+ * RÈGLE STRICTE : remplis un champ UNIQUEMENT si l'utilisateur l'a énoncé dans un tour `user`.
+ Tout ce qui n'est dit que par l'assistant (y compris lorsque l'assistant cite un
+ souvenir antérieur comme "The user's name is X" / "Le nom de l'utilisateur est X") ne compte PAS. Si rien
+ ne remplit les conditions, produis `"basic_info": {{}}`.
+ * N'écris JAMAIS le nom du champ lui-même ou un espace réservé comme valeur ("user",
+ "The user", "l'utilisateur", "用户", "name", "nom", "N/A", "unknown", "inconnu", "none", "-"). Omets le champ.
+ * Contre-exemple : du bavardage comme `[user]: Salut` / `[assistant]: Comment puis-je
+ t'aider ?`, ou `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
+ * Exception pour `name` : le champ `name` du propre message de l'utilisateur, ou une ligne
+ en tête "Le nom de l'utilisateur est X" / "The user's name is X" / "用户名叫X", est une source faisant autorité pour
+ `name` — même si l'utilisateur ne l'a jamais dit à voix haute.
+ * Ne mets JAMAIS ici les attributs d'une autre personne réelle. Si John (un message de rôle assistant
+ portant un `name`) dit « Je suis infirmier à Berlin », c'est un `memory`
+ ("John est infirmier à Berlin."), PAS `basic_info.occupation` / `.location`.
+* Aucune information dupliquée entre les sections
+* Les tags doivent contenir 1 à 3 mots-clés concis en minuscules
+* Utilise des tableaux vides `[]` ou `{{}}` lorsque rien n'est extrait
+* Renvoie uniquement du JSON valide
+
+Produis le JSON maintenant."""
+
+EXTRACT_PROMPT_NO_INTENTION = """## Last k Messages
+
+{last_messages}
+
+---
+
+## New Messages
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Format de sortie
+
+Renvoie UNIQUEMENT un objet JSON dans un bloc délimité ```json.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Règles :
+
+* `memory` = informations durables qui méritent d'être retenues : préférences, opinions, attitudes,
+ traits, événements, expériences, habitudes, décisions, **ainsi que les projets futurs / actions
+ à venir** — sur l'utilisateur ou sur toute autre personne réelle nommée, avec le
+ sujet rédigé selon « # SUJET ». N'invente **pas** de catégorie intentions séparée.
+* `owner` (obligatoire sur chaque souvenir) = `"user"` ou `"agent"`
+ (voir « # OWNER » ci-dessus ; `"user"` par défaut en cas de doute)
+* `basic_info` = **uniquement le profil propre de l'utilisateur**. Inclus les champs de profil
+ stables (p. ex. nom, âge, lieu de résidence, profession, employeur) **explicitement énoncés**
+ dans les NOUVEAUX messages de l'utilisateur. N'infère jamais, n'invente jamais. Si aucun champ n'est explicitement
+ énoncé, produis `{{}}`.
+ * RÈGLE STRICTE : remplis un champ UNIQUEMENT si l'utilisateur l'a énoncé dans un tour `user`.
+ Tout ce qui n'est dit que par l'assistant (y compris lorsque l'assistant cite un
+ souvenir antérieur comme "The user's name is X" / "Le nom de l'utilisateur est X") ne compte PAS. Si rien
+ ne remplit les conditions, produis `"basic_info": {{}}`.
+ * N'écris JAMAIS le nom du champ lui-même ou un espace réservé comme valeur ("user",
+ "The user", "l'utilisateur", "用户", "name", "nom", "N/A", "unknown", "inconnu", "none", "-"). Omets le champ.
+ * Contre-exemple : du bavardage comme `[user]: Salut` / `[assistant]: Comment puis-je
+ t'aider ?`, ou `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
+ * Exception pour `name` : le champ `name` du propre message de l'utilisateur, ou une ligne
+ en tête "Le nom de l'utilisateur est X" / "The user's name is X" / "用户名叫X", est une source faisant autorité pour
+ `name` — même si l'utilisateur ne l'a jamais dit à voix haute.
+ * Ne mets JAMAIS ici les attributs d'une autre personne réelle. Si John (un message de rôle assistant
+ portant un `name`) dit « Je suis infirmier à Berlin », c'est un `memory`
+ ("John est infirmier à Berlin."), PAS `basic_info.occupation` / `.location`.
+* Aucune information dupliquée entre les sections
+* Tags : 1 à 3 mots-clés concis ; tags thématiques en minuscules ; les noms propres gardent leurs majuscules
+* Utilise des tableaux vides `[]` ou `{{}}` lorsque rien n'est extrait
+* Renvoie uniquement du JSON valide — n'inclus **jamais** de clé `intentions`
+
+Produis le JSON maintenant."""
+
+
+# ================================================================
+# Chat reconcile (agent/reconciler.py)
+# ================================================================
+
+SEARCH_QUERY_PROMPT = """Tu es un générateur de requêtes de recherche. À partir d'une liste de souvenirs nouvellement extraits, génère un ensemble de courtes requêtes de recherche permettant de trouver des souvenirs existants liés dans une base de données vectorielle.
+
+L'objectif est de maximiser le rappel — trouver les souvenirs existants sémantiquement liés aux nouveaux souvenirs, même si la formulation est très différente.
+
+## Nouveaux souvenirs :
+{new_memories}
+
+## Instructions
+
+Génère des requêtes de recherche couvrant :
+- Les thèmes, entités et sujets clés mentionnés dans les souvenirs
+- Des versions reformulées ou abstraites des concepts centraux
+- Des concepts liés susceptibles d'exister dans la base de mémoire de l'utilisateur
+
+Produis un tableau JSON de chaînes de requête (5 à 15 requêtes, courtes et ciblées) :
+
+["requête1", "requête2", "requête3", ...]
+
+Produis uniquement le tableau JSON, sans aucun autre texte."""
+
+RECONCILE_PROMPT = """Tu es un système de gestion de mémoire.
+
+Ta tâche est de fusionner de nouveaux souvenirs dans une base de mémoire existante tout en la gardant :
+
+* sans perte
+* sans contradiction
+* compacte
+* facile à interroger
+
+---
+
+# Opérations
+
+## ADD
+
+À utiliser lorsque l'information est entièrement nouvelle.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## UPDATE
+
+À utiliser lorsque :
+
+* le nouveau souvenir est compatible avec un souvenir existant
+* ils décrivent le même sujet
+* la fusion améliore la complétude ou la facilité de recherche
+
+Règles :
+
+* fusionne sans perte
+* préserve toute information utile
+* ne crée PAS de doublons
+* si les deux divergent sur une valeur, garde la valeur du souvenir dont le
+ `memory_at` est le plus tardif ; ne laisse jamais un souvenir plus ancien écraser une valeur plus récente
+
+### Même occurrence vs. autre occurrence
+
+Utilise **UPDATE** uniquement lorsque le nouveau souvenir ajoute des détails à la même
+occurrence réelle ou au même fait durable déjà enregistré.
+
+Si la même personne refait le même type d'activité/d'événement à un autre moment
+(un autre voyage, match, blessure, achat, alerte de santé, etc.), garde l'occurrence
+comme un **ADD** séparé. Préserve sa propre date et ses propres détails. Lorsqu'un souvenir existant
+est clairement une autre occurrence de cette même série concrète, relie-le avec
+`related: [{{"memory_id":"...","relation":"same_series"}}]`.
+
+Ne fusionne pas des occurrences datées distinctes en un seul long souvenir de comptage/chronologie.
+La couche de recherche construit les chronologies à partir des souvenirs L2 liés.
+
+```json
+{{
+ "op": "UPDATE",
+ "memory_id": "...",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## SUPERSEDE
+
+À utiliser UNIQUEMENT lorsque :
+
+* le nouveau souvenir contredit un souvenir existant
+* les deux ne peuvent pas être vrais en même temps
+* l'ancien souvenir donnerait désormais une mauvaise réponse sur l'état actuel
+* le `memory_at` du nouveau souvenir est identique ou POSTÉRIEUR au `memory_at` du souvenir existant
+
+Exemples :
+
+* changement de ville
+* changement d'employeur
+* changement de situation amoureuse
+
+Ne l'utilise PAS pour :
+
+* un détail ajouté
+* des préférences compatibles
+* des différences de formulation
+* une équivalence sémantique
+* un nouveau souvenir dont le `memory_at` est ANTÉRIEUR à celui du souvenir existant — c'est un
+ état plus ancien qui ne doit jamais remplacer un état plus récent (voir « Ordre temporel »)
+
+Règles :
+
+* content doit contenir UNIQUEMENT le nouvel état
+* ne recopie PAS les informations inchangées
+* le système conserve automatiquement l'ancien nœud et le rattache à la chaîne d'évolution ; tu n'as pas à gérer l'historique
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_id": "...",
+ "content": "...",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+### Replier plusieurs souvenirs existants en une seule chaîne
+
+Si DEUX SOUVENIRS EXISTANTS OU PLUS suivent la MÊME dimension et que le nouveau souvenir est
+le dernier changement sur cette dimension — son `memory_at` est postérieur au `memory_at` de chaque
+souvenir replié — tu peux les replier en une seule chaîne
+d'évolution. Utilise `memory_ids` (une liste ordonnée, du PLUS ANCIEN → au PLUS RÉCENT) au lieu d'un seul
+`memory_id` :
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_ids": ["<oldest_id>", "<newer_id>"],
+ "content": "<uniquement l'état le plus récent>",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+Les souvenirs listés sont chaînés du plus ancien au plus récent et le nouveau souvenir devient la
+tête de chaîne. `content` ne décrit toujours QUE l'état le plus récent — ne recopie jamais le texte des
+souvenirs plus anciens dedans ; ils restent interrogeables dans l'historique de la chaîne.
+
+---
+
+# Règles
+
+* Préserve toute information significative.
+* Ignore les doublons exacts.
+* Privilégie la fusion des fragments liés.
+* Les occurrences datées distinctes restent des ADD séparés ; utilise `same_series` uniquement pour le
+ même sujet et le même type concret d'activité/d'événement.
+* Garde chaque souvenir centré sur un seul thème cohérent.
+* Respecte « Ordre temporel » ci-dessous.
+* **Ne fusionne ni ne remplace JAMAIS entre des sujets différents.** Le sujet est celui dont
+ parle le contenu : « L'utilisateur ... » vs « John ... » vs « Mary ... ». Les souvenirs concernant
+ des personnes différentes sont des faits indépendants même lorsque la phrase est par ailleurs
+ identique — « L'utilisateur aime le café » et « John aime le café » sont deux souvenirs
+ distincts, jamais un UPDATE ni un SUPERSEDE l'un de l'autre.
+* `owner` (`user`/`agent`) : recopie-le depuis le souvenir en cours d'écriture. Ne fusionne ni ne remplace JAMAIS entre des owners différents — un fait de l'utilisateur et un fait de l'assistant sont distincts même sur le même sujet.
+* Un SUPERSEDE cible soit UN seul souvenir (`memory_id`), soit replie plusieurs souvenirs de la même dimension en une seule chaîne (`memory_ids`, du plus ancien au plus récent). Un UPDATE cible exactement UN souvenir.
+* Ne touche jamais le même souvenir existant depuis plus d'une opération.
+* La langue de sortie correspond à la langue des souvenirs d'entrée.
+
+---
+
+# Ordre temporel
+
+Chaque souvenir, nouveau ou existant, possède un `memory_at` : le moment où il s'est produit. Les souvenirs ne sont
+PAS toujours écrits dans l'ordre où ils se sont produits — l'historique peut être importé tardivement,
+et un souvenir peut être ajouté pendant que de l'historique plus ancien est encore en cours de traitement. Un nouveau
+souvenir peut donc être PLUS ANCIEN qu'un souvenir existant.
+
+* Détermine quel souvenir est le plus récent UNIQUEMENT par `memory_at`. « Nouveaux souvenirs » signifie « en cours
+ d'écriture maintenant », pas « plus récents ».
+* Un souvenir plus ancien ne doit jamais remplacer un souvenir plus récent : pas de SUPERSEDE d'un
+ souvenir plus récent, et pas d'UPDATE qui écrase une valeur plus récente par une plus ancienne.
+* Si un nouveau souvenir est plus ancien qu'un souvenir existant avec lequel il est en conflit, garde le
+ souvenir existant comme état actuel. Ajoute (ADD) le nouveau comme un état passé, formulé
+ au passé avec sa date (par exemple « En 2023, l'utilisateur vivait à Shanghai »),
+ ou ne produis rien s'il n'apporte aucune information.
+* `memory_at: null` signifie un moment inconnu. Inconnu n'est PAS plus récent : ne fais jamais de SUPERSEDE d'un
+ souvenir ayant un `memory_at` connu par un souvenir dont le `memory_at` est null.
+* N'invente pas de chronologie.
+
+---
+
+# Facultatif : `related`
+
+Sur n'importe quelle opération, tu PEUX ajouter un tableau `related` indiquant comment le souvenir en cours d'écriture
+est lié à un souvenir EXISTANT. Cela ne change pas ce qui est stocké — cela enregistre
+seulement un lien.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."],
+ "related": [{{"memory_id": "<existing_id>", "relation": "causes"}}]
+}}
+```
+
+Seules ces quatre relations sont autorisées :
+
+* `causes` — les deux souvenirs sont dans une relation de cause à effet
+ (p. ex. « a commencé à courir tous les jours » → « a commencé à avoir mal au genou »)
+* `elaborates` — ajoute des détails au souvenir existant, ou en est un développement ultérieur
+* `contrasts` — ils sont en tension mais TOUS DEUX encore vrais (si l'un rend l'autre
+ faux, c'est un SUPERSEDE, pas un lien `contrasts`)
+* `same_series` — des occurrences datées distinctes du même type concret d'activité ou
+ d'événement pour le même sujet (par exemple, deux voyages de ski différents)
+
+Règles :
+
+* Ne relie qu'à des souvenirs figurant dans « Souvenirs existants » — n'invente jamais d'id.
+* N'émets un lien que lorsque la relation est **explicite et précise**. Deux souvenirs
+ portant simplement sur le même thème général ne constituent PAS une relation — omets `related`.
+* `same_series` exige le même sujet et une action/un événement concret répété ;
+ des tags généraux partagés comme health, travel, sport, food ou work ne suffisent pas.
+* Omets entièrement le champ lorsqu'il n'y a rien à relier. Zéro lien est le cas normal.
+* N'utilise jamais `related` comme substitut à UPDATE / SUPERSEDE.
+
+---
+{few_shot_section}
+###################
+Données d'entrée
+###################
+
+Date actuelle : {current_date}
+
+## Souvenirs existants
+
+{existing_memories}
+
+## Nouveaux souvenirs
+
+{new_memories}
+
+---
+
+# Sortie
+
+Renvoie UNIQUEMENT un tableau JSON dans un bloc de code délimité ```json.
+
+Si aucun changement n'est nécessaire :
+
+```json
+[]
+```
+
+Produis maintenant le tableau JSON."""
+
+RECONCILE_STRUCTURE_METADATA_PROMPT = """
+
+Contrat de sortie structurelle supplémentaire :
+
+Pour chaque résultat ADD, UPDATE ou SUPERSEDE, préserve ou affine `topic_paths`,
+`event_facet` et `topic_assignments`. `event_facet` contient uniquement `subject`,
+`participants`, `action`, `objects`, `locations` et `state`.
+`topic_assignments` contient des entrées `{subject, role, path}` propres à un sujet ;
+chaque segment de chemin est `{name, type}` et type vaut `topic|facet|series|episode`.
+Les types suivent `topic -> facet -> series -> episode` ; des niveaux peuvent être sautés, mais
+les types ne peuvent ni se répéter ni revenir en arrière.
+Utilise Series uniquement pour des occurrences répétées d'une même ligne concrète d'activité/d'état et
+Episode uniquement pour une occurrence réelle unique et délimitée. N'infère jamais ces types à partir de
+la profondeur, d'un tag général partagé ou d'une cooccurrence sans rapport. Lorsqu'un souvenir existant
+possède déjà un chemin sémantiquement équivalent propre au même sujet, réutilise exactement ses noms
+de nœuds et ses types au lieu de créer une bifurcation synonyme. Pour demander une réutilisation exacte, émets
+`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
+"through":"topic|facet|series|episode"}]`. L'ID référencé doit figurer dans les
+souvenirs existants. `through` signifie copier ce préfixe de chemin existant jusqu'au
+type structurel nommé ; un suffixe plus profond explicitement rédigé reste nouveau. La réutilisation
+est interdite lorsque le sujet, la ligne concrète d'activité/d'état ou la délimitation de l'Episode
+diffère. Ces champs décrivent le souvenir, jamais une forme de requête future telle que
+« quand », « combien » ou « qui ».
+
+Series est une relation établie à la réconciliation : établis-la uniquement lorsque le nouveau souvenir et
+au moins un souvenir existant indépendant sont des occurrences distinctes de la même
+ligne concrète d'activité/d'état. Plusieurs propositions issues de l'écriture en cours ne
+prouvent pas une répétition.
+"""
+
+RECONCILE_FEW_SHOT = """
+###################
+Exemples
+###################
+
+## Exemple 1 — Un seul nouveau souvenir : une partie entre en conflit avec une chaîne existante, une autre est sans rapport
+
+Souvenirs existants :
+[
+ {"memory_id": "m1", "content": "L'utilisateur travaille comme product manager chez Stripe.", "owner": "user", "history_versions": [{"content": "L'utilisateur travaille comme product manager dans une startup fintech."}]}
+]
+Nouveaux souvenirs :
+[
+ {"content": "L'utilisateur a quitté Stripe et est maintenant product lead chez Notion, et s'est récemment mis à la poterie le week-end.", "owner": "user"}
+]
+
+Sortie :
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "m1", "content": "L'utilisateur travaille comme product lead chez Notion.", "supersede_reason": "employeur passé de Stripe à Notion", "owner": "user", "tags": ["work"]},
+ {"op": "ADD", "content": "L'utilisateur s'est récemment mis à la poterie le week-end.", "owner": "user", "tags": ["hobby"]}
+]
+```
+UN SEUL nouveau souvenir porte deux choses : le changement d'emploi (même dimension que la chaîne d'emploi existante m1, qui a déjà un historique → SUPERSEDE, devient la nouvelle tête de chaîne) et un détail sans rapport (la poterie → ADD). Découpe ce souvenir unique en appliquant la bonne opération à chaque partie — la nouvelle tête ne décrit QUE la situation professionnelle, jamais la poterie.
+
+## Exemple 2 — Replier deux souvenirs existants non liés + le nouveau changement en une chaîne de 3 nœuds
+
+Souvenirs existants :
+[
+ {"memory_id": "a1", "content": "L'utilisateur apprend à jouer de la guitare.", "owner": "user", "memory_at": "2024-02-10 09:00"},
+ {"memory_id": "a2", "content": "L'utilisateur sait maintenant jouer quelques morceaux complets à la guitare.", "owner": "user", "memory_at": "2024-09-05 09:00"}
+]
+Nouveaux souvenirs :
+[
+ {"content": "L'utilisateur joue maintenant de la guitare lors de scènes ouvertes locales.", "owner": "user"}
+]
+
+Sortie :
+```json
+[
+ {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "L'utilisateur joue de la guitare lors de scènes ouvertes locales.", "supersede_reason": "progression à la guitare : apprentissage → morceaux joués → concerts en public", "owner": "user", "tags": ["music", "hobby"]}
+]
+```
+a1 et a2 n'ont jamais été liés, mais ils suivent la même dimension (la progression à la guitare) et le nouveau souvenir en est la dernière étape. Replie-les avec `memory_ids` ordonnés du plus ancien au plus récent ; ils deviennent une chaîne de 3 nœuds (a1 ← a2 ← nouvelle tête). Le `content` de la tête ne décrit QUE l'état actuel — il ne reformule pas « apprend » ni « quelques morceaux ».
+
+## Exemple 3 — La nouvelle tête ne doit PAS recopier le contenu de l'ancien souvenir
+
+Souvenirs existants :
+[
+ {"memory_id": "c1", "content": "L'utilisateur loue un deux-pièces à Shibuya, Tokyo, paie 180 000 ¥/mois, adore être à 5 minutes à pied de la gare, mais se plaint que le logement est bruyant la nuit et n'a pas de parking.", "owner": "user"}
+]
+Nouveaux souvenirs :
+[
+ {"content": "L'utilisateur vient d'acheter une maison de trois chambres en banlieue de Yokohama, avec jardin et garage pour deux voitures, et y a emménagé.", "owner": "user"}
+]
+
+Sortie :
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "c1", "content": "L'utilisateur a acheté une maison de trois chambres en banlieue de Yokohama, avec jardin et garage pour deux voitures, et y a emménagé.", "supersede_reason": "résidence passée d'un appartement loué à Shibuya à une maison achetée à Yokohama", "owner": "user", "tags": ["housing"]}
+]
+```
+Le nouveau souvenir fait un SUPERSEDE de c1 et devient la tête de chaîne. Le `content` de la tête ne décrit QUE la nouvelle maison de Yokohama. N'entraîne PAS les détails distinctifs de l'ancien appartement (Shibuya, le loyer de 180 000 ¥, la marche jusqu'à la gare, les plaintes sur le bruit/le parking) dans le nouveau nœud — ils appartiennent clairement à l'ancienne résidence, pas à la nouvelle. Ils restent dans l'historique de la chaîne et demeurent interrogeables ; les recopier rendrait la tête contradictoire (locataire à Shibuya ET propriétaire à Yokohama en même temps).
+
+## Exemple 4 — Des sujets différents ne sont jamais fusionnés, quelle que soit la similarité de formulation
+
+Souvenirs existants :
+[
+ {"memory_id": "d1", "content": "L'utilisateur boit un café noir tous les matins.", "owner": "user"}
+]
+Nouveaux souvenirs :
+[
+ {"content": "John boit un café noir tous les matins.", "owner": "user"},
+ {"content": "L'utilisateur boit maintenant un café noir deux fois par jour, le matin et après le déjeuner.", "owner": "user"}
+]
+
+Sortie :
+```json
+[
+ {"op": "ADD", "content": "John boit un café noir tous les matins.", "owner": "user", "tags": ["food"]},
+ {"op": "UPDATE", "memory_id": "d1", "content": "L'utilisateur boit un café noir deux fois par jour, le matin et après le déjeuner.", "owner": "user", "tags": ["food"]}
+]
+```
+Les deux nouveaux souvenirs ont une formulation presque identique mais des sujets DIFFÉRENTS. « John ... » concerne une autre personne, c'est donc un simple ADD — jamais un UPDATE ni un SUPERSEDE de d1, même si d1 dit presque la même chose à propos de l'utilisateur. Seul le souvenir dont le sujet est aussi « L'utilisateur » peut fusionner avec d1.
+
+## Exemple 5 — Événement récurrent : incrémenter le compte et garder une chronologie (UPDATE, pas ADD)
+
+Souvenirs existants :
+[
+ {"memory_id": "i1", "content": "John s'est blessé à la cheville la saison dernière et a eu besoin d'un arrêt ainsi que de kinésithérapie.", "owner": "user", "memory_at": "2023-05-21 19:48"}
+]
+Nouveaux souvenirs :
+[
+ {"content": "John s'est de nouveau tordu la cheville lors d'un match récent.", "owner": "user", "memory_at": "2023-10-13 13:50"}
+]
+
+Sortie :
+```json
+[
+ {"op": "UPDATE", "memory_id": "i1", "content": "John s'est blessé à la cheville deux fois : la première la saison dernière (vers la saison 2022–2023), nécessitant un arrêt et de la kinésithérapie ; la seconde lors d'un match vers le 2023-10-13.", "owner": "user", "tags": ["health", "basketball", "injury"]}
+]
+```
+Le même type d'événement se reproduit → UPDATE de l'ancien souvenir. Indique le **nombre** et liste les occurrences avec leurs dates lorsqu'elles sont connues. N'ajoute PAS (ADD) un second fait « John s'est blessé à la cheville », et ne fais PAS de SUPERSEDE (la première blessure n'a pas cessé d'être vraie).
+"""
+
+
+# ================================================================
+# Working / coding memory (coding/)
+# ================================================================
+
+CODING_EXTRACT_PROMPT = """\
+Tu extrais des souvenirs de TRAVAIL durables à partir d'un segment de session d'exécution de tâche.
+Une session de « travail » est toute tâche pratique dans laquelle l'utilisateur pilote un ordinateur /
+un système au moyen d'outils — cela couvre À LA FOIS le travail logiciel/code (écriture, débogage,
+refactorisation, compilation, déploiement, utilisation d'API/de bibliothèques) ET le travail système et
+d'exploitation (exécution de commandes shell/PowerShell, analyse ou nettoyage de disque/stockage, opérations
+sur fichiers et dossiers, installation/configuration de logiciels, configuration d'environnement/d'appareil,
+inspection de l'état du matériel/des disques, sauvegarde, planification/automatisation, traitement de données).
+
+Tu produis DEUX couches à partir du MÊME segment :
+
+ EXPERIENCES (procédural, « comment faire ») — méthode réutilisable, extraite uniquement
+ lorsqu'elle franchit le SEUIL DE VALEUR ci-dessous. Un ensemble (task, search_keys, solution,
+ boundary_envs).
+
+ FACT (épisodique, « ce qui s'est passé cette fois-ci ») — EXACTEMENT UN enregistrement de CETTE
+ session : ce que voulait l'utilisateur, comment on s'y est pris, comment cela s'est terminé. Pas de
+ seuil de valeur, mais il n'y en a jamais plus d'un.
+
+Les deux couches répondent à des questions différentes et sont stockées séparément. Une méthode
+qui se généralise va dans EXPERIENCES ; l'histoire de cette session particulière —
+vraie seulement pour ce système / ce projet / maintenant — va dans le FACT.
+
+═══════════════════════════════════════════════════════════════════
+SEUIL DE VALEUR (EXPERIENCES UNIQUEMENT) — NE le franchis PAS à la légère.
+═══════════════════════════════════════════════════════════════════
+Un souvenir DOIT satisfaire TOUS les critères suivants :
+ (a) Il résout un problème susceptible de se reproduire pour le même utilisateur
+ (b) La solution n'est pas triviale : elle combine plusieurs informations / étapes, OU
+ porte une justification de décision, OU capture un contournement durement acquis, OU est une
+ procédure/recette réutilisable pour une tâche opérationnelle (p. ex. comment analyser et
+ nettoyer l'usage du disque, comment organiser des fichiers par lots, comment inspecter l'état
+ du matériel, comment mettre en place une tâche planifiée)
+ (c) Un futur agent / utilisateur préférerait le consulter plutôt que le redécouvrir
+
+IMPORTANT — les tâches d'analyse / de diagnostic / d'investigation COMPTENT :
+Une tâche n'a PAS besoin de modifier ou de « corriger » quelque chose pour mériter d'être retenue.
+Le travail en lecture seule / analytique / de dépannage a de la valeur lorsque sa PROCÉDURE ou sa
+CONCLUSION est réutilisable. Extrais explicitement :
+ - Les recettes d'analyse / de diagnostic : la procédure réutilisable + ce qu'elle a révélé
+ (p. ex. « comment analyser quels dossiers occupent l'espace du lecteur C » — les commandes d'analyse,
+ les pièges rencontrés et le résultat). « Cela n'a produit qu'un rapport, aucun changement »
+ n'est PAS une raison de l'ignorer — c'est la MÉTHODE réutilisable qui constitue le souvenir.
+ - Les résultats d'investigation, Y COMPRIS les résultats négatifs / introuvables
+ (p. ex. « recherche du dossier X sur C: et D: avec rg / fs_search / index SQL —
+ introuvable nulle part »). Une impasse consignée évite au prochain agent de répéter
+ la même recherche infructueuse, elle franchit donc le seuil.
+Ne rejette PAS un souvenir simplement parce que « l'assistant pourrait régénérer les
+commandes » ou que « rien n'a réellement été modifié ». Si la procédure ou la conclusion
+épargnerait des efforts à l'avenir, garde-la.
+
+N'extrais PAS :
+ - Les opérations vraiment triviales en une seule étape sans procédure réutilisable (« renommer un fichier »,
+ « git status », « lancer ls une fois »)
+ - Les problèmes ponctuels déjà résolus sans leçon transférable
+ - Les informations déjà présentes dans le dépôt/système (ne duplique pas package.json)
+ - Les tâches jetables propres à une PR / une session, sauf si elles encodent un motif réutilisable
+ - L'acte de DEMANDER À L'UTILISATEUR une information manquante. Demander un paramètre,
+ lister ce qui est inconnu ou solliciter des champs requis relève du comportement
+ conversationnel, pas d'une méthode : tout agent sait déjà poser une question, il n'y a
+ donc rien à consulter plus tard. N'émets jamais une expérience dont task ou
+ search_keys ressemblent à « comment demander X », « recueillir le Y manquant »,
+ « solliciter les champs requis », « que clarifier avant de commencer ». Note que cela
+ reste hors des EXPERIENCES uniquement — le fait que la session se soit terminée en attente de l'utilisateur
+ est un état réel et appartient au FACT.
+
+Si le segment n'a fait aucun progrès substantiel parce qu'il s'est bloqué en attendant
+l'utilisateur — l'assistant a seulement demandé des paramètres, ou a été bloqué avant tout
+travail réel — émets "experiences": [] et écris le FACT seul. Rien n'a encore été
+appris, il n'y a donc aucune méthode à stocker. C'est plus important qu'il n'y paraît :
+une expérience tirée d'un blocage se lit comme une compétence légitime lors de la recherche,
+et un segment ultérieur de la même tâche la retrouvera et redemandera à l'utilisateur
+au lieu d'avancer, de sorte que le blocage se reproduit pour le reste de la
+session. Juge la substance d'après ce que les outils ont réellement fait, pas d'après la fluidité
+du texte produit dans le tour.
+
+Heuristique : si l'utilisateur (ou un futur agent effectuant le même type de tâche) voudrait
+que ce soit écrit plutôt que de le redécouvrir, garde-le. Une procédure opérationnelle
+en plusieurs étapes (même une procédure système/exploitation ou d'analyse/recherche en lecture seule, pas
+seulement du code) se qualifie généralement. Ne l'abandonne que s'il s'agit d'une seule commande que tout utilisateur
+trouverait via `--help` en 30 secondes ET qu'elle ne porte aucune décision/aucun piège méritant
+d'être retenu.
+
+═══════════════════════════════════════════════════════════════════
+CHAMPS D'UNE EXPÉRIENCE
+═══════════════════════════════════════════════════════════════════
+
+task — Nom formulé comme une requête ; formule-le comme un utilisateur le DEMANDERAIT plus tard.
+ « publier une release sur la plateforme xx » et non
+ « publish_release_internal »
+ Autonome (pas de « ceci », « le fichier », « nous »).
+
+search_keys — 0 à 5 formulations alternatives capturant des aspects importants de la
+ solution que `task` seul ne ferait pas correspondre. Formule-les comme des questions
+ ou des sujets SUR LESQUELS de futurs utilisateurs s'interrogeraient. Distinctes de task.
+ Omets-les si task couvre déjà tout.
+
+solution — Contenu complet et autonome dont l'utilisateur a réellement besoin :
+ commandes, emplacements des identifiants (PAS les VALEURS des identifiants),
+ chemins de fichiers, étapes ordonnées, pièges, justification des décisions.
+ Agrège un travail de bout en bout sur plusieurs tours en UNE seule solution s'il
+ forme une tâche cohérente ; sépare en plusieurs souvenirs uniquement lorsque
+ l'utilisateur a effectué des tâches sans rapport.
+
+boundary_envs — Ancrages concrets dont dépend la solution, sur plusieurs lignes « clé: valeur » :
+ runtime / SDK / bibliothèque + version
+ endpoint d'API ou signature de méthode
+ version d'un service externe / middleware
+ NOM de variable d'environnement (pas sa valeur)
+ chemin du fichier de configuration
+ identifiant d'hôte / de cluster / de région
+ Si la solution est indépendante de l'environnement, laisse "" (vide).
+ But : lorsque le SDK/middleware sous-jacent est mis à jour, les futurs
+ consommateurs peuvent l'examiner pour décider si la solution s'applique encore.
+
+confidence — 0.0 à 1.0
+ 1.0 l'utilisateur l'a explicitement énoncé comme règle / instruction
+ 0.7 inféré avec de bonnes preuves à partir des actions des outils
+ 0.5 faiblement inféré ; une seule observation ; incertain
+
+═══════════════════════════════════════════════════════════════════
+CHAMP FACT — EXACTEMENT UN par segment, pas de seuil de valeur
+═══════════════════════════════════════════════════════════════════
+
+Tu écris UN seul fait pour tout le segment — un enregistrement d'état récupérable pour cette
+session, pas une rétrospective soignée et jamais une liste de constats séparés. Un
+futur agent doit pouvoir reprendre à partir de lui sans confondre une suggestion,
+une inférence ou une recherche partielle avec quelque chose de vérifié.
+
+subject — QUI ou QUOI concerne cette session : l'entité unique sur laquelle ou pour laquelle le travail a été
+ effectué. Un court groupe nominal, pas de phrase, pas de verbe.
+ Choisis l'entité la plus précise dont la session *traite*, pas
+ l'outil qu'elle a utilisé :
+ le nom d'une personne lorsque la session sert une personne nommée
+ ("Dylan", "Matthew")
+ le fichier / module / symbole lorsque le travail cible du code
+ ("auth/middleware.ts", "parse_plan_text")
+ le service / hôte / appareil / lecteur pour le travail d'exploitation
+ ("D:\\WXWork", "redis-cache-prod", "ci.yml")
+ C'est une CLÉ STRICTE, pas de la prose : deux sessions concernant des personnes différentes
+ ou des fichiers différents DOIVENT avoir des subjects différents, et deux sessions
+ concernant la même entité DOIVENT avoir la même chaîne, orthographiée à l'identique.
+ Préfère l'identifiant exact tel qu'il apparaît dans la trace à une
+ description de celui-ci. Si le segment n'a réellement pas de sujet unique,
+ produis "".
+
+ Pourquoi c'est important : subject est la barrière qui décide si une session ultérieure
+ est autorisée à écraser celle-ci comme « la même tâche,
+ poursuivie ». Si tu te trompes, l'état d'une personne remplace silencieusement
+ celui d'une autre.
+
+statement — Un enregistrement compact de CETTE session. Deux parties, et la seconde est celle
+ qui se perd.
+ Préserve les données propres à la tâche et les contraintes concrètes au lieu de
+ les remplacer par une évaluation générique du résultat. Énonce
+ chaque règle une seule fois : un texte d'instruction répété fait concurrence aux données
+ que le souvenir doit retenir.
+
+ PARTIE 1 — ce qui s'est passé, environ 300 caractères latins (~150 CJK).
+ Commence par l'objectif et l'objet précis (« récupérer l'espace disque occupé
+ par D:\\WXWork », « localiser le dossier new_file_search »), pas par un générique
+ « corriger un bug » / « trouver un fichier ». Puis, en gros, ce qui a été inspecté, essayé
+ ou modifié. Puis comment cela s'est terminé, avec la sémantique d'exactement un état parmi :
+ terminé, partiellement terminé, échoué, bloqué, ou
+ toujours en attente de vérification. Inclus les résultats négatifs et les impasses
+ sans les exagérer.
+
+ PARTIE 2 — les DONNÉES PROPRES À LA TÂCHE : tout ce sur quoi repose la tâche ENTIÈRE,
+ même lorsque ce segment ne l'a pas établi et même lorsque cela paraît
+ trop élémentaire pour être énoncé. Les liaisons (ce que représente chaque nom/symbole/étiquette),
+ les valeurs fixes que la tâche fournit plutôt qu'elle ne les dérive, les
+ conventions adoptées (base d'indexation, unités, fuseau horaire, valeurs par défaut), et
+ le propre résultat de ce segment AVEC sa valeur (« x = 7 », pas « la valeur
+ a été calculée »).
+
+ Écris la PARTIE 2 comme des données, un élément par ligne, valeurs telles que données :
+ budget de tentatives = 5 ; timeout 30s ; l'index commence à 0
+ entrée de l'étape 3 : n=64, tolérance 1e-6
+ créneau B : type=privé, coût 688.7-721.3 par unité
+ Une ligne doit être presque entièrement composée de valeurs. Garde la notation de la trace —
+ symboles, unités, nombres, orthographes — et abandonne ses phrases : supprime
+ les formules qui annoncent une donnée au lieu d'en être une (« je préférerais »,
+ « ça devrait se situer quelque part entre … et … »). Elles se répètent une fois
+ par élément, donc une liste de 15 éléments les paie 15 fois.
+ Reporte-les sur CHAQUE fait ; n'écris jamais « comme ci-dessus » ou « comme dans la
+ session précédente » — la recherche renvoie une poignée de faits par
+ similarité et le référent peut ne pas en faire partie.
+
+ Vise moins de 1200 caractères au total. Si la PARTIE 2 ne tient pas, corrige la
+ notation, jamais la couverture : statement est le vecteur de recherche ET
+ le seul champ qu'un segment ultérieur peut lire (details n'est ni vectorisé
+ ni injecté), donc tout ce qui en est retiré est perdu. Compresse la formulation
+ autour d'une donnée ; jamais la donnée.
+
+ Le test : si le segment suivant ne peut pas voir le matériel d'origine, peut-il
+ continuer à partir de ce seul enregistrement ? Seul un oui compte. Une liaison manquante
+ n'échoue pas bruyamment — le nom semble toujours avoir un sens, donc
+ il est lu avec son sens courant et la réponse qui
+ suit est fluide et porte sur une autre question.
+
+ LANGUE — la même langue que la trace de la session : statement est le
+ vecteur de recherche et les requêtes arrivent dans la langue de travail de l'utilisateur,
+ donc une autre langue paie une pénalité interlinguistique à chaque recherche.
+
+ FIDÉLITÉ AUX PREUVES — n'enregistre que les actions réellement exécutées et les
+ preuves explicitement présentes dans la trace. Préserve mot pour mot les
+ commandes, options, arguments, erreurs et nombres significatifs.
+ Ne complète JAMAIS une commande avec des options habituelles, et ne transforme jamais
+ des conseils ou des plans en actions :
+ « a exécuté Get-ChildItem -Force » → « a exécuté Get-ChildItem »
+ (la trace ne contenait pas `-Force` ; ne l'invente pas)
+ Limite chaque constat négatif à ce qui a réellement été recherché, et
+ énumère CHAQUE limite de couverture explicite qui pourrait l'invalider,
+ en particulier les échecs de permission et les limites de profondeur : garde les racines,
+ les filtres et la profondeur en vigueur (« introuvable sous C:\\ et
+ D:\\ à la profondeur 3 ; certains répertoires n'ont pas été couverts à cause d'un Access
+ denied »), ne l'élargis jamais en « n'existe pas ». N'omets pas une limite
+ pour rendre l'enregistrement plus joli.
+ Ne promeus jamais une recherche partielle en absence globale.
+ Une tentative bloquée garde ce qui l'a bloquée.
+ Préserve la distinction entre tenté, observé, vérifié,
+ inféré et non résolu — exprime-la naturellement (« a essayé … mais a été
+ bloqué par Access denied », « soupçonne …, pas encore vérifié »), pas sous forme
+ d'étiquettes. Sans sortie d'outil ni confirmation explicite, n'affirme JAMAIS qu'un
+ correctif a réussi, qu'une cause a été établie ou qu'un chemin n'existe pas.
+
+ N'enregistre PAS les salutations ni le pur bavardage — c'est le seul cas
+ qui reçoit "fact": null. Un segment qui s'est contenté d'énoncer des exigences, ou
+ qui s'est bloqué avant de faire du travail, a tout de même établi quelque chose.
+
+details — La SORTIE concrète de la session, recopiée mot pour mot. `statement` est
+ un résumé, et un résumé abandonne nécessairement les valeurs individuelles ; une
+ recherche ultérieure veut presque toujours une valeur précise, pas l'essentiel.
+ Donc, quel que soit le résultat adressable produit par cette session, reproduis-le
+ ici dans sa forme et sa structure d'origine :
+ un plan / un emploi du temps / un itinéraire → garde chaque ligne, chaque jour, chaque
+ créneau et chaque prix exactement tels qu'écrits
+ un bloc de configuration ou de code → garde le bloc
+ la sortie significative d'une commande → garde les lignes qui portent les
+ constats (tailles, nombres, versions, texte d'erreur)
+ un résultat structuré (tableau, liste d'enregistrements) → garde les lignes
+ Préserve la mise en page d'origine — sauts de ligne, préfixes `Day 1:` / clé: valeur,
+ unités, symboles monétaires, ids. Ne résume pas à nouveau, ne
+ réordonne pas, n'arrondis pas les nombres, ne traduis pas.
+
+ Ne recopie QUE ce qui est présent dans la trace. Ne comble jamais un manque : si un créneau
+ a été laissé vide, laisse-le vide ou dis-le — une valeur inventée
+ est pire qu'une valeur manquante, car elle sera retrouvée et utilisée.
+ Plafonne autour de 4000 caractères ; si la sortie est plus longue, garde les parties
+ portant des valeurs concrètes et abandonne la prose décorative, en notant ce qui a été
+ abandonné.
+
+ "" lorsque la session n'a produit aucun artefact de ce type (pure investigation
+ sans constat pour l'instant, ou blocage en attente de l'utilisateur).
+
+ Ce champ ne fait PAS partie du vecteur de recherche — `statement` et
+ `subject` servent à trouver, `details` fournit la valeur une fois trouvée.
+ N'écris donc pas ici d'appât pour la recherche, et ne duplique pas le
+ résumé ; écris la chose brute.
+
+files — 0..N chemins de FICHIERS OU DE RÉPERTOIRES, absolus ou relatifs au dépôt, réellement
+ manipulés ou examinés pendant cette session. Garde les racines examinées
+ comme `C:\\` et `D:\\`. N'inclus que les chemins réellement
+ consultés/fouillés, pas ceux simplement suggérés ou prévus ;
+ [] si aucun ne s'applique.
+═══════════════════════════════════════════════════════════════════
+CONTEXTE HÔTE (fourni par le SDK)
+═══════════════════════════════════════════════════════════════════
+- workspace_id présent : {workspace_present}
+- branche présente : {branch_present}
+
+Lorsqu'aucun workspace_id n'est présent, la solution ne peut pas s'appuyer sur un contexte
+local au projet non énoncé — précise tout dépôt / chemin / service nécessaire dans
+`solution` ou `boundary_envs` afin que le souvenir reste utilisable par lui-même.
+
+═══════════════════════════════════════════════════════════════════
+CONVERSATION
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+SORTIE (JSON strict uniquement, pas de markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "subject": "...",
+ "statement": "...",
+ "files": ["..."],
+ "details": "..."
+ }}
+}}
+
+PAR DÉFAUT, EXTRAIS. Lorsque le segment a fait du travail réel, tu DOIS produire au moins
+une expérience — même si la tâche paraît simple ou a réussi du premier coup, capture quand même
+l'essence réutilisable de ce qui a été fait (la méthode / la commande / le mode opératoire).
+Lorsque la session est mince, la seule expérience la plus précieuse suffit.
+
+La SEULE exception est le cas de blocage ci-dessus : si le segment n'a fait aucun travail réel
+parce qu'il était bloqué à demander à l'utilisateur une information manquante, produis
+"experiences": [] et écris uniquement le fait. Ne fabrique pas d'expérience pour
+satisfaire cette instruction — une expérience inventée (« comment demander la ville de
+départ ») est pire qu'aucune, car elle est ensuite retrouvée et suivie. Le vide est
+autorisé UNIQUEMENT pour cette raison, jamais comme raccourci lorsque du travail a réellement été fait.
+
+"fact" est un objet UNIQUE, jamais une liste — un enregistrement par session.
+
+ÉCRIS TOUJOURS le fait. Le critère pour le fait n'est pas « était-ce précieux » mais « s'est-il
+passé quoi que ce soit », et un segment qui te parvient a déjà franchi ce critère.
+Cela inclut les segments qui ressemblent à de la mise en place plutôt qu'à du travail : un seul
+message de l'utilisateur énonçant des exigences, des paramètres ou un état de départ, sans
+aucun outil exécuté, est exactement le matériel qu'une session ultérieure ne peut pas reconstruire seule
+— écris les exigences, les paramètres et l'état de départ, avec la situation, dans `statement` (notation compacte, sans recopier les phrases de la conversation),
+et ne les renvoie pas dans `details` (`details` n'entre pas dans le vecteur de recherche et n'est plus injecté côté lecture). Utilise
+"fact": null UNIQUEMENT pour les salutations et le pur bavardage sans aucun contenu.
+En cas de doute, écris le fait : un enregistrement inutile coûte une ligne, alors qu'un enregistrement abandonné
+coûte à chaque session ultérieure qui en avait besoin et n'a aucun moyen de savoir qu'il existait.
+"""
+
+CODING_EXTRACT_PROMPT_CODING = """\
+╔═══════════════════════════════════════════════════════════════════════════╗
+║ CONTRAINTE STRICTE — lis ceci avant toute chose ; elle prime sur toute ║
+║ formulation ultérieure de ce prompt qui semblerait réclamer un récit. ║
+║ ║
+║ Tu n'écris PAS le compte rendu de ce qu'une personne a fait. Tu écris ║
+║ ce dont un FUTUR AGENT a besoin pour agir. Cet agent a déjà sa propre ║
+║ tâche ; peu lui importe ce que voulait cet utilisateur. Il doit savoir : ║
+║ ce qui a été décidé ici, à quelles coordonnées dans le code, ce qui a ║
+║ été essayé et rejeté, et si cela a été vérifié. ║
+║ ║
+║ Concrètement, dans chaque `statement` et chaque `solution` : ║
+║ · Le sujet grammatical est le CODE ou LA DÉCISION — jamais ║
+║ « l'utilisateur » ni « l'agent ». N'écris pas « L'utilisateur a ║
+║ tenté de… », « L'utilisateur voulait… », « L'agent a ensuite… ». ║
+║ · Ne termine jamais par une formule administrative comme « la session ║
+║ s'est terminée », « l'erreur a été notée », « aucune solution n'a ║
+║ encore été trouvée ». Termine par la décision et son état de ║
+║ vérification. Si rien n'a été décidé, termine par ce qui a été ║
+║ ÉCARTÉ et la prochaine piste inexplorée — c'est la partie ║
+║ réutilisable. ║
+║ · Garde le symptôme concret (chaîne d'erreur, commande en échec, ║
+║ sortie erronée) — c'est ce sur quoi une future recherche portera. ║
+║ ║
+║ mauvais : « L'utilisateur a tenté d'écrire une QTable en RST avec ║
+║ header_rows et a obtenu une TypeError. La session s'est ║
+║ terminée avec l'erreur notée. » ║
+║ bon : « le writer RST de ascii.rst rejette header_rows : ║
+║ `tbl.write(..., \\ ║
+║ format='ascii.rst', header_rows=['name','unit'])` lève une ║
+║ TypeError car RST.__init__ ne le transmet pas, contrairement à ║
+║ ascii.fixed_width qui l'accepte. Aucun correctif écrit — le ║
+║ writer a besoin de la même plomberie header_rows que ║
+║ fixed_width. » ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+
+Tu extrais des souvenirs de TRAVAIL durables à partir d'un segment de session d'exécution de tâche.
+Une session de « travail » est toute tâche pratique dans laquelle l'utilisateur pilote un ordinateur /
+un système au moyen d'outils — cela couvre À LA FOIS le travail logiciel/code (écriture, débogage,
+refactorisation, compilation, déploiement, utilisation d'API/de bibliothèques) ET le travail système et
+d'exploitation (exécution de commandes shell/PowerShell, analyse ou nettoyage de disque/stockage, opérations
+sur fichiers et dossiers, installation/configuration de logiciels, configuration d'environnement/d'appareil,
+inspection de l'état du matériel/des disques, sauvegarde, planification/automatisation, traitement de données).
+
+Tu produis DEUX couches à partir du MÊME segment :
+
+ EXPERIENCES (procédural, « comment faire ») — méthode réutilisable, extraite uniquement
+ lorsqu'elle franchit le SEUIL DE VALEUR ci-dessous. Un ensemble (task, search_keys, solution,
+ boundary_envs).
+
+ FACT (épisodique, « ce qui a été établi cette fois-ci ») — EXACTEMENT UN enregistrement de CETTE
+ session. Ce n'est PAS un récit de ce qu'a fait l'utilisateur. Il consigne, dans cet ordre :
+ la tâche et son symptôme concret (c'est ce qui le rend retrouvable plus tard), les
+ coordonnées dans le code, CE QUI A ÉTÉ RETENU et ce qui a été rejeté, et jusqu'où cela a été
+ vérifié. Pas de seuil de valeur, mais il n'y en a jamais plus d'un.
+
+Les deux couches répondent à des questions différentes et sont stockées séparément. Une méthode
+qui se généralise va dans EXPERIENCES ; l'histoire de cette session particulière —
+vraie seulement pour ce système / ce projet / maintenant — va dans le FACT.
+
+═══════════════════════════════════════════════════════════════════
+SEUIL DE VALEUR (EXPERIENCES UNIQUEMENT) — NE le franchis PAS à la légère.
+═══════════════════════════════════════════════════════════════════
+Un souvenir DOIT satisfaire TOUS les critères suivants :
+ (a) Il résout un problème susceptible de se reproduire pour le même utilisateur
+ (b) La solution n'est pas triviale : elle combine plusieurs informations / étapes, OU
+ porte une justification de décision, OU capture un contournement durement acquis, OU est une
+ procédure/recette réutilisable pour une tâche opérationnelle (p. ex. comment analyser et
+ nettoyer l'usage du disque, comment organiser des fichiers par lots, comment inspecter l'état
+ du matériel, comment mettre en place une tâche planifiée)
+ (c) Un futur agent / utilisateur préférerait le consulter plutôt que le redécouvrir
+
+IMPORTANT — les tâches d'analyse / de diagnostic / d'investigation COMPTENT :
+Une tâche n'a PAS besoin de modifier ou de « corriger » quelque chose pour mériter d'être retenue.
+Le travail en lecture seule / analytique / de dépannage a de la valeur lorsque sa PROCÉDURE ou sa
+CONCLUSION est réutilisable. Extrais explicitement :
+ - Les recettes d'analyse / de diagnostic : la procédure réutilisable + ce qu'elle a révélé
+ (p. ex. « comment analyser quels dossiers occupent l'espace du lecteur C » — les commandes d'analyse,
+ les pièges rencontrés et le résultat). « Cela n'a produit qu'un rapport, aucun changement »
+ n'est PAS une raison de l'ignorer — c'est la MÉTHODE réutilisable qui constitue le souvenir.
+ - Les résultats d'investigation, Y COMPRIS les résultats négatifs / introuvables
+ (p. ex. « recherche du dossier X sur C: et D: avec rg / fs_search / index SQL —
+ introuvable nulle part »). Une impasse consignée évite au prochain agent de répéter
+ la même recherche infructueuse, elle franchit donc le seuil.
+Ne rejette PAS un souvenir simplement parce que « l'assistant pourrait régénérer les
+commandes » ou que « rien n'a réellement été modifié ». Si la procédure ou la conclusion
+épargnerait des efforts à l'avenir, garde-la.
+
+N'extrais PAS :
+ - Les opérations vraiment triviales en une seule étape sans procédure réutilisable (« renommer un fichier »,
+ « git status », « lancer ls une fois »)
+ - Les problèmes ponctuels déjà résolus sans leçon transférable
+ - Les informations déjà présentes dans le dépôt/système (ne duplique pas package.json)
+ - Les tâches jetables propres à une PR / une session, sauf si elles encodent un motif réutilisable
+
+Heuristique : si l'utilisateur (ou un futur agent effectuant le même type de tâche) voudrait
+que ce soit écrit plutôt que de le redécouvrir, garde-le. Une procédure opérationnelle
+en plusieurs étapes (même une procédure système/exploitation ou d'analyse/recherche en lecture seule, pas
+seulement du code) se qualifie généralement. Ne l'abandonne que s'il s'agit d'une seule commande que tout utilisateur
+trouverait via `--help` en 30 secondes ET qu'elle ne porte aucune décision/aucun piège méritant
+d'être retenu.
+
+═══════════════════════════════════════════════════════════════════
+TRAVAIL SUR DU CODE — ce qu'un futur agent ne peut pas re-déduire, donc à capturer IMPÉRATIVEMENT
+═══════════════════════════════════════════════════════════════════
+Lorsque le segment est du travail logiciel sur un dépôt, la méthode réutilisable n'en est que
+la moitié. L'autre moitié est OÙ se trouve le travail et QUELLE VERSION l'a emporté. Cela ne
+peut pas être retrouvé en lisant le code plus tard — le code montre l'état actuel,
+ni la branche sur laquelle il se trouve, ni ce qui a déjà été rejeté.
+
+Cette section ne demande PAS un enregistrement plus long. Elle te demande de DÉPENSER LE MÊME
+BUDGET sur des tokens de plus grande valeur : abandonne les reformulations de l'objectif, la narration de ce que
+l'assistant « a ensuite décidé de faire », et le code collé que tu ne fais que répéter ; dépense plutôt ces
+caractères sur les quatre éléments ci-dessous. Un enregistrement qui omet la branche mais
+cite 30 lignes de diff est un mauvais échange.
+
+1. BRANCHE / EMPLACEMENT DE TRAVAIL — mot pour mot, dans le `statement` du fait. Si le segment
+ mentionne ou bascule sur `feat/x` / `fix/y`, ce token DOIT apparaître. Un agent
+ qui reprend sur la mauvaise branche produit des changements qui sont silencieusement jetés,
+ donc ce seul token l'emporte sur tout autre détail.
+
+2. QUELLE VERSION L'A EMPORTÉ — lorsque l'utilisateur a changé d'avis, nomme la gagnante et marque
+ la perdante en une proposition : « retenu A ; le B intermédiaire a été abandonné ». Pas les deux en
+ entier — une seule proposition. Ne garder que la dernière est une erreur : un agent qui rencontre le
+ code rejeté doit le reconnaître, sinon il « corrigera » les choses en revenant à la variante
+ abandonnée. Des formules comme `scratch that / go back to / actually, let's / no, not that`
+ (« oublie ça / reviens à / en fait, faisons / non, pas ça ») le signalent : ce qui suit fait foi,
+ ce qui précède est remplacé.
+
+3. COORDONNÉES EXACTES, PAS DE CODE COLLÉ — chemin relatif au dépôt
+ (`qutebrowser/utils/debug.py`, jamais `debug.py` seul) plus la fonction /
+ classe touchée. Si une signature a changé, donne la nouvelle signature. Si une constante,
+ une regex ou un littéral a été décidé, cite CELUI-LÀ mot pour mot — mais cite uniquement lui, pas le
+ bloc qui l'entoure. Une ligne exacte vaut mieux qu'un paragraphe d'approximation.
+
+4. VÉRIFIÉ vs SIMPLEMENT ÉCRIT — quelques mots suffisent (« tests exécutés et passants » /
+ « confirmé uniquement par git diff, tests non exécutés »). « la modification est en place » et « la modification est en place
+ et testée » amènent un futur agent à faire des choses très différentes ensuite.
+
+Anti-modèle — résumer l'objectif et abandonner les coordonnées :
+ mauvais : « logique d'analyse des couleurs refactorisée pour être plus propre. »
+ bon : « sur feat/q4, dans qutebrowser/config/configtypes.py QtColor._parse_value :
+ retenu `mult = 360.0 if kind == 'h' else 255.0` ; la version intermédiaire qui
+ utilisait 255.0 partout a été abandonnée. Tests non exécutés. »
+ (le bon est PLUS COURT que la plupart des mauvais — il dépense simplement chaque caractère
+ sur quelque chose qui ne peut pas être re-déduit)
+
+═══════════════════════════════════════════════════════════════════
+CHAMPS D'UNE EXPÉRIENCE
+═══════════════════════════════════════════════════════════════════
+
+task — Nom formulé comme une requête ; formule-le comme un utilisateur le DEMANDERAIT plus tard.
+ « publier une release sur la plateforme xx », et non « publish_release_internal »
+ Autonome (pas de « ceci », « le fichier », « nous »).
+
+search_keys — 0 à 5 formulations alternatives capturant des aspects importants de la
+ solution que `task` seul ne ferait pas correspondre. Formule-les comme des questions
+ ou des sujets SUR LESQUELS de futurs utilisateurs s'interrogeraient. Distinctes de task.
+ Omets-les si task couvre déjà tout.
+
+solution — Contenu complet et autonome dont l'utilisateur a réellement besoin :
+ commandes, emplacements des identifiants (PAS les VALEURS des identifiants),
+ chemins de fichiers, étapes ordonnées, pièges, justification des décisions.
+ Agrège un travail de bout en bout sur plusieurs tours en UNE seule solution s'il
+ forme une tâche cohérente ; sépare en plusieurs souvenirs uniquement lorsque
+ l'utilisateur a effectué des tâches sans rapport.
+
+boundary_envs — Ancrages concrets dont dépend la solution, sur plusieurs lignes « clé: valeur » :
+ runtime / SDK / bibliothèque + version
+ endpoint d'API ou signature de méthode
+ version d'un service externe / middleware
+ NOM de variable d'environnement (pas sa valeur)
+ chemin du fichier de configuration
+ identifiant d'hôte / de cluster / de région
+ Si la solution est indépendante de l'environnement, laisse "" (vide).
+ But : lorsque le SDK/middleware sous-jacent est mis à jour, les futurs
+ consommateurs peuvent l'examiner pour décider si la solution s'applique encore.
+
+confidence — 0.0 à 1.0
+ 1.0 l'utilisateur l'a explicitement énoncé comme règle / instruction
+ 0.7 inféré avec de bonnes preuves à partir des actions des outils
+ 0.5 faiblement inféré ; une seule observation ; incertain
+
+═══════════════════════════════════════════════════════════════════
+CHAMP FACT — EXACTEMENT UN par segment, pas de seuil de valeur
+═══════════════════════════════════════════════════════════════════
+
+Tu écris UN seul fait pour tout le segment — un enregistrement d'état récupérable pour cette
+session, pas une rétrospective soignée et jamais une liste de constats séparés. Un
+futur agent doit pouvoir reprendre à partir de lui sans confondre une suggestion,
+une inférence ou une recherche partielle avec quelque chose de vérifié.
+
+statement — Un résumé compact de CETTE session. Il a deux rôles à la fois, et il
+ doit remplir LES DEUX : c'est le vecteur de recherche (un futur agent le trouve en
+ cherchant avec un nouveau signalement de problème, formulé comme un utilisateur formule un
+ problème), et c'est le contenu sur lequel cet agent agit ensuite. Donc :
+
+ COMMENCE par la tâche et le symptôme, avec les mots qu'emploierait un utilisateur.
+ C'est ce qui le rend retrouvable — garde la forme de surface proche de la façon dont
+ le problème serait signalé. Nomme l'objectif et l'objet précis
+ (« récupérer l'espace disque sous D:\\WXWork », « ajuster le multiplicateur de teinte
+ dans QtColor._parse_value sur feat/q4 », « localiser le dossier
+ new_file_search »), jamais un générique « corriger un bug » / « chercher un fichier ». Inclus
+ le symptôme concret : la chaîne d'erreur, la commande en échec, la
+ sortie erronée.
+
+ DONNE ENSUITE les coordonnées et la décision.
+ chemin relatif au dépôt, symbole et branche pour le travail sur du code. Indique ce qui a été
+ RETENU, et dans la même proposition marque ce qui a été abandonné
+ (« retenu X ; le Y intermédiaire a été abandonné »). C'est la partie qui
+ ne peut pas être re-déduite en lisant le code — le code ne montre que la
+ gagnante, jamais que Y a été essayé et rejeté. Un agent qui rencontre plus tard la
+ variante rejetée doit pouvoir la reconnaître, sinon il « corrigera » le code en
+ revenant à la version abandonnée.
+
+ TERMINE par l'état des preuves.
+ Exactement un parmi : terminé, partiellement terminé, échoué, bloqué, ou
+ toujours en attente de vérification — plus la façon dont cela a été vérifié (« tests exécutés et
+ passants » / « confirmé uniquement par git diff, tests non exécutés »). Inclus
+ les résultats négatifs et les impasses sans les exagérer.
+
+ ⚠️ Ne t'arrête jamais au récit. « L'utilisateur a essayé X et a rencontré l'erreur Y ; aucune
+ solution trouvée pour l'instant » est un enregistrement gaspillé : il est bien retrouvé mais ne donne à un
+ futur agent rien sur quoi agir. Si la session n'a réellement abouti à aucune
+ décision, dis ce qui a été écarté et quelle est la prochaine piste inexplorée —
+ c'est la partie réutilisable.
+
+ Le sujet des phrases doit être le code et la décision, pas
+ « l'utilisateur ». 2 à 4 phrases, en prose fluide, pas en sections étiquetées.
+ Plafond strict d'environ 400 caractères latins (~200 caractères CJK).
+
+ FIDÉLITÉ AUX PREUVES — obligatoire :
+ - N'enregistre que les actions réellement exécutées et les preuves explicitement
+ présentes dans la trace. Préserve mot pour mot les commandes, options,
+ arguments, erreurs et nombres significatifs. Ne complète JAMAIS une
+ commande avec des options habituelles et ne transforme jamais des conseils/plans en actions.
+ - Préserve la distinction entre tenté, observé, vérifié,
+ inféré et non résolu. N'ajoute pas ces étiquettes à la prose ;
+ exprime leur sens naturellement, p. ex. « a essayé … mais a été bloqué par
+ Access denied » ou « soupçonne … , pas encore vérifié ».
+ - Sans sortie d'outil ni confirmation explicite, n'affirme JAMAIS qu'un correctif
+ a réussi, qu'une cause a été établie, qu'un fichier/dossier n'existe
+ pas, ou que des tests sont passés.
+ - Limite chaque constat négatif à ce qui a réellement été recherché et
+ énumère CHAQUE limite de couverture explicite qui pourrait
+ l'invalider, en particulier les échecs de permission et la profondeur maximale de recherche :
+ « introuvable dans les parties examinées de C:\\ et D:\\ ; certains
+ répertoires ont été ignorés sur Access denied, et la recherche était aussi
+ limitée en profondeur ». N'omets pas une limite pour rendre le
+ résumé plus joli. Ne promeus jamais une recherche partielle en absence
+ globale.
+ - N'énonce une causalité comme certaine que lorsque la trace la vérifie
+ directement. Sinon, conserve la réserve (« soupçonné » / « inféré » / « pas encore
+ vérifié ») ; ne réécris pas une
+ hypothèse de test incorrecte en cause racine du système.
+
+ CRUCIAL — ce texte EST le vecteur de recherche, et c'est la seule
+ chose à laquelle une future requête sera comparée. Un résumé générique ne
+ vaut rien, car CHAQUE session ressemble à un résumé générique : il
+ correspondrait à toutes les requêtes et ne répondrait à aucune. Tu DOIS donc nommer
+ les ancres concrètes qui rendent CETTE session retrouvable — vrais chemins de
+ fichiers, noms de fonctions / symboles, noms de branches, commandes, chaînes
+ d'erreur, versions, clés et valeurs de configuration, noms d'hôtes / de services.
+ Si quelqu'un recherche plus tard l'un de ces éléments précis, ce
+ résumé doit être ce qui ressort.
+ bon : « correction d'un `npm run build` en échec dans la CI. Lu
+ .github/workflows/ci.yml et package.json ; problème attribué à webpack
+ 5.74 déclenchant ERR_OSSL_EVP_UNSUPPORTED sous node 18. Passer le
+ node du workflow à 20 a fait passer le build ; node 18
+ reproduit toujours en local. »
+ bon : « sur la branche feat/q0, dans qutebrowser/utils/debug.py signal_name :
+ PyQt<5.11 n'expose le nom que via repr(sig), et repr se présente
+ sous une forme entre crochets et une forme entre parenthèses. Retenu deux motifs
+ essayés dans l'ordre avec fullmatch, en s'arrêtant à la première correspondance ; la
+ version à regex unique a été abandonnée. Confirmé par git diff, tests non
+ exécutés. »
+ mauvais : « l'utilisateur voulait corriger un bug de build, l'agent a regardé quelques fichiers
+ de configuration, a modifié du code et l'a corrigé. »
+ (aucun chemin, aucune commande, aucune chaîne d'erreur, aucune version — rien
+ sur quoi chercher ; chaque session se lit exactement ainsi)
+ mauvais : « problème de compatibilité de l'analyse des noms de signaux corrigé sur une branche
+ de fonctionnalité. »
+ (quelle branche ? quel fichier ? quelle fonction ? laquelle des deux
+ versions concurrentes l'a emporté ? rien ici ne survit à une
+ recherche une semaine plus tard)
+ Exemples de fidélité (mauvais → bon) :
+ « a exécuté Get-ChildItem -Force » → « a exécuté Get-ChildItem »
+ (la trace ne contenait pas `-Force` ; ne l'invente pas)
+ « confirmé que new_file_search n'existe pas » →
+ « new_file_search est introuvable dans les parties examinées de C:\\ et
+ D:\\ ; certains répertoires ont été ignorés sur Access denied ou à cause de la limite
+ de profondeur, l'investigation n'est donc que partiellement faite »
+ « des payloads identiques provoquent une fausse erreur de verrou » →
+ « le script de vérification supposait que le dernier écrivain est toujours un rang
+ fixe ; cette hypothèse ne tient pas, donc l'existence d'un bug de verrou
+ n'est toujours pas vérifiée »
+
+ N'enregistre PAS les salutations ni le pur bavardage. Si le segment n'a établi
+ absolument rien, produis "fact": null.
+
+files — 0..N chemins de FICHIERS OU DE RÉPERTOIRES, absolus ou relatifs au dépôt, réellement
+ manipulés ou examinés pendant cette session. Garde les racines examinées
+ comme `C:\\` et `D:\\`. N'inclus que les chemins réellement
+ consultés/fouillés, pas ceux simplement suggérés ou prévus ;
+ [] si aucun ne s'applique.
+
+═══════════════════════════════════════════════════════════════════
+CONTEXTE HÔTE (fourni par le SDK)
+═══════════════════════════════════════════════════════════════════
+- workspace_id présent : {workspace_present}
+- branche présente : {branch_present}
+
+Lorsqu'aucun workspace_id n'est présent, la solution ne peut pas s'appuyer sur un contexte
+local au projet non énoncé — précise tout dépôt / chemin / service nécessaire dans
+`solution` ou `boundary_envs` afin que le souvenir reste utilisable par lui-même.
+
+═══════════════════════════════════════════════════════════════════
+CONVERSATION
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+SORTIE (JSON strict uniquement, pas de markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "statement": "...",
+ "files": ["..."]
+ }}
+}}
+
+OBLIGATOIRE : tu DOIS produire au moins UNE expérience. Ne renvoie PAS une liste vide.
+Même si la tâche paraît simple ou a réussi du premier coup, capture quand même
+l'essence réutilisable de ce qui a été fait (la méthode / la commande / le mode opératoire). Seule
+la plus précieuse des expériences est requise lorsque la session est mince — mais ne produis jamais
+un tableau "experiences" vide.
+
+"fact" est un objet UNIQUE, jamais une liste — un enregistrement par session. Utilise
+"fact": null uniquement lorsque le segment n'est que du bavardage n'ayant rien établi.
+"""
+
+CODING_RECONCILE_PROMPT = """\
+Tu décides comment fusionner de nouveaux brouillons de souvenirs de code avec les souvenirs existants de l'utilisateur.
+
+Pour chaque nouveau brouillon, décide l'une des actions suivantes :
+ ADD — aucun souvenir existant ne décrit la même tâche/le même aspect
+ UPDATE — un souvenir existant décrit la même tâche ; le nouveau brouillon le remplace
+ (la solution peut avoir changé, l'environnement peut avoir été mis à jour, etc.)
+ SKIP — doublon d'un souvenir existant ; rien de nouveau
+
+En outre, tu peux émettre des opérations DELETE sur des candidats existants lorsque le nouveau
+contenu les rend obsolètes ou invalides :
+ DELETE — la nouvelle conversation remplace/annule/invalide EXPLICITEMENT un
+ souvenir existant qui ne peut pas être réparé via UPDATE. Exemples :
+ * l'utilisateur dit « n'utilise plus X » et X n'existe que sous forme de
+ souvenir séparé (pas celui en cours d'ajout/de mise à jour)
+ * les boundary_envs du candidat (service / endpoint / SDK) ont disparu
+ et la nouvelle conversation confirme leur abandon
+
+Règles :
+- « Même tâche » signifie que le souvenir existant et le nouveau brouillon seraient tous deux des réponses
+ valides à la même future requête de l'utilisateur.
+- Si la solution diffère, privilégie UPDATE (nous ne conservons pas d'historique).
+- Si la tâche et la solution correspondent toutes deux étroitement, SKIP.
+- DELETE uniquement lorsqu'il existe une preuve EXPLICITE que le candidat est invalide/obsolète.
+ Ne fais jamais de DELETE simplement parce qu'un candidat semble « périmé ».
+- Les opérations produites peuvent être plus nombreuses que les brouillons lorsque des DELETE sont produits.
+
+═══════════════════════════════════════════════════════════════════
+NOUVEAUX BROUILLONS
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+CANDIDATS EXISTANTS (par brouillon, retrouvés par similarité de tâche)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+SORTIE (JSON strict uniquement, pas de 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": "l'utilisateur a explicitement abandonné Y"}},
+ {{"draft_idx": 2, "action": "SKIP", "reason": "doublon"}}
+ ]
+}}
+
+S'il n'y a aucun brouillon, produis {{"ops": []}}.
+"""
+
+CODING_FACT_RECONCILE_PROMPT = """\
+Tu maintiens des FAITS DE TRAVAIL au niveau de la session. Chaque statement résume une
+trace/session entière : la tâche de l'utilisateur, l'approche générale et le résultat. Ce n'est pas une
+affirmation atomique.
+
+Chaque nouveau fait de session ci-dessous SERA stocké ; ce n'est pas ta décision. Ta seule
+tâche est de détecter la continuation d'une tâche : la nouvelle session continue-t-elle à faire avancer la
+MÊME tâche de l'utilisateur qu'un fait de session existant ? Si oui, fais un SUPERSEDE de l'ancien fait afin que
+les liens forment une chaîne de progression inter-sessions pour cette tâche.
+
+Marque un fait existant comme remplacé UNIQUEMENT lorsqu'il existe des preuves solides que :
+ - Les sujets correspondent : les deux enregistrements concernent la MÊME entité — la même
+ personne, le même fichier/module, le même hôte/service. Un sujet commun est
+ nécessaire mais pas suffisant ; ET
+ - L'objectif de l'utilisateur est substantiellement le MÊME, et pas simplement dans le même thème/projet ;
+ ET
+ - La nouvelle trace poursuit, réessaie, étend, vérifie ou termine le travail
+ consigné par la trace existante.
+
+Ne fais PAS de SUPERSEDE lorsque :
+ - Les deux enregistrements nomment des sujets différents. Deux personnes d'un même groupe, deux fichiers
+ d'un même module, deux hôtes d'un même cluster sont PARALLÈLES, pas successifs : l'état d'une
+ personne n'est pas une version plus récente de celui d'une autre. Lorsqu'un sujet est affiché
+ comme (unspecified), reviens à un jugement fondé sur le seul statement.
+ - Les sessions mentionnent simplement le même fichier, symbole, composant, dépôt,
+ erreur ou technologie, mais poursuivent des objectifs utilisateur différents.
+ - Une tâche ne fait que fournir du contexte ou une technique pour une autre tâche.
+ - La relation est incertaine. Sois prudent : INSERT est le choix sûr par défaut ;
+ fusionner des sessions sans rapport détruit leurs historiques de tâche distincts.
+
+Traite chaque statement comme un texte limité par ses preuves. Ne réinterprète pas une inférence
+qu'il contient comme une cause établie, et n'utilise pas une conjecture/erreur commune comme preuve que
+les objectifs de l'utilisateur sont les mêmes. Ta décision porte uniquement sur la continuation de la tâche ; ne
+« corrige », ne complète et n'embellis aucun des enregistrements de session.
+
+Exemples :
+ existant : « L'utilisateur devait corriger le npm run build de la CI ; problème attribué à
+ ERR_OSSL_EVP_UNSUPPORTED sous Node 18, workflow pas encore modifié. »
+ nouveau : « L'utilisateur a poursuivi la correction du même build CI ; a passé Node à 20 dans
+ .github/workflows/ci.yml et npm run build a réussi. »
+ → SUPERSEDE
+
+ existant : « L'utilisateur devait corriger la gestion de l'expiration des JWT dans
+ auth/middleware.ts ; une logique de rafraîchissement a été ajoutée. »
+ nouveau : « L'utilisateur devait ajouter une journalisation des performances à
+ auth/middleware.ts ; une métrique de latence a été introduite. »
+ → garder les deux
+ (même fichier/projet, objectif utilisateur différent)
+
+═══════════════════════════════════════════════════════════════════
+NOUVEAUX FAITS DE SESSION
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+FAITS DE SESSION EXISTANTS (par nouveau fait, retrouvés par similarité de statement)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+SORTIE (JSON strict uniquement, pas de markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "ops": [
+ {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "poursuit la même tâche de correction de la CI"}},
+ {{"draft_idx": 1, "supersedes": []}}
+ ]
+}}
+
+N'utilise que des ids de faits figurant dans la liste de candidats de ce même draft_idx.
+Si rien n'est remplacé nulle part, produis {{"ops": []}}.
+"""
+
+CODING_CHAIN_SUMMARY_PROMPT = """\
+Une tâche de l'utilisateur dans une base de mémoire de travail a progressé sur plusieurs sessions. Voici
+les résumés de session de la chaîne de progression de cette tâche, du plus ancien au plus récent, se terminant par
+la session actuelle.
+
+Résume comment la MÊME tâche a progressé d'une session à l'autre jusqu'à son état actuel.
+Couvre chaque étape importante dans l'ordre chronologique. Pour chaque étape, préserve
+lorsque c'est disponible : l'action ou le changement réel, son résultat direct, et tout
+problème non résolu ou condition limitante. Termine par un état actuel explicite.
+
+Règles :
+ - Il s'agit uniquement de compression. Ne rapporte QUE ce que disent les entrées ; n'ajoute ni ne
+ complète jamais une commande, une cause, un motif, une action, un résultat de test, un état de réussite ou une
+ conclusion négative globale.
+ - Préserve exactement le statut des preuves : tenté n'est pas terminé, observé n'est
+ pas vérifié, inféré n'est pas établi, et non résolu reste non résolu.
+ Garde les mots d'incertitude et les limites de recherche/permission/couverture.
+ - Énonce fidèlement l'état final actuel (terminé, partiellement terminé,
+ échoué, bloqué, ou toujours en attente de vérification). Ne le rehausse jamais sur la base
+ d'une histoire causale plausible ou d'une entrée ultérieure qui ne l'a pas vérifié.
+ - Lorsque des entrées mentionnent une cause soupçonnée et un résultat ultérieur, relie-les
+ causalement uniquement si une entrée dit directement que cette cause a été vérifiée.
+ - Préserve les ancres de recherche concrètes : chemins de fichiers, symboles, commandes, chaînes
+ d'erreur, versions, clés/valeurs de configuration et valeurs numériques importantes qui
+ comptent pour la progression.
+ - Pour les chaînes de 2 à 3 générations, ne compresse pas excessivement la progression en une seule
+ phrase. Préfère 2 à 4 paragraphes compacts lorsque c'est utile, ou une prose lisible avec
+ un objectif de tâche clair, une progression étape par étape et un état actuel.
+ - Ne recopie pas mécaniquement tout l'historique. Omets les répétitions et les détails
+ de faible valeur tout en conservant les actions importantes, les résultats directs et les éléments restants.
+ - N'invente pas de titres d'étape ni de dates. Ne mentionne une date que lorsque les entrées
+ lui donnent un sens ; les horodatages bruts sont du bruit.
+ - Si les entrées indiquent que des révisions plus anciennes ont été omises, indique explicitement que
+ l'historique antérieur a été omis ; ne laisse pas entendre que les entrées fournies sont complètes.
+ - Écris dans la même langue que celle des entrées.
+ - Pas de préambule ni de guillemets englobants.
+
+Exemple
+ entrées :
+ (2026-07-20) L'utilisateur devait corriger le npm run build de la CI ; problème attribué à
+ ERR_OSSL_EVP_UNSUPPORTED sous Node 18, workflow pas encore
+ modifié.
+ (2026-07-24) L'utilisateur a poursuivi cette correction de la CI ; a passé Node à 20 dans
+ .github/workflows/ci.yml, mais le cache des dépendances
+ reproduisait encore l'ancienne erreur.
+ (maintenant) L'utilisateur a poursuivi la vérification du même correctif ; après avoir vidé le
+ cache npm, npm run build a réussi.
+ sortie :
+ L'objectif de la tâche est de corriger le npm run build de la CI. Le problème a d'abord été attribué à
+ ERR_OSSL_EVP_UNSUPPORTED sous Node 18, sans que le workflow soit encore modifié ;
+ ensuite, .github/workflows/ci.yml a été passé à Node 20, mais le cache des dépendances
+ maintenait l'ancienne erreur. Enfin, après avoir vidé le cache npm,
+ npm run build a réussi, cette correction du build est donc actuellement vérifiée comme terminée.
+
+═══════════════════════════════════════════════════════════════════
+ENTRÉES
+═══════════════════════════════════════════════════════════════════
+{chain_block}
+
+═══════════════════════════════════════════════════════════════════
+SORTIE (le résumé lui-même, rien d'autre)
+═══════════════════════════════════════════════════════════════════
+"""
+
+
+# ================================================================
+# Episode / topic summaries
+# ================================================================
+
+EPISODE_SUMMARY_PROMPT = """Tu résumes UN épisode de conversation avec l'utilisateur.
+
+Un épisode est une seule séquence de discussion — une chose dont on a parlé,
+éventuellement sur plusieurs sessions d'écriture.
+
+## Souvenirs capturés pendant cet épisode (du plus ancien → au plus récent)
+
+{memories}
+
+---
+
+Écris un seul résumé dense de ce qui s'est passé / de ce qui a été discuté dans cet épisode.
+
+Règles :
+
+* 2 à 4 phrases, à la troisième personne, en commençant par « L'utilisateur ... » (ou par la personne nommée
+ si les souvenirs concernent quelqu'un d'autre).
+* Relie les souvenirs en un seul récit cohérent — un épisode a généralement un
+ fil conducteur (un projet, un problème, une sortie, une décision).
+* Préserve les détails concrets : noms, lieux, nombres, dates.
+* N'invente RIEN qui ne figure pas dans les souvenirs.
+* N'énumère PAS les souvenirs un par un ; synthétise-les.
+* La langue de sortie doit correspondre à la langue des souvenirs.
+
+Renvoie UNIQUEMENT le texte du résumé, sans préambule, sans JSON, sans guillemets."""
+
+TOPIC_SUMMARY_PROMPT = """Tu résumes tout ce que l'on sait sur UN thème.
+
+## Thème
+
+{topic_name}
+
+## Souvenirs relevant de ce thème (du plus ancien → au plus récent)
+
+{memories}
+
+---
+
+Écris un seul résumé dense de ce que l'on sait de l'utilisateur au regard de ce
+thème.
+
+Règles :
+
+* 2 à 4 phrases, à la troisième personne, en commençant par « L'utilisateur ... » (ou par la personne nommée
+ si les souvenirs concernent quelqu'un d'autre).
+* Couvre le thème dans son ensemble — énonce la situation actuelle, et ne mentionne son
+ évolution que lorsque le changement compte.
+* Préserve les détails concrets : noms, lieux, nombres, dates.
+* N'invente RIEN qui ne figure pas dans les souvenirs.
+* N'énumère PAS les souvenirs un par un ; synthétise-les.
+* La langue de sortie doit correspondre à la langue des souvenirs.
+
+Renvoie UNIQUEMENT le texte du résumé, sans préambule, sans JSON, sans guillemets."""
+
+
+# ================================================================
+# System 2 evolve (pipelines/system2_agent.py)
+# ================================================================
+
+SYSTEM2_AGENT_PROMPT = """Tu es un Agent de traitement cognitif. Ta mission est de faire émerger des structures cognitives d'ordre supérieur à partir des données de mémoire brutes d'un utilisateur.
+
+## Architecture de la mémoire
+
+### VDB (base de données vectorielle) — lecture seule
+| Couche | Description |
+|-------|-------------|
+| L0 BASIC_INFO | Attributs de l'utilisateur (nom, âge, profession) |
+| L1 RAW | Transcriptions de conversation d'origine |
+| L2 FACT | Faits atomiques extraits des conversations |
+| L3 SUMMARY | Résumés de session |
+| L4 IDENTITY | Traits d'identité, préférences, habitudes |
+| L5 KNOWLEDGE | Connaissances de domaine |
+
+### Graph (graphe de connaissances) — tu en es le seul rédacteur
+| Couche | Description |
+|-------|-------------|
+| L6 SCHEMA | Motifs de comportement — liés à un domaine, atomiques, immuables une fois créés |
+
+## Qu'est-ce qu'un Schema L6 ?
+
+Un Schema est un motif de comportement transversal aux événements dans le modèle de l'utilisateur à long terme, et
+comporte les trois composantes suivantes :
+
+
+- **Circonstance** : le domaine/thème/la situation dans lequel ce motif est observé. Un Schema DOIT rester dans sa circonstance — ne généralise PAS d'un domaine à l'autre. L'abstraction inter-domaines est gérée séparément par le système.
+- **Motif** : le comportement habituel, le mode de pensée ou la tendance d'action de l'utilisateur dans cette circonstance.
+- **Éclairage** : le moteur psychologique ou le modèle mental sous-jacent.
+
+### Format du contenu
+Utilise une seule phrase combinant les trois :
+« Lorsque [circonstance], l'utilisateur [motif] — ce qui reflète [éclairage]. »
+
+Pour les motifs durables liés aux émotions, à la thérapie, au stress, au deuil ou aux traumatismes, n'efface
+pas le contexte autobiographique précis au profit d'une étiquette de personnalité
+générique. Préfère une structure ancrée qui préserve :
+« Déclencheur/contexte -> réponse émotionnelle récurrente -> ressource d'adaptation observée. »
+N'inclus que les déclencheurs, réponses et ressources d'adaptation présents dans des preuves
+appartenant à l'utilisateur (user-owned). Les conseils de l'assistant ne sont pas une ressource d'adaptation observée chez l'utilisateur.
+
+### Règles
+- **Atomique** : un seul motif par Schema. Deux motifs distincts → deux Schemas.
+- **Immuable** : une fois créé, le contenu ne change JAMAIS.
+- **Preuves uniquement** : les nouveaux faits qui ne font que soutenir la formulation existante → appelle
+ `add_evidence`. Si de nouvelles preuves changent, corrigent ou restreignent substantiellement
+ l'état durable actuel, utilise `revise_schema` afin que l'ancienne version soit conservée pour
+ l'audit mais retirée de la recherche active.
+- **Lié à un domaine** : reste dans le domaine observé. L'abstraction inter-domaines est gérée par un processus système distinct.
+- **Sépare les faits des motifs** : une identité explicite isolée, un état de santé,
+ l'usage d'un équipement, une affiliation, un projet ou une préférence relève de la mémoire d'état L2,
+ pas de L6. L6 exige des preuves appartenant à l'utilisateur représentant au moins deux
+ écritures raw ou sessions indépendantes. Un seul fait L2 réconcilié peut représenter plusieurs écritures ;
+ examine ses source_raw_memory_ids plutôt que de compter les nœuds de faits.
+- **Sécurité du sujet** : des faits partageant un même fragment source peuvent décrire d'autres personnes ou
+ des exemples. Ne crée un Schema de l'utilisateur que lorsque le matériel attribue explicitement
+ le motif à l'utilisateur. Sinon, ne produis aucune opération pour ce matériel.
+- **Couverture des candidats** : dans une revue source-context, rends compte de chaque fait
+ candidat listé : soit utilise-le comme preuve dans `create_schema`/`add_evidence`,
+ soit émets `skip_fact`. Le contexte raw peut confirmer son sujet ou restituer un détail
+ omis, mais ne doit pas amorcer des Schemas sans rapport.
+- **Seuil de preuve** : créer un L6 exige un ou plusieurs faits de preuve appartenant à l'utilisateur
+ représentant au moins deux écritures raw ou sessions indépendantes.
+ Les conseils de l'assistant n'établissent pas à eux seuls un motif de l'utilisateur.
+
+### Bons et mauvais exemples
+✅ « Lorsqu'il cuisine, l'utilisateur suit strictement les étapes de la recette et mesure précisément les ingrédients — ce qui reflète un besoin de structure externe pour gérer l'incertitude. »
+✅ « Lorsqu'il joue aux jeux vidéo, l'utilisateur consulte toujours des soluces pour atteindre 100 % de complétion — motivé par une faible tolérance à l'inachevé. »
+✅ « Après la perte inattendue d'un mentor, les rappels de la mort peuvent raviver soudainement le deuil ; l'utilisateur fait une pause pour réfléchir et fait des promenades au calme pour retrouver son équilibre. »
+❌ « L'utilisateur aborde la musique comme un moyen de synthèse créative et de rapprochement culturel, mêlant constamment diverses traditions musicales... » (plusieurs motifs fusionnés, trop large)
+❌ « L'utilisateur est passionné par beaucoup de choses et accorde de l'importance à la qualité. » (aucune circonstance, trop vague)
+❌ « L'utilisateur est guidé par le sens et résilient. » (efface le déclencheur durable et les preuves d'adaptation observées)
+
+## Ton flux de travail
+
+Matériaux d'entrée (tu n'es invoqué que lorsqu'au moins un cluster existe) :
+- **Résultats de clustering** : entrée principale — faits regroupés par similarité sémantique
+- **Faits non regroupés (complément)** : faits n'appartenant à aucun cluster ; priorité inférieure aux résultats de clustering
+
+Pour chaque groupe de faits (regroupés ou non) :
+1. **Recherche les Schemas existants** : si un Schema existant capture déjà ce motif, appelle `add_evidence`. Utilise `revise_schema` uniquement lorsque l'ancienne formulation deviendrait substantiellement incomplète ou trompeuse après l'ajout des nouvelles preuves.
+2. **Crée un nouveau Schema** : uniquement si aucun Schema existant ne couvre ce motif. Une phrase, trois composantes.
+3. **Établis des relations** : si deux Schemas sont thématiquement liés, utilise `add_edge` (RELATED_TO).
+
+## Principes
+
+- Toutes les opérations sur le Graph DOIVENT passer par les tools
+- Le contenu d'un Schema est IMMUABLE — ne recrée jamais ce qui existe déjà
+- Préfère `add_evidence` à la création de doublons
+- Préfère ne rien créer plutôt que de créer des nœuds de faible qualité
+- Un Schema = un motif atomique dans un domaine
+- Pour les tags, préfère réutiliser les tags de la liste des tags existants"""
+
+
+# ================================================================
+# Fragments assembled in code
+# ================================================================
+
+# Display name of this language, used in logs and docs.
+LANGUAGE_NAME = "Français"
+
+# 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, so their prompts stay exactly as before.
+OUTPUT_LANGUAGE_DIRECTIVE = """
+
+---
+
+# LANGUE DE SORTIE
+
+Rédige en français chaque valeur en langage naturel que tu produis (texte des souvenirs, résumés, justifications, requêtes), quelle que soit la langue utilisée par la conversation ou par les souvenirs existants. Cette règle prime sur toute règle ci-dessus demandant de suivre la langue d'entrée. Conserve exactement tels quels les clés JSON, les noms de champs, les valeurs d'énumération, les noms d'opérations, les ID, le code, les chemins de fichiers, les commandes, les messages d'erreur et les noms propres.
+"""
+
+# 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"# DEUX TYPES DE MÉMOIRE.*?(?=\n# OWNER)"
+
+NO_INTENTION_MEMORY_SECTION = (
+ "# MÉMOIRE\n"
+ "\n"
+ "Tu extrais un seul type de mémoire : **memory** (souvenirs).\n"
+ "\n"
+ "## memory\n"
+ "\n"
+ "Tout ce qui est durable et mérite d'être retenu au sujet de l'utilisateur — et de\n"
+ "toute autre personne nommée dans la conversation — va ici :\n"
+ "\n"
+ "* préférences, opinions, valeurs, attitudes\n"
+ "* événements, actions, expériences\n"
+ "* habitudes, motifs de comportement\n"
+ "* relations, traits\n"
+ "* faits objectifs, décisions, contraintes\n"
+ "* activités en cours\n"
+ "* **projets futurs / actions à venir** qui méritent d'être retenus\n"
+ " (mets-les dans `memory` ; n'invente PAS de catégorie intentions séparée)\n"
+ "\n"
+ "Les préférences implicites DOIVENT être inférées lorsqu'elles sont fortement suggérées.\n"
+ "\n"
+ "Ne sépare PAS « quel genre de personne est l'utilisateur » de « ce qui s'est passé ».\n"
+ "Les deux vont dans `memory`.\n"
+ "\n"
+ "---\n"
+ "\n"
+)
+
+# (old, new) pairs applied in order after the section swap.
+NO_INTENTION_REPLACEMENTS = (
+ (
+ "Chaque souvenir et chaque intention DOIT porter un `owner`",
+ "Chaque souvenir DOIT porter un `owner`",
+ ),
+)
+
+INTENTION_DISABLED_NOTE = (
+ "\n\n---\n\n# INTENTIONS DÉSACTIVÉES\n"
+ "L'extraction des intentions est désactivée. Même si les exemples few-shot montrent "
+ "`intentions`, n'émets **pas** cette clé ; mets les projets futurs dans `memory`.\n"
+)
+
+# Coding / working extractor: wraps the history and the new messages.
+CODING_CONVERSATION_BLOCK = (
+ "5 DERNIERS TOURS DE L'UTILISATEUR (CONTEXTE UNIQUEMENT ; ne les extrais pas à nouveau) :\n"
+ "{history}"
+ "\n\nNOUVEAUX MESSAGES (extrais uniquement à partir de cette écriture complète) :\n"
+ "{new}"
+)
+CODING_EMPTY_BLOCK = "(aucun)"
+
+# 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 = "Le nom de l'utilisateur est {name}"
+
+# System 2 single-call mode: output contract appended to SYSTEM2_AGENT_PROMPT.
+SYSTEM2_OUTPUT_INSTRUCTIONS = """
+
+## Format de sortie
+
+N'appelle PAS de tools. Produis directement un tableau JSON d'opérations, entouré d'un bloc de code ```json.
+
+Opérations disponibles :
+
+1. **create_schema** — Crée un nouveau Schema comportemental L6
+ ```{"op": "create_schema", "schema_kind": "behavior_pattern", "content": "motif concis lisible par l'utilisateur", "retrieval_text": "comportement et situations pertinentes", "evidence_list": ["fact_node_id_1", "fact_node_id_2"], "tags": ["tag1"]}```
+
+2. **add_evidence** — Ajoute des preuves à un Schema existant (le contenu reste immuable)
+ ```{"op": "add_evidence", "node_id": "existing_schema_node_id", "evidence_list": ["new_fact_id_1"]}```
+
+3. **revise_schema** — Crée une nouvelle version lorsque de nouvelles preuves changent substantiellement l'état actuel, et retire l'ancienne version de la recherche active. Ne l'utilise pas pour un détail compatible.
+ ```{"op": "revise_schema", "node_id": "old_schema_id", "schema_kind": "explicit_state", "content": "profil actuel mis à jour", "retrieval_text": "texte de recherche mis à jour", "evidence_list": ["new_fact_id_1"], "tags": ["tag1"], "reason": "pourquoi l'ancienne formulation induirait en erreur"}```
+
+4. **add_edge** — Crée une relation entre deux Schemas
+ ```{"op": "add_edge", "source_id": "schema_id_1", "target_id": "schema_id_2", "reason": "raison de la relation"}```
+
+5. **skip_fact** — Marque explicitement un fait candidat comme examiné sans créer
+ de Schema. À utiliser uniquement pour des faits concernant une autre personne, des événements passagers, des conseils de
+ l'assistant qui n'établissent pas un trait de l'utilisateur, ou des faits déjà entièrement couverts.
+ ```{"op": "skip_fact", "node_id": "candidate_fact_id", "reason": "pas un motif durable de l'utilisateur"}```
+
+## Contrat de sortie
+
+1. La sortie DOIT être un tableau JSON entouré d'un bloc de code ```json.
+2. Si les données sont insuffisantes pour des conclusions fiables, produis `[]`. Dans une
+ revue source-context, `[]` signifie que chaque candidat de cette revue a été examiné
+ et qu'aucun ne soutient un Schema durable.
+3. AUCUN texte en dehors du bloc de code.
+4. Les ID de evidence_list doivent provenir des node_ids de faits fournis dans les matériaux.
+5. Le node_id de add_evidence / revise_schema doit provenir des ID de nœuds existants du Graph.
+6. Pour une revue source-context, chaque fait candidat doit apparaître dans une evidence_list ou dans un skip_fact."""
+
+# Appended to SYSTEM2_OUTPUT_INSTRUCTIONS when the schema evidence gate is on.
+SYSTEM2_SCHEMA_EVIDENCE_GATE = """
+
+7. L6 représente uniquement des motifs de comportement transversaux aux événements. create_schema doit utiliser des preuves appartenant à l'utilisateur (user-owned) représentant au moins deux écritures raw ou sessions indépendantes. Un seul fait réconcilié peut suffire lorsque source_raw_memory_ids contient plusieurs écritures indépendantes.
+8. Ne crée pas de L6 pour une identité explicite isolée, un état de santé, l'usage d'un équipement, une affiliation, un projet ou une préférence. La projection d'état L2 canonique est responsable de ces faits."""
+
+# (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
+# (or be harmless if it does not).
+SYSTEM2_SINGLE_CALL_REPLACEMENTS = (
+ ("- Toutes les opérations sur le Graph DOIVENT passer par les tools\n", ""),
+ ("appelle `add_evidence`", "utilise l'opération add_evidence"),
+ ("utilise `add_edge` (RELATED_TO)", "utilise l'opération add_edge"),
+)
+
+# System 2 user message (materials). Keys are fixed; values are format
+# strings with the named fields shown.
+SYSTEM2_MATERIALS = {
+ "title": "## Matériaux prétraités\n",
+ "stats": (
+ "### Statistiques\n- Total des faits VDB : {total}\n"
+ "- Faits nouveaux (à traiter) : {fresh} (exclus_car_déjà_en_preuve={evidenced})\n"
+ "- Clusters trouvés : {clusters}\n"
+ "- Faits dans des clusters : {clustered}, complément non regroupé : {unclustered}\n"
+ "- Total des Schemas du Graph : {graph_total} (rappelés={recalled})"
+ ),
+ "graph_status_empty": "- État du Graph : **VIDE** (premier traitement cognitif)\n",
+ "clusters_header": "### Résultats de clustering\n",
+ "label_holistic": "{n} faits utilisateur inter-sessions ; uniquement des motifs émotionnels/thérapeutiques durables étayés par des preuves",
+ "label_source_context": "{n} faits candidats ; l'écriture raw sert uniquement à valider le sujet/les détails",
+ "label_topic": "{n} faits, thème",
+ "raw_label": "Extrait raw pertinent par candidat",
+ "holistic_note": (
+ "Il s'agit d'une seule passe nocturne de consolidation holistique, bornée. Crée au plus "
+ "{max_schemas} Schemas thérapeutiques ancrés. "
+ "Privilégie l'association d'un déclencheur/contexte durable, d'une réponse émotionnelle récurrente "
+ "et d'une ressource d'adaptation observée ou d'une contrainte de décision provenant d'écritures raw/sessions différentes. "
+ "Avant create_schema, fais l'union des raw_sources de ses ID de preuve et exige au moins deux "
+ "ID de source raw distincts ; deux faits issus d'une même écriture raw constituent un seul événement. "
+ "Produis [] lorsque les preuves sont insuffisantes.\n"
+ ),
+ "companion_header": "**Indices compagnons de sources indépendantes (candidats, pas conclusions) :**",
+ "unclustered_header": "### Faits non regroupés (complément)\n",
+ "unclustered_hint": "Les faits ci-dessous n'ont été regroupés dans aucun cluster ci-dessus. Examine-les après les thèmes des clusters ; priorité inférieure aux résultats de clustering.\n",
+ "forward_header": "### Nœuds du Graph liés (retrouvés par recherche sur le centroïde des clusters, {count} résultats)\n",
+ "graph_empty": "### Nœuds existants du Graph\nLe Graph est actuellement VIDE — c'est le premier traitement cognitif. Ne fais PAS de recherche dans le Graph (elle ne renverrait rien). Passe directement à la création de Schemas à partir des résultats de clustering.\n",
+ "graph_no_recall": (
+ "### Nœuds existants du Graph\n"
+ "Le Graph contient {graph_total} Schemas, "
+ "mais le rappel vectoriel par centroïde n'a trouvé aucune correspondance. Décide à partir des résultats de clustering si de nouveaux Schemas sont nécessaires.\n"
+ ),
+ "reverse_header": "### Références inverses du Graph (faits VDB référencés par des Schemas existants)\n",
+ "tags_header": "### Tags existants (préfère les réutiliser plutôt que de créer des synonymes)\n",
+ "closing": (
+ "Analyse les matériaux ci-dessus et produis un tableau JSON d'opérations. "
+ "Décide s'il faut créer de nouveaux Schemas ou ajouter des preuves aux Schemas existants. "
+ "Si les données sont insuffisantes pour des conclusions fiables, produis un tableau vide `[]`. "
+ "Pour les tags, préfère réutiliser les tags de la liste des tags existants ci-dessus."
+ ),
+}
diff --git a/hy_memory/prompts/id.py b/hy_memory/prompts/id.py
new file mode 100644
index 0000000..0386cd5
--- /dev/null
+++ b/hy_memory/prompts/id.py
@@ -0,0 +1,2312 @@
+# -*- coding: utf-8 -*-
+"""Bahasa Indonesia prompts (``id``).
+
+Translated from en.py; native-speaker review recommended.
+"""
+
+
+# ================================================================
+# Chat extraction (agent/extractor.py)
+# ================================================================
+
+EXTRACT_SYSTEM_PROMPT = """# PERAN
+
+Anda adalah Pengekstrak Memori (Memory Extractor).
+
+Ekstrak memori yang tahan lama dan bernilai tinggi dari percakapan, lalu ubah menjadi pernyataan terstruktur yang dapat berdiri sendiri.
+
+Hanya ekstrak informasi yang kemungkinan besar akan berguna dalam percakapan di masa mendatang.
+
+---
+
+# MASUKAN
+
+Anda akan menerima:
+
+* k Pesan Terakhir
+* Pesan Baru
+* Memory Date
+* Current Date
+
+Gunakan:
+
+* k Pesan Terakhir hanya untuk resolusi koreferensi
+* Memory Date sebagai SATU-SATUNYA jangkar waktu
+* Current Date hanya sebagai metadata, jangan pernah untuk menyelesaikan waktu relatif
+
+---
+
+# APA YANG DIEKSTRAK
+
+Ekstrak HANYA informasi yang benar-benar baru yang muncul dalam pesan pengguna yang BARU.
+
+Memori yang baik meliputi:
+
+* preferensi
+* proyek jangka panjang
+* kebiasaan
+* tujuan
+* aktivitas yang berulang
+* opini
+* hubungan
+* pengalaman penting
+* sifat yang stabil
+* rencana masa depan
+* keputusan
+* batasan
+* rekomendasi yang diterima
+
+JANGAN ekstrak:
+
+* basa-basi
+* ucapan konfirmasi singkat
+* emosi umum
+* konteks percakapan yang bersifat sementara
+* pengingat asisten tentang memori lama
+* informasi yang sudah tersirat dari konteks sebelumnya
+* penilaian kepribadian yang samar
+
+---
+
+# SUBJEK
+
+Setiap memori harus dapat berdiri sendiri, ditulis dalam sudut pandang orang ketiga, dengan
+subjek yang eksplisit. Subjek mana yang dipakai ditentukan oleh **siapa yang berbicara**:
+
+| Pembicara | Subjek yang ditulis | Contoh |
+| --- | --- | --- |
+| `role: "user"` | pengguna | "Pengguna ..." / "The user ..." / "用户..." |
+| pembicara mana pun dengan `name` selain pengguna (mis. `name: "John"`) | orang tersebut, dengan namanya | "John ..." |
+| `role: "assistant"` TANPA `name` | asisten AI | "Asisten ..." |
+
+Kedua bagian masukan menyatakan pembicara dengan cara berbeda:
+
+* **Pesan Baru** adalah array JSON — baca `role` dan field `name` yang opsional.
+* **k Pesan Terakhir** adalah teks yang sudah dirender — pembicaranya adalah label dalam kurung siku,
+ `[user]:` / `[John]:` / `[assistant]:`, dan dapat diawali satu baris
+ "Nama pengguna adalah Tim" / "The user's name is Tim" / "用户名叫Tim".
+
+Aturan:
+
+* Pengguna adalah orang pemilik memori-memori ini. Meskipun nama pengguna sendiri
+ diketahui (dari `name` pada pesannya, atau dari baris nama di awal), tetap
+ tulis "Pengguna ...", JANGAN PERNAH "Tim ...".
+* **`role: "assistant"` YANG memiliki `name` adalah orang nyata lain, bukan AI.**
+ Tulis memorinya dengan namanya sebagai subjek: "John ...".
+* Hanya `role: "assistant"` tanpa nama yang merupakan asisten AI.
+* Jangan pernah mengarang nama untuk asisten AI; ia tidak punya nama.
+
+---
+
+# ATURAN BAHASA
+
+* Bahasa keluaran harus sama dengan bahasa masukan.
+* Pertahankan aksara asli dan istilah teknis persis seperti aslinya.
+* Jangan pernah mentransliterasi nama, merek, atau persamaan.
+
+---
+
+# DUA JENIS MEMORI
+
+Anda mengekstrak dua jenis memori: **memory** dan **intentions**.
+
+## memory
+
+Segala hal yang tahan lama dan layak diingat tentang pengguna — dan tentang orang lain
+yang disebut namanya dalam percakapan — masuk ke sini:
+
+* preferensi, opini, nilai, sikap
+* peristiwa, tindakan, pengalaman
+* kebiasaan, pola perilaku
+* hubungan, sifat
+* fakta objektif, keputusan, batasan
+* aktivitas yang sedang berlangsung
+
+Preferensi implisit WAJIB disimpulkan bila tersirat dengan kuat
+(mis. melanjutkan kembali suatu aktivitas → minat positif; menghindari sesuatu →
+preferensi negatif; upaya sukarela yang berulang → minat yang berkelanjutan).
+
+JANGAN pisahkan "orang seperti apa pengguna itu" dari "apa yang terjadi".
+Keduanya masuk ke `memory`.
+
+## intentions
+
+Sesuatu yang berorientasi ke depan, yang pengguna **rencanakan atau niatkan untuk dilakukan di masa mendatang**,
+yang dapat ditindaklanjuti dan menjadi tidak relevan setelah selesai atau terlewat.
+
+Contoh:
+
+* "Pengguna memiliki wawancara kerja Selasa depan."
+* "Pengguna berencana pindah apartemen pada akhir bulan."
+* "Pengguna berniat menyelesaikan laporan sebelum hari Jumat."
+
+BUKAN intention (ini masuk ke `memory`):
+
+* preferensi / sifat yang stabil ("Pengguna suka bola basket")
+* peristiwa masa lalu yang sudah selesai ("Pengguna pindah ke Beijing tahun lalu")
+* tujuan umum tanpa langkah masa depan yang dapat ditindaklanjuti
+
+### valid_until
+
+Untuk setiap intention, berikan `valid_until`: tanggal setelah mana
+intention tersebut tidak lagi penting (tenggat / tanggal target), yang diselesaikan
+berdasarkan **Memory Date** (mis. "Selasa depan" → tanggal absolut tersebut).
+Jika tenggat tidak dapat ditentukan, isi `valid_until` dengan `null`.
+
+---
+
+# OWNER
+
+Setiap memory dan intention WAJIB memiliki `owner` yang menyatakan ke penyimpanan memori mana
+item itu termasuk. Hanya ada tepat dua nilai:
+
+* `"user"` — apa pun yang termasuk dalam penyimpanan memori milik pengguna sendiri. Ini mencakup
+ fakta/preferensi/sifat tentang pengguna itu sendiri, DAN fakta tentang orang nyata lain
+ yang disebut namanya dalam percakapan, karena hal-hal itu tetap merupakan sesuatu yang
+ seharusnya disimpan oleh memori pengguna.
+* `"agent"` — informasi yang diberikan oleh asisten AI (sebuah `role: "assistant"` tanpa nama)
+ (rekomendasi, konfirmasi, hal-hal yang ia teliti), atau tindakan di masa mendatang
+ yang pengguna ingin dilakukan oleh **asisten** ("ingatkan saya 8 jam lagi").
+
+Orang yang memiliki nama TIDAK PERNAH `owner: "agent"` — ia orang nyata, bukan AI,
+meskipun pesannya membawa `role: "assistant"`. Memorinya adalah
+`owner: "user"` dengan namanya sebagai subjek konten.
+
+Tentukan `owner` per item. Jika ragu, gunakan default `"user"`.
+
+---
+
+# ATURAN WAKTU
+
+Selesaikan waktu relatif menggunakan Memory Date.
+
+Contoh:
+
+* "minggu depan"
+* "bulan lalu"
+* "besok"
+
+Jika waktu tidak dapat diselesaikan dengan aman:
+
+* hapus ungkapan waktu relatif
+* biarkan memori tanpa keterangan waktu
+
+Jangan mengarang kronologi.
+
+**Peristiwa yang baru saja terjadi tetaplah peristiwa — simpan.** Ketika pengguna melaporkan sesuatu yang
+baru saja selesai ("baru pulang", "baru selesai", "tadi pagi", "kemarin"), tanggal
+selesainya adalah Memory Date. Tuliskan **peristiwa itu sendiri** beserta tanggal tersebut; jangan
+meleburkannya ke dalam pernyataan latar belakang.
+
+* "Saya baru pulang dari liburan bersama keluarga"
+ → "Pengguna pulang dari liburan keluarga pada <Memory Date>."
+ BUKAN → "Pengguna suka berlibur bersama keluarga." (tanggal kepulangan adalah jawaban atas "kapan
+ mereka pulang", dan membuangnya membuat pertanyaan itu tidak dapat dijawab)
+
+Jika suatu peristiwa memiliki awal dan akhir yang disebutkan secara terpisah dalam percakapan,
+catat keduanya alih-alih meleburkannya menjadi satu rentang.
+
+---
+
+# ATURAN KUALITAS
+
+Setiap memori harus:
+
+* dapat berdiri sendiri
+* lengkap secara konteks
+* mudah ditemukan kembali (retrieval-friendly)
+* padat informasi
+
+Pertahankan detail penting:
+
+* nama
+* produk
+* lokasi
+* angka
+* persamaan
+* batasan
+
+Jangan pernah menggeneralisasi hal yang spesifik menjadi sebuah kategori. Tulis apa yang benar-benar dikatakan.
+
+* "Banff" → tetap "Banff", BUKAN "Pegunungan Rocky"
+* "seekor border collie berumur 3 tahun bernama Luna" → pertahankan ras, umur, dan namanya
+
+**Detail spesifik yang diberikan oleh pembicara lain tetap dihitung.** Sebuah fakta sering terbentuk lintas
+giliran bicara: pembicara lain menyebutkan hal tersebut, pengguna mengonfirmasinya. Aturan subjek
+menentukan memori *milik siapa* itu — aturan tersebut tidak membenarkan pembuangan detail.
+
+* [Sam]: "Apakah kamu sempat main ski di Banff?"
+ [user]: "Iya, tempatnya bagus banget buat main ski!"
+ → "Pengguna bermain ski di Banff dan merasa saljunya luar biasa."
+ BUKAN → "Pengguna menyukai olahraga musim dingin." (tempat dan aktivitasnya sama-sama
+ sudah ditetapkan, masing-masing oleh satu pembicara)
+
+Hindari memori yang terpotong-potong dan kurang konteks.
+
+Pilih jumlah memori sesedikit mungkin yang tetap mempertahankan kebutuhan
+pencarian yang berbeda di masa mendatang.
+
+* Pemadatan berarti menggabungkan, bukan menghilangkan. Setiap proposisi eksplisit yang tahan lama
+ dalam pesan baru harus muncul tepat satu kali dalam keluaran.
+* Gabungkan detail bila memiliki subjek yang sama dan peristiwa, keadaan, preferensi,
+ rencana, atau keputusan dunia nyata yang sama. Satu peristiwa yang koheren boleh memakai 1–3 kalimat.
+* Jangan menuliskan sekaligus pernyataan yang luas dan pernyataan ulang yang lebih sempit dari bukti yang sama.
+* Pisahkan hanya bila subjeknya berbeda, peristiwanya terjadi secara independen, atau
+ memorinya menggambarkan keadaan yang berbeda.
+* Simpan sebab, rekomendasi, atau akibat bersama fakta yang dijelaskannya bila
+ memisahkannya akan menghilangkan hubungan tersebut.
+* Jangan pernah menggabungkan kejadian bertanggal yang terpisah hanya karena topiknya sama.
+* Pertahankan presisi waktu dari sumbernya. Jangan ubah frasa samar seperti "akhir pekan
+ lalu" atau "musim panas lalu" menjadi tanggal kalender yang pasti kecuali tanggalnya eksplisit
+ atau dapat ditentukan secara unik; "akhir pekan sebelum <Memory Date>" dapat diterima.
+
+---
+
+# TAGS
+
+Setiap memori harus menyertakan 1–3 tag yang ringkas.
+- Kata kunci topik tetap huruf kecil (travel, health, work).
+- Nama diri mempertahankan huruf kapital (Jasper, Canada, Banff, Prius).
+
+Contoh:
+
+* work
+* travel
+* Jasper
+* Canada
+* health
+
+---
+"""
+
+STRUCTURE_METADATA_PROMPT = """
+
+---
+
+# ORGANISASI STRUKTURAL
+
+Untuk setiap `memory`, keluarkan juga:
+
+* `topic_paths`: daftar yang kompatibel dengan versi lama berisi nol hingga tiga jalur
+ semantik dari yang luas ke yang spesifik.
+* `event_facet`: objek yang hanya berisi `subject`, `participants`, `action`,
+ `objects`, `locations`, dan `state`; state bernilai `planned`, `ongoing`,
+ `completed`, atau `unknown`.
+* `topic_assignments`: nol hingga enam keanggotaan yang spesifik per subjek. Setiap item adalah
+ `{subject, role, path}`, dengan `path` berupa daftar segmen `{name, type}` dan
+ `type` salah satu dari `topic`, `facet`, `series`, atau `episode`. Gunakan `topic` untuk
+ domain yang luas, `facet` untuk aktivitas konkret/aspek semantik, `series` hanya
+ untuk kejadian berulang dari garis aktivitas/keadaan konkret yang sama, dan
+ `episode` hanya untuk satu kejadian dunia nyata yang berbatas. Sebuah peristiwa bersama boleh memiliki
+ satu assignment per partisipan eksplisit sambil tetap mempertahankan satu memori kanonis.
+ Urutan type mengikuti `topic -> facet -> series -> episode`; tingkatan boleh dilewati tetapi
+ type tidak boleh berulang atau mundur.
+
+Pengekstrak ini hanya melihat penulisan saat ini sehingga tidak boleh mengeluarkan
+segmen `series`. Keluarkan Topic/Facet/Episode di sini. Tahap reconcile nanti dapat menetapkan
+Series setelah membandingkan kejadian-kejadian independen yang sudah tersimpan.
+
+Ini adalah organisasi pada saat penulisan. Jangan menyimpulkan Series/Episode dari kedalaman jalur,
+jangan membuat hierarki dari nama diri atau tag yang luas, dan jangan menetapkan seseorang hanya
+karena ia muncul bersamaan dalam konteks yang tidak berkaitan. Berhentilah pada tingkat paling spesifik
+yang didukung dan gunakan nilai kosong bila ragu. Jangan pernah menyandikan bentuk kueri seperti
+"kapan", "berapa banyak", "siapa", bentuk jamak, atau kata urutan.
+"""
+
+EXTRACT_FEW_SHOT = """
+---
+
+# CONTOH
+
+## Contoh 1 — Batasan: konteks lama hanya untuk resolusi, tidak pernah diekstrak ulang
+
+k Pesan Terakhir:
+[{"role": "user", "content": "Aku lagi lihat-lihat anjing adopsi di penampungan hewan di pusat kota."},
+ {"role": "assistant", "content": "Wah, menyenangkan sekali — sudah ketemu yang kamu suka?"}]
+Pesan Baru:
+[{"role": "user", "content": "Iya, kemarin aku jemput dia — border collie umur 3 tahun namanya Luna."}]
+Memory Date: 2025-04-10
+
+Keluaran:
+```json
+{
+ "memory": [
+ {"content": "Pengguna mengadopsi seekor border collie berumur 3 tahun bernama Luna dari penampungan hewan di pusat kota pada 2025-04-09.", "tags": ["pets", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Pesan lama hanya menyelesaikan rujukan "dia" dan memberikan konteks ("penampungan hewan di pusat kota"). JANGAN keluarkan memori basi seperti "pengguna sedang mempertimbangkan untuk mengadopsi anjing" — hanya fakta yang benar-benar baru (adopsi yang sudah terjadi) yang diekstrak, dengan "kemarin" diselesaikan berdasarkan Memory Date.
+
+## Contoh 2 — Ringkas balasan asisten yang panjang
+
+Pesan Baru:
+[{"role": "user", "content": "Tolong tuliskan esai singkat tentang mengapa kerja jarak jauh meningkatkan produktivitas."},
+ {"role": "assistant", "content": "Tentu — pembuka: 'Kerja jarak jauh telah mengubah cara tim bekerja...' [~2000 kata isi dihilangkan] ...penutup: 'Singkatnya, otonomi dan berkurangnya gangguan mendorong hasil kerja yang lebih tinggi.'"}]
+Memory Date: 2025-03-22
+
+Keluaran:
+```json
+{
+ "memory": [
+ {"content": "Asisten menyusun esai singkat untuk pengguna yang berargumen bahwa kerja jarak jauh meningkatkan produktivitas karena otonomi dan berkurangnya gangguan mendorong hasil kerja yang lebih tinggi.", "tags": ["writing", "remote-work"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Balasan asisten panjang. Jangan pernah menyimpan esai secara utuh kata per kata — saring menjadi topik + tesis. owner adalah "agent" karena asistenlah yang menghasilkannya. Konten kata per kata yang membengkak membuat memori tidak dapat digunakan.
+
+## Contoh 3 — Ekstraksi gabungan: basic_info + intention + rencana agent yang diringkas
+
+Pesan Baru:
+[{"role": "user", "content": "Halo, saya Kenji. Saya berencana jalan-jalan ke Jepang bulan depan — bisa tolong buatkan itinerary 7 hari?"},
+ {"role": "assistant", "content": "# Rute Emas Klasik Jepang 7 Hari (Tokyo → Kyoto → Nara → Osaka)\\nTerbang ke Tokyo, naik Shinkansen ke selatan menuju Kyoto, perjalanan sehari ke Nara, pulang dari Osaka (Kansai).\\n\\n## Hari 1: Tiba di Tokyo\\n- Mendarat di Haneda/Narita, titip tas di hotel dekat Stasiun Tokyo.\\n- Sore hari: Kuil Sensoji (Asakusa), jalan-jalan di Jalan Nakamise, coba taiyaki.\\n- Malam: Shibuya Crossing + rooftop Shibuya Sky untuk matahari terbenam; makan malam di izakaya (yakitori, sake).\\n\\n## Hari 2: Pasar & landmark Tokyo — [dihilangkan]\\n## Hari 3: Shinkansen ke Kyoto, Fushimi Inari, Gion — [dihilangkan]\\n## Hari 4: Kuil-kuil Kyoto (Kiyomizu-dera, Kinkaku-ji, Ginkaku-ji) — [dihilangkan]\\n## Hari 5: Perjalanan sehari ke Nara (rusa Taman Nara, Todai-ji) — [dihilangkan]\\n## Hari 6: Osaka (Kastel Osaka, jajanan kaki lima Dotonbori) — [dihilangkan]\\n## Hari 7: Wisata Osaka + berangkat dari Bandara Kansai — [dihilangkan]\\n\\nTips: beli JR Pass 7 hari sebelum tiba. Ada yang ingin disesuaikan?"}]
+Memory Date: 2025-09-15
+
+Keluaran:
+```json
+{
+ "memory": [
+ {"content": "Asisten membuat itinerary 7 hari ke Jepang untuk pengguna dengan rute emas klasik: Tokyo (Asakusa, Shibuya), Shinkansen ke Kyoto (Fushimi Inari, Kiyomizu-dera, Kinkaku-ji, Gion), perjalanan sehari ke Nara (taman rusa, Todai-ji), lalu Osaka (Kastel Osaka, Dotonbori), berangkat pulang dari Bandara Kansai.", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
+ ],
+ "intentions": [
+ {"content": "Pengguna berencana melakukan perjalanan 7 hari ke Jepang pada Oktober 2025.", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
+ ],
+ "basic_info": {"name": "Kenji"}
+}
+```
+Satu giliran bicara menghasilkan tiga keluaran di wadah yang berbeda: nama masuk ke basic_info, perjalanan adalah intention berorientasi ke depan dengan tenggat, dan itinerary panjang multi-bagian dari asisten diringkas menjadi SATU memori agent yang padat — rute dan persinggahan utama per kota, BUKAN poin-poin harian, tips, atau daftar makanan. Menyimpan seluruh balasan kata per kata akan membuat memori membengkak; menyimpan kerangkanya membuatnya tetap dapat dikueri.
+
+## Contoh 4 — Pesan selanjutnya yang mengonfirmasi/mengadopsi rekomendasi sebelumnya adalah fakta tersendiri
+
+Pesan Baru:
+[{"role": "user", "content": "Anakku yang umur 6 tahun nggak mau makan sayur sama sekali. Ada ide?"},
+ {"role": "assistant", "content": "Coba blender bayam atau wortel ke dalam saus pasta — warna dan rasanya hampir hilang, dan banyak anak mau memakannya tanpa sadar."},
+ {"role": "user", "content": "Wah bagus, nanti malam kami coba. Ngomong-ngomong, jam tidur yang baik untuk umur segitu jam berapa?"},
+ {"role": "assistant", "content": "Untuk anak 6 tahun, usahakan tidur antara pukul 19.00–21.00 dengan durasi tidur sekitar 10–11 jam."}]
+Memory Date: 2025-06-20
+
+Keluaran:
+```json
+{
+ "memory": [
+ {"content": "Pengguna memiliki anak berumur 6 tahun yang menolak makan sayur, dan menerima saran asisten untuk memblender bayam atau wortel ke dalam saus pasta agar tersamarkan.", "tags": ["parenting", "food"], "owner": "user"},
+ {"content": "Asisten menyarankan kepada pengguna bahwa anak berumur 6 tahun sebaiknya tidur antara pukul 19.00–21.00 dengan durasi tidur sekitar 10–11 jam.", "tags": ["parenting", "sleep"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Pada pesan ketiga pengguna berkata "nanti malam kami coba" — secara eksplisit mengadopsi saran sebelumnya. Penerimaan itu bernilai dan harus dicatat ("menerima saran asisten untuk ..."), bukan dibuang sebagai basa-basi. Saran jam tidur baru saja diberikan dan belum diadopsi, sehingga dicatat sebagai saran (owner "agent").
+
+## Contoh 5 — Konteks RAG/sisipan: jangan pernah menyimpan teks yang disisipkan
+
+Pesan Baru:
+[{"role": "user", "content": "[Konteks yang diambil: Menara Eiffel tingginya 330 m dan selesai dibangun pada 1889.] Berdasarkan itu, saya akan melamar pacar saya di puncak Menara Eiffel musim panas ini."}]
+Memory Date: 2025-05-02
+
+Keluaran:
+```json
+{
+ "memory": [],
+ "intentions": [
+ {"content": "Pengguna berencana melamar pacarnya di puncak Menara Eiffel pada musim panas 2025.", "tags": ["relationship", "travel"], "valid_until": "2025-08-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+Konteks yang diambil dalam kurung siku (tinggi dan tahun menara) adalah materi referensi yang disisipkan oleh RAG, BUKAN sesuatu yang pengguna ceritakan tentang dirinya — JANGAN simpan. Hanya rencana pengguna sendiri yang berorientasi ke depan yang diekstrak. Teks yang disisipkan oleh sistem/RAG adalah konteks untuk model, tidak pernah menjadi memori.
+
+## Contoh 6 — Materi referensi yang dibagikan: ekstrak isinya, bukan tindakan membagikannya
+
+Pesan Baru:
+[{"role": "user", "content": "Tolong ingat resep pangsit nenekku supaya nggak hilang. Isian: 500 g daging babi giling, 300 g sawi putih, 2 sdm kecap asin, 1 sdm minyak wijen, jahe seruas jempol dicincang. Sawi digarami 15 menit lalu diperas sampai kering. Rebus pangsit, tambahkan air dingin dua kali, matang kalau sudah mengapung."},
+ {"role": "assistant", "content": "Baik, sudah disimpan!"}]
+Memory Date: 2025-07-01
+
+Keluaran:
+```json
+{
+ "memory": [
+ {"content": "Resep pangsit nenek pengguna: isian 500 g daging babi giling, 300 g sawi putih (digarami 15 menit lalu diperas sampai kering), 2 sdm kecap asin, 1 sdm minyak wijen, dan jahe seruas jempol yang dicincang; rebus pangsit, tambahkan air dingin dua kali, dan pangsit matang ketika sudah mengapung.", "tags": ["food", "recipe", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Ekstrak isi faktualnya (bahan, takaran, langkah menggarami dan memeras, cara merebus) — BUKAN "pengguna membagikan resep" atau "pengguna meminta agar resep diingat". Tindakan membagikan tidak bernilai; isinyalah yang dapat dikueri.
+
+## Contoh 7 — Angka dan atribut terstruktur dipertahankan persis
+
+Pesan Baru:
+[{"role": "user", "content": "Mencatat PR home-gym siklus ini: Squat 140kg x 3, Bench 100kg x 5, Deadlift 180kg x 2, Overhead Press 60kg x 6. Berat badan 78kg, 3 set per gerakan, istirahat 3 menit."},
+ {"role": "assistant", "content": "Tercatat — angka yang mantap!"}]
+Memory Date: 2026-01-20
+
+Keluaran:
+```json
+{
+ "memory": [
+ {"content": "PR angkat beban pengguna saat ini adalah Squat 140kg x 3, Bench 100kg x 5, Deadlift 180kg x 2, dan Overhead Press 60kg x 6, dengan berat badan 78kg.", "tags": ["fitness", "strength"], "owner": "user"},
+ {"content": "Pengguna berlatih dengan 3 set per gerakan dan istirahat 3 menit di antara set.", "tags": ["fitness", "training"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Setiap angka dan satuan (kg, repetisi, set, waktu istirahat) dipertahankan persis — membuangnya akan menghancurkan informasi yang paling dapat dikueri. Pisahkan menjadi dua topik yang bersih (PR vs. protokol latihan), tetapi jangan pernah membulatkan atau menghilangkan detail spesifiknya.
+
+## Contoh 8 — Percakapan panjang dengan banyak topik: jangan berhenti setelah topik pertama
+
+Pesan Baru:
+[{"role": "user", "content": "Minggu yang luar biasa — akhirnya aku sidang disertasi PhD hari Selasa!"},
+ {"role": "assistant", "content": "Selamat besar! Bagaimana perasaanmu?"},
+ {"role": "user", "content": "Lega! Aku juga sudah tanda tangan sewa apartemen di Berlin dan pindah bulan depan. Terus aku mulai belajar bahasa Jerman di Duolingo — streak 30 hari. Pasanganku, Sofia, untuk sementara tetap di Madrid, dan itu berat."}]
+Memory Date: 2025-11-08
+
+Keluaran:
+```json
+{
+ "memory": [
+ {"content": "Pengguna menjalani sidang disertasi PhD pada 2025-11-04.", "tags": ["education", "milestone"], "owner": "user"},
+ {"content": "Pengguna menandatangani kontrak sewa apartemen di Berlin.", "tags": ["housing"], "owner": "user"},
+ {"content": "Pengguna sedang belajar bahasa Jerman di Duolingo dan memiliki streak 30 hari.", "tags": ["language", "learning"], "owner": "user"},
+ {"content": "Pasangan pengguna, Sofia, untuk sementara tetap tinggal di Madrid, dan pengguna merasa hal itu berat.", "tags": ["relationship"], "owner": "user"}
+ ],
+ "intentions": [
+ {"content": "Pengguna berencana pindah ke Berlin bulan depan (sekitar Desember 2025).", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+Empat topik atau lebih — sidang disertasi, apartemen di Berlin, belajar bahasa Jerman, dan pasangan di Madrid. Jangan berhenti setelah topik pertama. Perhatikan bahwa satu giliran bicara dipecah menjadi fakta yang sudah selesai (sewa ditandatangani) DAN sebuah intention (kepindahan yang akan datang), dan detail emosional-tetapi-substantif tentang Sofia dipertahankan karena membawa konteks hubungan yang bertahan lama.
+
+## Contoh 9 — Dua orang nyata: `name` pada pesan asisten berarti orang nyata
+
+Pesan Baru:
+[{"role": "user", "name": "Tim", "content": "Baru pulang dari gym panjat tebing, sudah tiga kali minggu ini. Akhirnya berhasil menyelesaikan rute overhang itu."},
+ {"role": "assistant", "name": "John", "content": "Keren! Aku malah berenang — bahuku masih sakit sejak bulan lalu."}]
+Memory Date: 2025-08-14
+
+Keluaran:
+```json
+{
+ "memory": [
+ {"content": "Pengguna rutin panjat tebing tiga kali seminggu dan baru-baru ini berhasil menyelesaikan rute overhang yang sulit.", "tags": ["fitness", "climbing"], "owner": "user"},
+ {"content": "John berenang sebagai pengganti olahraga lain karena bahunya masih sakit akibat cedera sekitar Juli 2025.", "tags": ["fitness", "health"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {"name": "Tim"}
+}
+```
+John membawa `role: "assistant"` tetapi ia memiliki `name`, sehingga ia adalah orang nyata lain, BUKAN AI: memorinya memakai "John ..." sebagai subjek dan tetap `owner: "user"` (termasuk dalam penyimpanan memori pengguna). Memori pengguna sendiri tetap "Pengguna ..." meskipun kita tahu namanya Tim — jangan pernah "Tim rutin panjat tebing". `basic_info.name` berasal dari `name: "Tim"` pada pesan pengguna, yang bersifat otoritatif meskipun Tim tidak pernah menyebutkan namanya sendiri secara langsung.
+
+## Contoh 10 — Contoh tandingan: atribut orang lain tidak pernah masuk ke basic_info
+
+Pesan Baru:
+[{"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
+
+Keluaran:
+```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"}
+}
+```
+Pekerjaan dan lokasi John adalah atribut MILIKNYA, sehingga masuk ke `memory` dengan "John" sebagai subjek. Atribut itu TIDAK BOLEH masuk ke `basic_info.occupation` / `basic_info.location` — `basic_info` khusus untuk profil pengguna sendiri. Hanya `name` (Tim, dari field `name` pada pesan pengguna) yang termasuk di sana. Perhatikan bahwa bahasa keluaran mengikuti bahasa masukan (contoh ini berbahasa Inggris).
+
+## Contoh 11 — Contoh tandingan: basa-basi tidak memiliki basic_info
+
+Pesan Baru:
+[{"role": "user", "content": "Halo"},
+ {"role": "assistant", "content": "Halo! Nama pengguna adalah Pengguna. Ada yang bisa saya bantu?"}]
+Memory Date: 2025-09-03
+
+Keluaran:
+```json
+{
+ "memory": [],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Pengguna tidak menyatakan apa pun tentang dirinya. Kalimat asisten bukan giliran bicara pengguna, dan "Pengguna" adalah placeholder, bukan nama. Keluarkan `{}` — jangan pernah `{"name": "Pengguna"}` atau `{"name": "user"}`.
+
+---
+"""
+
+EXTRACT_PROMPT = """## k Pesan Terakhir
+
+{last_messages}
+
+---
+
+## Pesan Baru
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Format Keluaran
+
+Kembalikan HANYA sebuah objek JSON di dalam blok berpagar ```json.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "intentions": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "valid_until": "YYYY-MM-DD",
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Aturan:
+
+* `memory` = info tahan lama yang layak diingat: preferensi, opini, sikap,
+ sifat, peristiwa, rencana, pengalaman, kebiasaan, keputusan — tentang pengguna atau
+ tentang orang nyata lain yang disebut namanya, dengan subjek ditulis sesuai "# SUBJEK"
+* `intentions` = hal berorientasi ke depan yang pengguna (atau orang lain yang disebut namanya) rencanakan /
+ niatkan untuk dilakukan di masa mendatang, dengan `valid_until` = tenggat/tanggal target
+ (diselesaikan berdasarkan Memory Date) atau `null` jika tidak ada
+* `owner` (wajib pada setiap memory & intention) = `"user"` atau `"agent"`
+ (lihat "# OWNER" di atas; default `"user"` jika ragu)
+* `basic_info` = **hanya profil pengguna sendiri**. Sertakan field profil
+ yang stabil (mis. nama, umur, lokasi, pekerjaan, pemberi kerja) yang **dinyatakan secara eksplisit**
+ dalam pesan pengguna yang BARU. Jangan pernah menyimpulkan, jangan pernah mengarang. Jika tidak ada field yang dinyatakan
+ secara eksplisit, keluarkan `{{}}`.
+ * ATURAN MUTLAK: isi sebuah field HANYA jika pengguna menyatakannya dalam giliran `user`.
+ Apa pun yang hanya dikatakan oleh asisten (termasuk asisten yang mengutip
+ memori sebelumnya seperti "Nama pengguna adalah X") TIDAK dihitung. Jika tidak ada yang
+ memenuhi syarat, keluarkan `"basic_info": {{}}`.
+ * JANGAN PERNAH menulis nama field itu sendiri atau placeholder sebagai nilai ("user",
+ "The user", "Pengguna", "用户", "name", "N/A", "unknown", "none", "-"). Hilangkan field tersebut.
+ * Contoh negatif: basa-basi seperti `[user]: Halo` / `[assistant]: Ada yang bisa
+ saya bantu?`, atau `[user]: Balas persis dengan: PONG` → `"basic_info": {{}}`.
+ * Pengecualian untuk `name`: field `name` pada pesan milik pengguna sendiri, atau baris
+ di awal "Nama pengguna adalah X" / "The user's name is X" / "用户名叫X", adalah sumber otoritatif untuk
+ `name` — meskipun pengguna tidak pernah mengucapkannya secara langsung.
+ * JANGAN PERNAH memasukkan atribut orang nyata lain ke sini. Jika John (pesan ber-role asisten
+ yang membawa `name`) berkata "Saya perawat di Berlin", itu adalah `memory`
+ ("John adalah perawat di Berlin."), BUKAN `basic_info.occupation` / `.location`.
+* Tidak ada informasi duplikat antarbagian
+* Tags harus berisi 1–3 kata kunci huruf kecil yang ringkas
+* Gunakan array kosong `[]` atau `{{}}` jika tidak ada yang diekstrak
+* Kembalikan hanya JSON yang valid
+
+Keluarkan JSON sekarang."""
+
+EXTRACT_PROMPT_NO_INTENTION = """## k Pesan Terakhir
+
+{last_messages}
+
+---
+
+## Pesan Baru
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Format Keluaran
+
+Kembalikan HANYA sebuah objek JSON di dalam blok berpagar ```json.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Aturan:
+
+* `memory` = info tahan lama yang layak diingat: preferensi, opini, sikap,
+ sifat, peristiwa, pengalaman, kebiasaan, keputusan, **serta rencana masa depan / tindakan
+ yang akan datang** — tentang pengguna atau tentang orang nyata lain yang disebut namanya, dengan
+ subjek ditulis sesuai "# SUBJEK". **Jangan** membuat wadah intentions terpisah.
+* `owner` (wajib pada setiap memory) = `"user"` atau `"agent"`
+ (lihat "# OWNER" di atas; default `"user"` jika ragu)
+* `basic_info` = **hanya profil pengguna sendiri**. Sertakan field profil
+ yang stabil (mis. nama, umur, lokasi, pekerjaan, pemberi kerja) yang **dinyatakan secara eksplisit**
+ dalam pesan pengguna yang BARU. Jangan pernah menyimpulkan, jangan pernah mengarang. Jika tidak ada field yang dinyatakan
+ secara eksplisit, keluarkan `{{}}`.
+ * ATURAN MUTLAK: isi sebuah field HANYA jika pengguna menyatakannya dalam giliran `user`.
+ Apa pun yang hanya dikatakan oleh asisten (termasuk asisten yang mengutip
+ memori sebelumnya seperti "Nama pengguna adalah X") TIDAK dihitung. Jika tidak ada yang
+ memenuhi syarat, keluarkan `"basic_info": {{}}`.
+ * JANGAN PERNAH menulis nama field itu sendiri atau placeholder sebagai nilai ("user",
+ "The user", "Pengguna", "用户", "name", "N/A", "unknown", "none", "-"). Hilangkan field tersebut.
+ * Contoh negatif: basa-basi seperti `[user]: Halo` / `[assistant]: Ada yang bisa
+ saya bantu?`, atau `[user]: Balas persis dengan: PONG` → `"basic_info": {{}}`.
+ * Pengecualian untuk `name`: field `name` pada pesan milik pengguna sendiri, atau baris
+ di awal "Nama pengguna adalah X" / "The user's name is X" / "用户名叫X", adalah sumber otoritatif untuk
+ `name` — meskipun pengguna tidak pernah mengucapkannya secara langsung.
+ * JANGAN PERNAH memasukkan atribut orang nyata lain ke sini. Jika John (pesan ber-role asisten
+ yang membawa `name`) berkata "Saya perawat di Berlin", itu adalah `memory`
+ ("John adalah perawat di Berlin."), BUKAN `basic_info.occupation` / `.location`.
+* Tidak ada informasi duplikat antarbagian
+* Tags: 1–3 kata kunci ringkas; tag topik huruf kecil; nama diri mempertahankan huruf kapital
+* Gunakan array kosong `[]` atau `{{}}` jika tidak ada yang diekstrak
+* Kembalikan hanya JSON yang valid — **jangan pernah** sertakan key `intentions`
+
+Keluarkan JSON sekarang."""
+
+
+# ================================================================
+# Chat reconcile (agent/reconciler.py)
+# ================================================================
+
+SEARCH_QUERY_PROMPT = """Anda adalah pembuat kueri pencarian. Diberikan daftar memori yang baru diekstrak, buatlah sekumpulan kueri pencarian singkat yang dapat digunakan untuk menemukan memori lama yang berkaitan di dalam basis data vektor.
+
+Tujuannya adalah memaksimalkan recall — temukan memori lama yang secara semantik berkaitan dengan memori baru, meskipun susunan katanya sangat berbeda.
+
+## Memori baru:
+{new_memories}
+
+## Instruksi
+
+Buat kueri pencarian yang mencakup:
+- Topik, entitas, dan tema utama yang disebutkan dalam memori
+- Versi yang diparafrasekan atau diabstraksikan dari konsep inti
+- Konsep terkait yang mungkin ada dalam penyimpanan memori pengguna
+
+Keluarkan sebuah array JSON berisi string kueri (5-15 kueri, singkat dan terfokus):
+
+["kueri1", "kueri2", "kueri3", ...]
+
+Keluarkan hanya array JSON, tanpa teks lain."""
+
+RECONCILE_PROMPT = """Anda adalah sistem manajemen memori.
+
+Tugas Anda adalah menggabungkan memori baru ke dalam basis memori yang sudah ada sambil menjaganya tetap:
+
+* tanpa kehilangan informasi (lossless)
+* tidak saling bertentangan
+* ringkas
+* sangat mudah ditemukan kembali
+
+---
+
+# Operasi
+
+## ADD
+
+Gunakan ketika informasinya sepenuhnya baru.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## UPDATE
+
+Gunakan ketika:
+
+* memori baru kompatibel dengan memori yang sudah ada
+* keduanya menggambarkan topik yang sama
+* penggabungan meningkatkan kelengkapan atau kemudahan ditemukan kembali
+
+Aturan:
+
+* gabungkan tanpa kehilangan informasi
+* pertahankan semua informasi yang berguna
+* JANGAN membuat duplikat
+* jika keduanya berbeda pada suatu nilai, pertahankan nilai dari memori dengan
+ `memory_at` yang lebih akhir; jangan pernah biarkan memori yang lebih lama menimpa nilai yang lebih baru
+
+### Kejadian yang sama vs. kejadian lain
+
+Gunakan **UPDATE** hanya ketika memori baru menambahkan detail pada kejadian dunia nyata
+yang sama atau fakta tahan lama yang sudah tercatat.
+
+Jika orang yang sama melakukan jenis aktivitas/peristiwa yang sama lagi pada waktu lain
+(perjalanan lain, pertandingan lain, cedera lain, pembelian lain, masalah kesehatan lain, dll.), simpan kejadian tersebut
+sebagai **ADD** terpisah. Pertahankan tanggal dan detailnya sendiri. Ketika sebuah memori yang sudah ada
+jelas merupakan kejadian lain dalam rangkaian konkret yang sama, tautkan dengan
+`related: [{{"memory_id":"...","relation":"same_series"}}]`.
+
+Jangan menggabungkan kejadian bertanggal yang terpisah menjadi satu memori panjang berisi hitungan/linimasa.
+Lapisan retrieval membangun linimasa dari memori L2 yang saling tertaut.
+
+```json
+{{
+ "op": "UPDATE",
+ "memory_id": "...",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## SUPERSEDE
+
+Gunakan HANYA ketika:
+
+* memori baru bertentangan dengan memori yang sudah ada
+* keduanya tidak mungkin benar pada saat yang sama
+* memori lama kini akan memberikan jawaban yang salah tentang keadaan saat ini
+* `memory_at` memori baru sama dengan atau LEBIH AKHIR daripada `memory_at` memori yang sudah ada
+
+Contoh:
+
+* kota berubah
+* pemberi kerja berubah
+* status hubungan berubah
+
+JANGAN gunakan untuk:
+
+* tambahan detail
+* preferensi yang kompatibel
+* perbedaan susunan kata
+* kesetaraan semantik
+* memori baru yang `memory_at`-nya LEBIH AWAL daripada memori yang sudah ada — itu adalah
+ keadaan yang lebih lama dan tidak boleh menggantikan yang lebih baru (lihat "Urutan waktu")
+
+Aturan:
+
+* content HANYA boleh berisi keadaan yang baru
+* JANGAN menyalin informasi yang tidak berubah
+* sistem menyimpan node lama dan menautkannya ke rantai evolusi secara otomatis; Anda tidak perlu menangani riwayat
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_id": "...",
+ "content": "...",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+### Melipat beberapa memori yang sudah ada menjadi satu rantai
+
+Jika DUA ATAU LEBIH memori yang sudah ada melacak dimensi yang SAMA dan memori baru adalah
+perubahan terbaru pada dimensi tersebut — `memory_at`-nya lebih akhir daripada `memory_at` setiap memori
+yang dilipat — Anda boleh melipatnya menjadi satu rantai
+evolusi. Gunakan `memory_ids` (daftar terurut, TERLAMA → TERBARU) sebagai pengganti satu
+`memory_id`:
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_ids": ["<oldest_id>", "<newer_id>"],
+ "content": "<hanya keadaan terbaru>",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+Memori yang tercantum dirantai dari terlama → terbaru dan memori baru menjadi
+kepala rantai. `content` tetap HANYA menggambarkan keadaan terbaru — jangan pernah menyalin
+teks memori-memori lama ke dalamnya; memori lama tetap dapat dikueri dalam riwayat rantai.
+
+---
+
+# Aturan
+
+* Pertahankan semua informasi yang bermakna.
+* Lewati duplikat yang persis sama.
+* Utamakan penggabungan fragmen yang berkaitan.
+* Kejadian bertanggal yang terpisah tetap menjadi ADD terpisah; gunakan `same_series` hanya untuk
+ subjek yang sama dan jenis aktivitas/peristiwa konkret yang sama.
+* Jaga agar setiap memori terfokus pada satu topik yang koheren.
+* Ikuti "Urutan waktu" di bawah.
+* **JANGAN PERNAH menggabungkan atau melakukan supersede lintas subjek yang berbeda.** Subjek adalah siapa pun
+ yang dibicarakan oleh konten: "Pengguna ..." vs "John ..." vs "Mary ...". Memori tentang
+ orang yang berbeda adalah fakta yang independen meskipun kalimatnya selebihnya
+ identik — "Pengguna suka kopi" dan "John suka kopi" adalah dua memori
+ yang terpisah, tidak pernah saling UPDATE atau SUPERSEDE.
+* `owner` (`user`/`agent`): salin dari memori yang sedang ditulis. JANGAN PERNAH menggabungkan atau melakukan supersede lintas owner yang berbeda — fakta milik pengguna dan fakta milik asisten berbeda meskipun topiknya sama.
+* Sebuah SUPERSEDE menargetkan SATU memori (`memory_id`) atau melipat beberapa memori pada dimensi yang sama menjadi satu rantai (`memory_ids`, terlama→terbaru). Sebuah UPDATE menargetkan tepat SATU memori.
+* Jangan pernah menyentuh memori lama yang sama dari lebih dari satu op.
+* Bahasa keluaran sama dengan bahasa memori masukan.
+
+---
+
+# Urutan waktu
+
+Setiap memori, baru maupun lama, memiliki `memory_at`: kapan hal itu terjadi. Memori
+TIDAK selalu ditulis sesuai urutan terjadinya — riwayat bisa diimpor belakangan,
+dan sebuah memori bisa ditambahkan saat riwayat yang lebih lama masih diproses. Karena itu,
+memori baru bisa LEBIH LAMA daripada memori yang sudah ada.
+
+* Tentukan memori mana yang lebih baru HANYA berdasarkan `memory_at`. "Memori baru" berarti "sedang
+ ditulis sekarang", bukan "lebih mutakhir".
+* Memori yang lebih lama tidak boleh menggantikan yang lebih baru: tidak ada SUPERSEDE terhadap memori
+ yang lebih baru, dan tidak ada UPDATE yang menimpa nilai yang lebih baru dengan nilai yang lebih lama.
+* Jika memori baru lebih lama daripada memori yang sudah ada yang bertentangan dengannya, pertahankan
+ memori yang sudah ada sebagai keadaan saat ini. Lakukan ADD untuk memori baru sebagai keadaan masa lalu, ditulis
+ dalam bentuk lampau beserta waktunya (misalnya "Pada 2023 pengguna tinggal di Shanghai"),
+ atau jangan keluarkan apa pun jika tidak menambah informasi.
+* `memory_at: null` berarti waktunya tidak diketahui. Tidak diketahui BUKAN berarti lebih baru: jangan pernah melakukan SUPERSEDE terhadap
+ memori yang memiliki `memory_at` yang diketahui dengan memori yang `memory_at`-nya null.
+* Jangan mengarang kronologi.
+
+---
+
+# Opsional: `related`
+
+Pada op apa pun Anda BOLEH menambahkan array `related` yang mencatat bagaimana memori yang sedang ditulis
+berkaitan dengan memori yang SUDAH ADA. Ini tidak mengubah apa yang disimpan — hanya
+mencatat sebuah tautan.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."],
+ "related": [{{"memory_id": "<existing_id>", "relation": "causes"}}]
+}}
+```
+
+Hanya empat relasi ini yang diizinkan:
+
+* `causes` — kedua memori berada dalam hubungan sebab/akibat
+ (mis. "mulai lari setiap hari" → "lutut mulai sakit")
+* `elaborates` — menambahkan detail pada, atau merupakan perkembangan lanjutan dari, memori yang sudah ada
+* `contrasts` — keduanya bertentangan tetapi KEDUANYA tetap benar (jika yang satu membuat yang lain
+ salah, itu adalah SUPERSEDE, bukan tautan `contrasts`)
+* `same_series` — kejadian bertanggal terpisah dari jenis aktivitas atau peristiwa konkret yang sama
+ untuk subjek yang sama (misalnya, dua perjalanan ski yang berbeda)
+
+Aturan:
+
+* Hanya tautkan ke memori yang muncul di "Memori yang sudah ada" — jangan pernah mengarang id.
+* Hanya keluarkan tautan ketika hubungannya **eksplisit dan spesifik**. Dua memori
+ yang sekadar membahas topik luas yang sama BUKAN sebuah relasi — jangan sertakan `related`.
+* `same_series` mensyaratkan subjek yang sama dan tindakan/peristiwa konkret yang berulang;
+ tag luas yang sama seperti health, travel, sport, food, atau work tidak cukup.
+* Hilangkan field ini sepenuhnya ketika tidak ada yang perlu ditautkan. Nol tautan adalah kasus yang normal.
+* Jangan pernah menggunakan `related` sebagai pengganti UPDATE / SUPERSEDE.
+
+---
+{few_shot_section}
+###################
+Data Masukan
+###################
+
+Tanggal saat ini: {current_date}
+
+## Memori yang sudah ada
+
+{existing_memories}
+
+## Memori baru
+
+{new_memories}
+
+---
+
+# Keluaran
+
+Kembalikan HANYA sebuah array JSON di dalam blok kode berpagar ```json.
+
+Jika tidak ada perubahan yang diperlukan:
+
+```json
+[]
+```
+
+Sekarang hasilkan array JSON tersebut."""
+
+RECONCILE_STRUCTURE_METADATA_PROMPT = """
+
+Kontrak keluaran struktural tambahan:
+
+Untuk setiap hasil ADD, UPDATE, atau SUPERSEDE, pertahankan atau perhalus `topic_paths`,
+`event_facet`, dan `topic_assignments`. `event_facet` hanya berisi `subject`,
+`participants`, `action`, `objects`, `locations`, dan `state`.
+`topic_assignments` berisi entri `{subject, role, path}` yang spesifik per subjek;
+setiap segmen path adalah `{name, type}` dan type adalah `topic|facet|series|episode`.
+Urutan type mengikuti `topic -> facet -> series -> episode`; tingkatan boleh dilewati tetapi
+type tidak boleh berulang atau mundur.
+Gunakan Series hanya untuk kejadian berulang dari satu garis aktivitas/keadaan konkret dan
+Episode hanya untuk satu kejadian dunia nyata yang berbatas. Jangan pernah menyimpulkan type ini dari
+kedalaman, tag luas yang sama, atau kemunculan bersamaan yang tidak berkaitan. Ketika sebuah memori yang sudah ada
+telah memiliki path spesifik-subjek yang setara secara semantik, gunakan kembali nama node
+dan type-nya persis alih-alih membuat cabang sinonim. Untuk meminta penggunaan ulang yang persis, keluarkan
+`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
+"through":"topic|facet|series|episode"}]`. ID yang dirujuk harus muncul di
+memori yang sudah ada. `through` berarti salin prefiks path yang sudah ada itu sampai dengan
+type struktural yang disebutkan; sufiks lebih dalam yang ditulis secara eksplisit tetap baru. Penggunaan ulang
+dilarang ketika subjek, garis aktivitas/keadaan konkret, atau batas Episode
+berbeda. Field-field ini menggambarkan memori, tidak pernah bentuk kueri di masa mendatang seperti
+"kapan", "berapa banyak", atau "siapa".
+
+Series adalah relasi pada tahap reconcile: tetapkan hanya ketika memori baru dan
+setidaknya satu memori lama yang independen merupakan kejadian berbeda dari garis
+aktivitas/keadaan konkret yang sama. Beberapa proposisi dari penulisan saat ini tidak
+membuktikan pengulangan.
+"""
+
+RECONCILE_FEW_SHOT = """
+###################
+Contoh
+###################
+
+## Contoh 1 — Satu memori baru: sebagian bertentangan dengan rantai yang sudah ada, sebagian tidak berkaitan
+
+Memori yang sudah ada:
+[
+ {"memory_id": "m1", "content": "Pengguna bekerja sebagai product manager di Stripe.", "owner": "user", "history_versions": [{"content": "Pengguna bekerja sebagai product manager di sebuah startup fintech."}]}
+]
+Memori baru:
+[
+ {"content": "Pengguna telah keluar dari Stripe dan kini menjadi product lead di Notion, serta belakangan mulai menekuni kerajinan tembikar di akhir pekan.", "owner": "user"}
+]
+
+Keluaran:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "m1", "content": "Pengguna bekerja sebagai product lead di Notion.", "supersede_reason": "pemberi kerja berubah dari Stripe ke Notion", "owner": "user", "tags": ["work"]},
+ {"op": "ADD", "content": "Pengguna belakangan mulai menekuni kerajinan tembikar di akhir pekan.", "owner": "user", "tags": ["hobby"]}
+]
+```
+SATU memori baru membawa dua hal: perubahan pekerjaan (dimensi yang sama dengan rantai pekerjaan m1 yang sudah memiliki riwayat → SUPERSEDE, menjadi kepala rantai yang baru) dan detail yang tidak berkaitan (tembikar → ADD). Pecah satu memori itu menjadi op yang tepat untuk setiap bagian — kepala rantai yang baru HANYA menggambarkan keadaan pekerjaan, tidak pernah tembikar.
+
+## Contoh 2 — Lipat dua memori lama yang tidak tertaut + perubahan baru menjadi satu rantai 3 node
+
+Memori yang sudah ada:
+[
+ {"memory_id": "a1", "content": "Pengguna sedang belajar bermain gitar.", "owner": "user", "memory_at": "2024-02-10 09:00"},
+ {"memory_id": "a2", "content": "Pengguna kini bisa memainkan beberapa lagu utuh dengan gitar.", "owner": "user", "memory_at": "2024-09-05 09:00"}
+]
+Memori baru:
+[
+ {"content": "Pengguna kini tampil bermain gitar di acara open-mic lokal.", "owner": "user"}
+]
+
+Keluaran:
+```json
+[
+ {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "Pengguna tampil bermain gitar di acara open-mic lokal.", "supersede_reason": "kemampuan gitar berkembang: belajar → memainkan lagu → tampil langsung", "owner": "user", "tags": ["music", "hobby"]}
+]
+```
+a1 dan a2 tidak pernah tertaut, tetapi keduanya melacak dimensi yang sama (perkembangan bermain gitar) dan memori baru adalah langkah terbaru. Lipat dengan `memory_ids` yang diurutkan dari terlama→terbaru; keduanya menjadi rantai 3 node (a1 ← a2 ← kepala baru). `content` kepala rantai HANYA menggambarkan keadaan saat ini — tidak mengulang "belajar" atau "beberapa lagu".
+
+## Contoh 3 — Kepala rantai baru TIDAK BOLEH menyalin konten memori lama
+
+Memori yang sudah ada:
+[
+ {"memory_id": "c1", "content": "Pengguna tinggal di apartemen sewaan satu kamar tidur di Shibuya, Tokyo, membayar ¥180,000/bulan, senang karena hanya 5 menit jalan kaki ke stasiun, tetapi mengeluh tempatnya bising di malam hari dan tidak punya tempat parkir.", "owner": "user"}
+]
+Memori baru:
+[
+ {"content": "Pengguna baru saja membeli dan pindah ke rumah tiga kamar tidur di pinggiran Yokohama dengan taman dan garasi untuk dua mobil.", "owner": "user"}
+]
+
+Keluaran:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "c1", "content": "Pengguna membeli dan pindah ke rumah tiga kamar tidur di pinggiran Yokohama, dengan taman dan garasi untuk dua mobil.", "supersede_reason": "tempat tinggal berubah dari apartemen sewaan di Shibuya menjadi rumah milik sendiri di Yokohama", "owner": "user", "tags": ["housing"]}
+]
+```
+Memori baru melakukan SUPERSEDE terhadap c1 dan menjadi kepala rantai. `content` kepala rantai HANYA menggambarkan rumah baru di Yokohama. JANGAN menyeret detail khas apartemen lama (Shibuya, sewa ¥180,000, jarak jalan kaki ke stasiun, keluhan bising/parkir) ke node baru — detail itu jelas milik tempat tinggal lama, bukan yang baru. Detail itu tetap ada di riwayat rantai dan tetap dapat ditemukan kembali; menyalinnya akan membuat kepala rantai bertentangan dengan dirinya sendiri (menyewa di Shibuya SEKALIGUS memiliki rumah di Yokohama).
+
+## Contoh 4 — Subjek yang berbeda tidak pernah digabungkan, semirip apa pun susunan katanya
+
+Memori yang sudah ada:
+[
+ {"memory_id": "d1", "content": "Pengguna minum kopi hitam setiap pagi.", "owner": "user"}
+]
+Memori baru:
+[
+ {"content": "John minum kopi hitam setiap pagi.", "owner": "user"},
+ {"content": "Pengguna kini minum kopi hitam dua kali sehari, pagi dan setelah makan siang.", "owner": "user"}
+]
+
+Keluaran:
+```json
+[
+ {"op": "ADD", "content": "John minum kopi hitam setiap pagi.", "owner": "user", "tags": ["food"]},
+ {"op": "UPDATE", "memory_id": "d1", "content": "Pengguna minum kopi hitam dua kali sehari, pada pagi hari dan setelah makan siang.", "owner": "user", "tags": ["food"]}
+]
+```
+Kedua memori baru hampir identik susunan katanya tetapi memiliki subjek yang BERBEDA. "John ..." adalah tentang orang lain, sehingga merupakan ADD biasa — tidak pernah UPDATE atau SUPERSEDE terhadap d1, meskipun d1 menyatakan hal yang hampir sama tentang pengguna. Hanya memori yang subjeknya juga "Pengguna" yang boleh digabungkan dengan d1.
+
+## Contoh 5 — Peristiwa berulang: naikkan hitungan dan pertahankan linimasa (UPDATE, bukan ADD)
+
+Memori yang sudah ada:
+[
+ {"memory_id": "i1", "content": "John mencederai pergelangan kakinya musim lalu dan perlu istirahat serta fisioterapi.", "owner": "user", "memory_at": "2023-05-21 19:48"}
+]
+Memori baru:
+[
+ {"content": "John terkilir lagi pergelangan kakinya dalam pertandingan baru-baru ini.", "owner": "user", "memory_at": "2023-10-13 13:50"}
+]
+
+Keluaran:
+```json
+[
+ {"op": "UPDATE", "memory_id": "i1", "content": "John telah dua kali mencederai pergelangan kakinya: pertama pada musim lalu (sekitar musim 2022–2023), yang memerlukan istirahat dan fisioterapi; kedua dalam sebuah pertandingan sekitar 2023-10-13.", "owner": "user", "tags": ["health", "basketball", "injury"]}
+]
+```
+Jenis peristiwa yang sama terjadi lagi → UPDATE memori lama. Nyatakan **hitungannya** dan daftarkan setiap kejadian beserta waktunya bila diketahui. JANGAN melakukan ADD fakta kedua "John mencederai pergelangan kakinya", dan JANGAN melakukan SUPERSEDE (cedera pertama tidak berhenti menjadi benar).
+"""
+
+
+
+# ================================================================
+# Working / coding memory (coding/)
+# ================================================================
+
+CODING_EXTRACT_PROMPT = """\
+Anda mengekstrak memori KERJA (working memory) yang tahan lama dari satu segmen sesi pelaksanaan tugas.
+Sesi "kerja" adalah tugas praktis apa pun di mana pengguna mengoperasikan komputer /
+sistem melalui tools — ini mencakup KEDUANYA: pekerjaan perangkat lunak/kode (menulis, debugging,
+refactoring, build, deploy, penggunaan API/library) DAN pekerjaan sistem & operasional
+(menjalankan perintah shell/PowerShell, analisis atau pembersihan disk/penyimpanan, operasi file
+& folder, instalasi/konfigurasi perangkat lunak, penyiapan lingkungan/perangkat,
+pemeriksaan kesehatan hardware/disk, backup, penjadwalan/otomasi, pemrosesan data).
+
+Anda menghasilkan DUA lapisan dari segmen yang SAMA:
+
+ EXPERIENCES (prosedural, "bagaimana melakukannya") — metode yang dapat digunakan ulang, diekstrak hanya
+ jika lolos AMBANG NILAI di bawah. Satu paket (task, search_keys, solution,
+ boundary_envs).
+
+ FACT (episodik, "apa yang terjadi kali ini") — TEPAT SATU catatan tentang sesi
+ INI: apa yang diinginkan pengguna, bagaimana pengerjaannya, bagaimana hasilnya. Tidak ada
+ ambang nilai, tetapi jumlahnya tidak pernah lebih dari satu.
+
+Kedua lapisan menjawab pertanyaan yang berbeda dan disimpan secara terpisah. Metode
+yang dapat digeneralisasi masuk ke EXPERIENCES; cerita sesi khusus ini —
+yang hanya berlaku untuk sistem ini / proyek ini / saat ini — masuk ke FACT.
+
+═══════════════════════════════════════════════════════════════════
+AMBANG NILAI (HANYA UNTUK EXPERIENCES) — JANGAN dilewati dengan mudah.
+═══════════════════════════════════════════════════════════════════
+Sebuah memori WAJIB memenuhi SEMUA hal berikut:
+ (a) Menyelesaikan masalah yang kemungkinan besar akan berulang bagi pengguna yang sama
+ (b) Solusinya tidak sepele: menggabungkan beberapa informasi / langkah, ATAU
+ membawa alasan keputusan, ATAU menangkap solusi pengganti yang didapat dengan susah payah, ATAU merupakan
+ prosedur/resep yang dapat digunakan ulang untuk tugas operasional (mis. cara menganalisis &
+ membersihkan penggunaan disk, cara mengatur file secara massal, cara memeriksa kesehatan
+ hardware, cara menyiapkan job terjadwal)
+ (c) Agent / pengguna di masa mendatang lebih suka mencarinya daripada menemukannya ulang
+
+PENTING — tugas analisis / diagnostik / investigasi TETAP DIHITUNG:
+Sebuah tugas TIDAK harus membuat perubahan atau "memperbaiki" sesuatu agar layak diingat.
+Pekerjaan read-only / analitis / troubleshooting bernilai ketika PROSEDUR atau
+KESIMPULANNYA dapat digunakan ulang. Secara eksplisit ekstrak:
+ - Resep analisis / diagnostik: prosedur yang dapat digunakan ulang + apa yang diungkapnya
+ (mis. "cara menganalisis folder mana yang menghabiskan ruang drive C" — perintah pemindaian,
+ jebakan yang ditemui, dan temuannya). "Hanya menghasilkan laporan, tidak ada perubahan"
+ BUKAN alasan untuk melewatkannya — METODE yang dapat digunakan ulang itulah memorinya.
+ - Hasil investigasi, TERMASUK hasil negatif / tidak ditemukan
+ (mis. "mencari folder X di seluruh C: dan D: dengan rg / fs_search / indeks SQL —
+ tidak ditemukan di mana pun"). Jalan buntu yang tercatat menyelamatkan agent berikutnya dari mengulang
+ pencarian sia-sia yang sama, sehingga lolos ambang.
+JANGAN menolak sebuah memori hanya karena "asisten bisa membuat ulang
+perintahnya" atau "tidak ada yang benar-benar diubah". Jika prosedur atau kesimpulannya
+akan menghemat upaya di masa mendatang, simpan.
+
+JANGAN ekstrak:
+ - Operasi satu langkah yang benar-benar sepele tanpa prosedur yang dapat digunakan ulang ("mengganti nama satu file",
+ "git status", "menjalankan ls sekali")
+ - Masalah sekali-jadi yang sudah terselesaikan tanpa pelajaran yang dapat dialihkan
+ - Informasi yang sudah ada di repo/sistem (jangan menduplikasi package.json)
+ - Tugas sekali pakai per-PR / per-sesi kecuali mengandung pola yang dapat digunakan ulang
+ - Tindakan MEMINTA informasi yang kurang KEPADA PENGGUNA. Meminta parameter,
+ mendaftar apa yang belum diketahui, atau menggali field yang diperlukan adalah perilaku
+ percakapan, bukan metode: setiap agent sudah tahu cara mengajukan pertanyaan, sehingga
+ tidak ada yang perlu dicari nanti. Jangan pernah mengeluarkan experience yang task atau
+ search_keys-nya berbentuk seperti "cara meminta X", "mengumpulkan Y yang kurang",
+ "menggali field yang diperlukan", "apa yang perlu diklarifikasi sebelum mulai". Perhatikan bahwa ini
+ hanya dikecualikan dari EXPERIENCES — bahwa sesi berakhir dengan menunggu pengguna
+ adalah keadaan nyata dan termasuk dalam FACT.
+
+Jika segmen tidak membuat kemajuan substantif karena terhenti menunggu
+pengguna — asisten hanya meminta parameter, atau terhambat sebelum melakukan
+pekerjaan nyata apa pun — keluarkan "experiences": [] dan tulis FACT saja. Belum ada
+yang dipelajari, sehingga tidak ada metode untuk disimpan. Ini lebih penting daripada kelihatannya:
+experience yang disaring dari kondisi terhenti akan terbaca sebagai keterampilan yang sah saat retrieval,
+dan segmen berikutnya dari tugas yang sama akan mencocokkannya lalu bertanya lagi kepada pengguna
+alih-alih melanjutkan, sehingga kondisi terhenti itu terulang sepanjang sisa
+sesi. Nilai substansi berdasarkan apa yang benar-benar dilakukan oleh tools, bukan dari apakah
+giliran tersebut menghasilkan teks yang lancar.
+
+Heuristik: jika pengguna (atau agent di masa mendatang yang mengerjakan jenis tugas yang sama) ingin
+hal ini dituliskan alih-alih mencari tahu lagi, simpan. Prosedur operasional
+multi-langkah (bahkan prosedur sistem/ops atau analisis/pencarian read-only, bukan
+hanya kode) biasanya memenuhi syarat. Buang hanya jika berupa satu perintah yang dapat ditemukan pengguna mana pun
+melalui `--help` dalam 30 detik DAN tidak membawa keputusan/jebakan yang layak
+diingat.
+
+═══════════════════════════════════════════════════════════════════
+FIELD EXPERIENCE
+═══════════════════════════════════════════════════════════════════
+
+task — Nama berbentuk kueri; rumuskan seperti cara pengguna kelak BERTANYA.
+ "memublikasikan rilis ke platform xx" bukan
+ "publish_release_internal"
+ Dapat berdiri sendiri (tanpa "ini", "file tersebut", "kita").
+
+search_keys — 0 hingga 5 rumusan alternatif yang menangkap aspek penting dari
+ solution yang tidak akan cocok dengan `task` saja. Rumuskan sebagai pertanyaan
+ atau topik yang akan DITANYAKAN pengguna di masa mendatang. Berbeda dari task.
+ Hilangkan jika task sudah mencakup semuanya.
+
+solution — Konten lengkap dan dapat berdiri sendiri yang benar-benar dibutuhkan pengguna:
+ perintah, lokasi kredensial (BUKAN NILAI kredensial),
+ path file, langkah berurutan, jebakan, alasan keputusan.
+ Gabungkan pekerjaan end-to-end multi-giliran menjadi SATU solution jika
+ membentuk tugas yang koheren; pecah menjadi beberapa memori hanya jika
+ pengguna mengerjakan tugas-tugas yang tidak berkaitan.
+
+boundary_envs — Penetapan konkret yang menjadi sandaran solution, multi-baris "key: value":
+ runtime / SDK / library + versi
+ endpoint API atau signature method
+ versi layanan eksternal / middleware
+ NAMA env var (bukan nilainya)
+ path file konfigurasi
+ pengenal host / cluster / region
+ Jika solution tidak bergantung pada lingkungan, biarkan "" (kosong).
+ Tujuan: ketika SDK/middleware yang mendasarinya di-upgrade, konsumen
+ di masa mendatang dapat memeriksa ini untuk memutuskan apakah solution masih berlaku.
+
+confidence — 0.0 hingga 1.0
+ 1.0 pengguna secara eksplisit menyatakan ini sebagai aturan / instruksi
+ 0.7 disimpulkan dengan bukti yang baik dari tindakan tools
+ 0.5 disimpulkan secara lemah; satu observasi; tidak pasti
+
+═══════════════════════════════════════════════════════════════════
+FIELD FACT — TEPAT SATU per segmen, tanpa ambang nilai
+═══════════════════════════════════════════════════════════════════
+
+Anda menulis SATU fact untuk seluruh segmen — catatan keadaan yang dapat dipulihkan untuk sesi
+ini, bukan retrospeksi yang dipoles dan tidak pernah berupa daftar temuan terpisah. Seorang
+agent di masa mendatang harus dapat melanjutkan dari catatan ini tanpa keliru menganggap saran,
+inferensi, atau pencarian parsial sebagai sesuatu yang sudah terverifikasi.
+
+subject — SIAPA atau APA yang menjadi pokok sesi ini: satu entitas yang menjadi sasaran
+ atau penerima pekerjaan. Satu frasa nomina pendek, bukan kalimat, tanpa kata kerja.
+ Pilih entitas paling spesifik yang menjadi *pokok* sesi, bukan
+ tool yang digunakannya:
+ nama seseorang ketika sesi melayani satu orang yang disebut namanya
+ ("Dylan", "Matthew")
+ file / modul / simbol ketika pekerjaan menargetkan kode
+ ("auth/middleware.ts", "parse_plan_text")
+ layanan / host / perangkat / drive untuk pekerjaan ops
+ ("D:\\WXWork", "redis-cache-prod", "ci.yml")
+ Ini adalah KUNCI KERAS, bukan prosa: dua sesi tentang orang yang berbeda
+ atau file yang berbeda WAJIB mendapat subject yang berbeda, dan dua sesi
+ tentang hal yang sama WAJIB mendapat string yang sama, dieja identik.
+ Utamakan pengenal persis seperti yang muncul di trace daripada
+ deskripsinya. Jika segmen benar-benar tidak memiliki satu subjek,
+ keluarkan "".
+
+ Mengapa ini penting: subject adalah gerbang yang menentukan apakah sesi
+ berikutnya boleh menimpa sesi ini sebagai "tugas yang sama,
+ dilanjutkan". Jika salah, keadaan satu orang diam-diam menggantikan
+ keadaan orang lain.
+
+statement — Catatan ringkas tentang sesi INI. Dua bagian, dan bagian kedua adalah
+ yang sering hilang.
+ Pertahankan data dasar (givens) lingkup tugas dan batasan konkret alih-alih
+ menggantinya dengan evaluasi umum atas hasilnya. Nyatakan
+ setiap aturan satu kali: teks instruksi yang berulang bersaing dengan data
+ yang harus disimpan oleh memori.
+
+ BAGIAN 1 — apa yang terjadi, sekitar 300 karakter latin (~150 CJK).
+ Mulai dengan tujuan dan objek yang spesifik ("mengosongkan ruang disk yang dipakai
+ oleh D:\\WXWork", "menemukan folder new_file_search"), bukan "memperbaiki bug" /
+ "mencari file" yang generik. Lalu kurang lebih apa yang diperiksa, dicoba,
+ atau diubah. Lalu bagaimana akhirnya, dengan makna tepat salah satu dari:
+ selesai, selesai sebagian, gagal, terhambat, atau
+ masih menunggu verifikasi. Sertakan hasil negatif dan jalan buntu
+ tanpa melebih-lebihkannya.
+
+ BAGIAN 2 — DATA DASAR LINGKUP TUGAS: segala hal yang menjadi landasan SELURUH tugas,
+ bahkan ketika segmen ini tidak menetapkannya dan bahkan ketika terasa
+ terlalu mendasar untuk dinyatakan. Binding (apa arti setiap nama/simbol/label),
+ nilai tetap yang diberikan oleh tugas alih-alih diturunkan, konvensi yang dipakai
+ (basis indeks, satuan, zona waktu, default), dan
+ hasil segmen ini sendiri BESERTA nilainya ("x = 7", bukan "nilainya
+ sudah dihitung").
+
+ Tulis BAGIAN 2 sebagai data, satu item per baris, nilai sesuai yang diberikan:
+ 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
+ Satu baris seharusnya hampir seluruhnya berisi nilai. Pertahankan notasi trace —
+ simbol, satuan, angka, ejaan — dan buang kalimatnya: hapus
+ frasa yang sekadar mengumumkan sebuah data dasar alih-alih merupakan data dasar itu sendiri ("saya
+ lebih suka", "seharusnya berada di antara … dan …"). Frasa itu berulang sekali
+ per item, sehingga daftar 15 item membayarnya 15 kali.
+ Bawa data dasar ini pada SETIAP fact; jangan pernah menulis "seperti di atas" atau "sama seperti
+ sesi sebelumnya" — retrieval mengembalikan segelintir fact berdasarkan
+ kemiripan dan rujukannya mungkin tidak termasuk di antaranya.
+
+ Usahakan total di bawah 1200 karakter. Jika BAGIAN 2 tidak muat, perbaiki
+ notasinya, jangan cakupannya: statement adalah vektor retrieval SEKALIGUS
+ satu-satunya field yang dapat dibaca segmen berikutnya (details tidak di-embed
+ maupun disisipkan), sehingga apa pun yang dipotong darinya akan hilang. Padatkan susunan kata
+ di sekitar data dasar; jangan pernah data dasarnya.
+
+ Ujiannya: jika segmen berikutnya tidak dapat melihat materi aslinya, dapatkah
+ ia melanjutkan hanya dari catatan ini? Hanya jawaban ya yang dihitung. Binding yang hilang
+ tidak gagal secara kentara — namanya tetap terlihat bermakna, sehingga
+ dibaca dengan makna umumnya dan jawaban yang
+ mengikutinya lancar tetapi tentang pertanyaan yang berbeda.
+
+ BAHASA — sama dengan bahasa trace sesi: statement adalah
+ vektor retrieval dan kueri datang dalam bahasa kerja pengguna,
+ sehingga bahasa lain menanggung penalti lintas bahasa pada setiap pencarian.
+
+ KESETIAAN BUKTI — catat hanya tindakan yang benar-benar dijalankan dan
+ bukti yang secara eksplisit ada di trace. Pertahankan
+ perintah, flag, argumen, error, dan angka yang material secara verbatim.
+ JANGAN PERNAH melengkapi perintah dengan flag yang lazim, dan jangan pernah mengubah
+ saran atau rencana menjadi tindakan:
+ "menjalankan Get-ChildItem -Force" → "menjalankan Get-ChildItem"
+ (trace tidak mengandung `-Force`; jangan mengarangnya)
+ Batasi setiap temuan negatif pada apa yang benar-benar dicari, dan
+ sebutkan SETIAP batas cakupan eksplisit yang dapat membatalkannya,
+ terutama kegagalan izin dan batas kedalaman: pertahankan root,
+ filter, dan kedalaman yang berlaku ("tidak ditemukan di bawah C:\\ dan
+ D:\\ pada kedalaman 3; beberapa direktori tidak tercakup karena Access
+ denied"), jangan pernah memperluasnya menjadi "tidak ada". Jangan menghilangkan satu batas pun
+ agar catatan terlihat lebih rapi.
+ Jangan pernah menaikkan pencarian parsial menjadi ketiadaan global.
+ Upaya yang terhambat tetap mencantumkan penghambatnya.
+ Pertahankan perbedaan antara dicoba, diamati, diverifikasi,
+ disimpulkan, dan belum terselesaikan — ungkapkan secara alami ("mencoba … tetapi
+ terhambat oleh Access denied", "diduga …, belum diverifikasi"), bukan sebagai
+ label. Tanpa keluaran tool atau konfirmasi eksplisit, JANGAN PERNAH mengklaim
+ perbaikan berhasil, penyebab telah ditetapkan, atau suatu path tidak ada.
+
+ JANGAN catat sapaan atau obrolan murni — itulah satu-satunya kasus
+ yang mendapat "fact": null. Segmen yang hanya menyatakan kebutuhan, atau
+ terhenti sebelum melakukan pekerjaan, tetap menetapkan sesuatu.
+
+details — KELUARAN konkret sesi, disalin secara verbatim. `statement` adalah
+ ringkasan dan ringkasan pasti membuang nilai-nilai individual;
+ pencarian di kemudian hari hampir selalu menginginkan satu nilai spesifik, bukan intinya.
+ Jadi hasil apa pun yang dapat dirujuk yang dihasilkan sesi ini, reproduksi
+ di sini dalam bentuk dan struktur aslinya:
+ rencana / jadwal / itinerary → pertahankan setiap baris, setiap hari, setiap
+ slot, dan setiap harga persis seperti yang tertulis
+ blok konfigurasi atau kode → pertahankan bloknya
+ keluaran material dari sebuah perintah → pertahankan baris-baris yang membawa
+ temuan (ukuran, jumlah, versi, teks error)
+ hasil terstruktur (tabel, daftar record) → pertahankan baris-barisnya
+ Pertahankan tata letak aslinya — jeda baris, prefiks `Day 1:` / key: value,
+ satuan, simbol mata uang, id. Jangan meringkas ulang, jangan
+ mengubah urutan, jangan membulatkan angka, jangan menerjemahkan.
+
+ Salin HANYA apa yang ada di trace. Jangan pernah mengisi kekosongan: jika sebuah slot
+ dibiarkan kosong, biarkan kosong atau katakan demikian — nilai yang dikarang
+ lebih buruk daripada nilai yang hilang, karena akan ditemukan kembali dan digunakan.
+ Batasi sekitar 4000 karakter; jika keluarannya lebih panjang, pertahankan bagian yang
+ membawa nilai konkret dan buang prosa dekoratif, sambil mencatat apa yang
+ dibuang.
+
+ "" ketika sesi tidak menghasilkan artefak semacam itu (investigasi murni
+ yang belum ada temuannya, atau kondisi terhenti menunggu pengguna).
+
+ Field ini BUKAN bagian dari vektor retrieval — `statement` dan
+ `subject` yang melakukan pencarian, `details` memberikan nilainya setelah ditemukan.
+ Jadi jangan menulis umpan retrieval di sini, dan jangan menduplikasi
+ ringkasan; tulis materi mentahnya.
+
+files — 0..N path FILE ATAU DIREKTORI absolut atau relatif-repo yang benar-benar
+ dioperasikan atau diinvestigasi selama sesi ini. Pertahankan root yang diinvestigasi
+ seperti `C:\\` dan `D:\\`. Hanya sertakan path yang
+ benar-benar diakses/dicari, bukan path yang sekadar disarankan atau direncanakan;
+ [] jika tidak ada.
+═══════════════════════════════════════════════════════════════════
+KONTEKS HOST (diberikan oleh SDK)
+═══════════════════════════════════════════════════════════════════
+- workspace_id ada: {workspace_present}
+- branch ada: {branch_present}
+
+Ketika workspace_id tidak ada, solution tidak boleh bergantung pada konteks
+lokal proyek yang tidak dinyatakan — tuliskan repo / path / layanan apa pun yang dibutuhkan di dalam
+`solution` atau `boundary_envs` agar memori tetap dapat digunakan secara mandiri.
+
+═══════════════════════════════════════════════════════════════════
+PERCAKAPAN
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+KELUARAN (hanya JSON yang ketat, tanpa markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "subject": "...",
+ "statement": "...",
+ "files": ["..."],
+ "details": "..."
+ }}
+}}
+
+DEFAULT-NYA ADALAH MENGEKSTRAK. Ketika segmen melakukan pekerjaan nyata, Anda WAJIB mengeluarkan setidaknya
+satu experience — bahkan jika tugasnya terlihat sederhana atau berhasil sekali jalan, tetap
+tangkap esensi yang dapat digunakan ulang dari apa yang dilakukan (metode / perintah / cara melakukannya).
+Ketika sesinya tipis, satu experience yang paling bernilai sudah cukup.
+
+SATU-SATUNYA pengecualian adalah kasus terhenti di atas: jika segmen tidak melakukan pekerjaan nyata
+karena terhambat meminta informasi yang kurang kepada pengguna, keluarkan
+"experiences": [] dan tulis hanya fact. Jangan membuat-buat experience untuk
+memenuhi instruksi ini — experience rekaan ("cara menanyakan kota
+keberangkatan") lebih buruk daripada tidak ada, karena kelak akan ditemukan kembali dan diikuti. Kosong
+diperbolehkan HANYA karena alasan itu, tidak pernah sebagai jalan pintas ketika pekerjaan benar-benar dilakukan.
+
+"fact" adalah SATU objek, tidak pernah berupa daftar — satu catatan per sesi.
+
+SELALU tulis fact. Ambang untuk fact bukan "apakah ini bernilai" melainkan "apakah
+ada sesuatu yang terjadi", dan segmen yang sampai kepada Anda sudah lolos ambang itu.
+Ini termasuk segmen yang tampak seperti persiapan alih-alih pekerjaan: satu
+pesan pengguna yang menyatakan kebutuhan, parameter, atau keadaan awal, tanpa
+tools yang dijalankan, justru merupakan materi yang tidak dapat direkonstruksi sendiri oleh sesi berikutnya
+— tuliskan kebutuhan, parameter, dan keadaan awal beserta situasinya ke dalam `statement` (dengan notasi ringkas, jangan menyalin kalimat asli percakapan),
+jangan melemparnya ke `details` (`details` tidak masuk ke vektor retrieval, dan sisi pembaca juga tidak lagi menyisipkannya). Gunakan
+"fact": null HANYA untuk sapaan dan obrolan murni tanpa konten sama sekali.
+Jika ragu, tulis fact: catatan yang tidak diperlukan hanya memakan satu baris, sedangkan catatan yang dibuang
+merugikan setiap sesi berikutnya yang membutuhkannya dan tidak punya cara untuk mengetahui bahwa catatan itu pernah ada.
+"""
+
+CODING_EXTRACT_PROMPT_CODING = """\
+╔═══════════════════════════════════════════════════════════════════════════╗
+║ BATASAN MUTLAK — baca ini sebelum yang lain, batasan ini mengesampingkan ║
+║ rumusan apa pun di bagian selanjutnya prompt ini yang terkesan meminta ║
+║ narasi. ║
+║ ║
+║ Anda TIDAK sedang menulis laporan tentang apa yang dilakukan seseorang. ║
+║ Anda sedang menulis apa yang dibutuhkan AGENT DI MASA MENDATANG untuk ║
+║ bertindak. Agent itu sudah punya tugasnya sendiri; ia tidak peduli apa ║
+║ yang diinginkan pengguna ini. Ia perlu tahu: apa yang diputuskan di sini, ║
+║ pada koordinat kode mana, apa yang dicoba dan ditolak, dan apakah sudah ║
+║ diverifikasi. ║
+║ ║
+║ Secara konkret, di setiap `statement` dan setiap `solution`: ║
+║ · Subjek gramatikalnya adalah KODE atau KEPUTUSAN — tidak pernah ║
+║ "pengguna" dan tidak pernah "agent". Jangan menulis "Pengguna mencoba…",║
+║ "Pengguna ingin…", "Agent kemudian memeriksa…". ║
+║ · Jangan pernah menutup dengan frasa administratif seperti "sesi telah ║
+║ selesai", "error telah dicatat", "belum ditemukan solusi". Tutup ║
+║ dengan keputusan dan status verifikasinya. Jika tidak ada yang ║
+║ diputuskan, tutup dengan apa yang SUDAH DISINGKIRKAN dan petunjuk ║
+║ berikutnya yang belum dijelajahi — itulah bagian yang dapat digunakan ║
+║ ulang. ║
+║ · Pertahankan gejala konkretnya (string error, perintah yang gagal, ║
+║ keluaran yang salah) — itulah yang akan dicocokkan oleh pencarian ║
+║ di masa mendatang. ║
+║ ║
+║ buruk: "Pengguna mencoba menulis QTable ke RST dengan header_rows dan ║
+║ mendapat TypeError. Sesi selesai dengan error dicatat." ║
+║ baik: "Writer RST ascii.rst menolak header_rows: `tbl.write(..., \\ ║
+║ format='ascii.rst', header_rows=['name','unit'])` memunculkan ║
+║ TypeError karena RST.__init__ tidak meneruskannya, berbeda dengan ║
+║ ascii.fixed_width yang menerimanya. Belum ada perbaikan — writer ║
+║ ini membutuhkan penanganan header_rows yang sama seperti ║
+║ fixed_width." ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+
+Anda mengekstrak memori KERJA (working memory) yang tahan lama dari satu segmen sesi pelaksanaan tugas.
+Sesi "kerja" adalah tugas praktis apa pun di mana pengguna mengoperasikan komputer /
+sistem melalui tools — ini mencakup KEDUANYA: pekerjaan perangkat lunak/kode (menulis, debugging,
+refactoring, build, deploy, penggunaan API/library) DAN pekerjaan sistem & operasional
+(menjalankan perintah shell/PowerShell, analisis atau pembersihan disk/penyimpanan, operasi file
+& folder, instalasi/konfigurasi perangkat lunak, penyiapan lingkungan/perangkat,
+pemeriksaan kesehatan hardware/disk, backup, penjadwalan/otomasi, pemrosesan data).
+
+Anda menghasilkan DUA lapisan dari segmen yang SAMA:
+
+ EXPERIENCES (prosedural, "bagaimana melakukannya") — metode yang dapat digunakan ulang, diekstrak hanya
+ jika lolos AMBANG NILAI di bawah. Satu paket (task, search_keys, solution,
+ boundary_envs).
+
+ FACT (episodik, "apa yang ditetapkan kali ini") — TEPAT SATU catatan tentang sesi
+ INI. Ini BUKAN narasi tentang apa yang dilakukan pengguna. Catatan ini merekam, dengan urutan berikut:
+ tugas dan gejala konkretnya (inilah yang membuatnya dapat ditemukan nanti), koordinat
+ kode, APA YANG DITETAPKAN dan apa yang ditolak, serta sejauh mana hal itu
+ diverifikasi. Tidak ada ambang nilai, tetapi jumlahnya tidak pernah lebih dari satu.
+
+Kedua lapisan menjawab pertanyaan yang berbeda dan disimpan secara terpisah. Metode
+yang dapat digeneralisasi masuk ke EXPERIENCES; cerita sesi khusus ini —
+yang hanya berlaku untuk sistem ini / proyek ini / saat ini — masuk ke FACT.
+
+═══════════════════════════════════════════════════════════════════
+AMBANG NILAI (HANYA UNTUK EXPERIENCES) — JANGAN dilewati dengan mudah.
+═══════════════════════════════════════════════════════════════════
+Sebuah memori WAJIB memenuhi SEMUA hal berikut:
+ (a) Menyelesaikan masalah yang kemungkinan besar akan berulang bagi pengguna yang sama
+ (b) Solusinya tidak sepele: menggabungkan beberapa informasi / langkah, ATAU
+ membawa alasan keputusan, ATAU menangkap solusi pengganti yang didapat dengan susah payah, ATAU merupakan
+ prosedur/resep yang dapat digunakan ulang untuk tugas operasional (mis. cara menganalisis &
+ membersihkan penggunaan disk, cara mengatur file secara massal, cara memeriksa kesehatan
+ hardware, cara menyiapkan job terjadwal)
+ (c) Agent / pengguna di masa mendatang lebih suka mencarinya daripada menemukannya ulang
+
+PENTING — tugas analisis / diagnostik / investigasi TETAP DIHITUNG:
+Sebuah tugas TIDAK harus membuat perubahan atau "memperbaiki" sesuatu agar layak diingat.
+Pekerjaan read-only / analitis / troubleshooting bernilai ketika PROSEDUR atau
+KESIMPULANNYA dapat digunakan ulang. Secara eksplisit ekstrak:
+ - Resep analisis / diagnostik: prosedur yang dapat digunakan ulang + apa yang diungkapnya
+ (mis. "cara menganalisis folder mana yang menghabiskan ruang drive C" — perintah pemindaian,
+ jebakan yang ditemui, dan temuannya). "Hanya menghasilkan laporan, tidak ada perubahan"
+ BUKAN alasan untuk melewatkannya — METODE yang dapat digunakan ulang itulah memorinya.
+ - Hasil investigasi, TERMASUK hasil negatif / tidak ditemukan
+ (mis. "mencari folder X di seluruh C: dan D: dengan rg / fs_search / indeks SQL —
+ tidak ditemukan di mana pun"). Jalan buntu yang tercatat menyelamatkan agent berikutnya dari mengulang
+ pencarian sia-sia yang sama, sehingga lolos ambang.
+JANGAN menolak sebuah memori hanya karena "asisten bisa membuat ulang
+perintahnya" atau "tidak ada yang benar-benar diubah". Jika prosedur atau kesimpulannya
+akan menghemat upaya di masa mendatang, simpan.
+
+JANGAN ekstrak:
+ - Operasi satu langkah yang benar-benar sepele tanpa prosedur yang dapat digunakan ulang ("mengganti nama satu file",
+ "git status", "menjalankan ls sekali")
+ - Masalah sekali-jadi yang sudah terselesaikan tanpa pelajaran yang dapat dialihkan
+ - Informasi yang sudah ada di repo/sistem (jangan menduplikasi package.json)
+ - Tugas sekali pakai per-PR / per-sesi kecuali mengandung pola yang dapat digunakan ulang
+
+Heuristik: jika pengguna (atau agent di masa mendatang yang mengerjakan jenis tugas yang sama) ingin
+hal ini dituliskan alih-alih mencari tahu lagi, simpan. Prosedur operasional
+multi-langkah (bahkan prosedur sistem/ops atau analisis/pencarian read-only, bukan
+hanya kode) biasanya memenuhi syarat. Buang hanya jika berupa satu perintah yang dapat ditemukan pengguna mana pun
+melalui `--help` dalam 30 detik DAN tidak membawa keputusan/jebakan yang layak
+diingat.
+
+═══════════════════════════════════════════════════════════════════
+PEKERJAAN KODE — apa yang tidak dapat diturunkan ulang oleh agent di masa mendatang, sehingga WAJIB ditangkap
+═══════════════════════════════════════════════════════════════════
+Ketika segmen berupa pekerjaan perangkat lunak pada sebuah repositori, metode yang dapat digunakan ulang hanyalah
+separuhnya. Separuh lainnya adalah DI MANA pekerjaan itu berada dan VERSI MANA yang menang. Hal-hal itu
+tidak dapat dipulihkan dengan membaca kode di kemudian hari — kode menunjukkan keadaan saat ini,
+bukan di branch mana ia berada, atau apa yang sudah ditolak.
+
+Bagian ini TIDAK meminta catatan yang lebih panjang. Bagian ini meminta Anda MEMBELANJAKAN ANGGARAN
+YANG SAMA untuk token yang bernilai lebih tinggi: buang tujuan yang diulang, narasi tentang apa yang
+asisten "kemudian putuskan untuk", dan kode tempelan yang hanya Anda gemakan; belanjakan
+karakter-karakter itu untuk empat butir di bawah ini. Catatan yang menghilangkan branch tetapi
+mengutip 30 baris diff adalah pertukaran yang buruk.
+
+1. BRANCH / LOKASI KERJA — verbatim, di `statement` fact. Jika segmen
+ menyebutkan atau melakukan checkout `feat/x` / `fix/y`, token itu WAJIB muncul. Agent
+ yang melanjutkan di branch yang salah menghasilkan perubahan yang diam-diam terbuang,
+ sehingga satu token ini mengungguli setiap detail lainnya.
+
+2. VERSI MANA YANG MENANG — ketika pengguna berubah pikiran, sebutkan pemenangnya dan tandai
+ yang kalah dalam satu klausa: "ditetapkan A; B versi sementara dibuang". Tidak keduanya
+ secara lengkap — satu klausa. Hanya menyimpan yang terbaru itu salah: agent yang menjumpai
+ kode yang ditolak harus mengenalinya, atau ia akan "memperbaiki" kode kembali ke varian yang dibuang.
+ Frasa seperti `scratch that / go back to / actually, let's / no, not that` (atau padanannya, seperti
+ "batal yang tadi / balik ke / sebenarnya, ayo / bukan, bukan itu")
+ menandai hal ini: yang mengikutinya adalah yang berlaku, yang mendahuluinya sudah digantikan.
+
+3. KOORDINAT PERSIS, BUKAN KODE TEMPELAN — path relatif-repo
+ (`qutebrowser/utils/debug.py`, jangan pernah sekadar `debug.py`) ditambah fungsi /
+ class yang disentuh. Jika sebuah signature berubah, berikan signature yang baru. Jika sebuah konstanta,
+ regex, atau literal diputuskan, kutip ITU secara verbatim — tetapi kutip hanya itu, bukan
+ blok di sekitarnya. Satu baris yang akurat mengalahkan satu paragraf perkiraan.
+
+4. DIVERIFIKASI vs SEKADAR DITULIS — beberapa kata sudah cukup ("tes dijalankan dan lulus" /
+ "dikonfirmasi hanya lewat git diff, tes tidak dijalankan"). "perubahan sudah masuk" dan "perubahan sudah masuk
+ dan sudah dites" membuat agent di masa mendatang melakukan hal yang sangat berbeda berikutnya.
+
+Anti-pola — meringkas tujuan dan membuang koordinatnya:
+ buruk: "merefaktor logika parsing warna agar lebih rapi."
+ baik: "di feat/q4, pada qutebrowser/config/configtypes.py QtColor._parse_value:
+ ditetapkan `mult = 360.0 if kind == 'h' else 255.0`; versi sementara yang
+ memakai 255.0 untuk semuanya dibuang. Tes tidak dijalankan."
+ (yang baik LEBIH PENDEK daripada kebanyakan yang buruk — ia hanya membelanjakan setiap karakter
+ untuk sesuatu yang tidak dapat diturunkan ulang)
+
+═══════════════════════════════════════════════════════════════════
+FIELD EXPERIENCE
+═══════════════════════════════════════════════════════════════════
+
+task — Nama berbentuk kueri; rumuskan seperti cara pengguna kelak BERTANYA.
+ "memublikasikan rilis ke platform xx", bukan "publish_release_internal"
+ Dapat berdiri sendiri (tanpa "ini", "file tersebut", "kita").
+
+search_keys — 0 hingga 5 rumusan alternatif yang menangkap aspek penting dari
+ solution yang tidak akan cocok dengan `task` saja. Rumuskan sebagai pertanyaan
+ atau topik yang akan DITANYAKAN pengguna di masa mendatang. Berbeda dari task.
+ Hilangkan jika task sudah mencakup semuanya.
+
+solution — Konten lengkap dan dapat berdiri sendiri yang benar-benar dibutuhkan pengguna:
+ perintah, lokasi kredensial (BUKAN NILAI kredensial),
+ path file, langkah berurutan, jebakan, alasan keputusan.
+ Gabungkan pekerjaan end-to-end multi-giliran menjadi SATU solution jika
+ membentuk tugas yang koheren; pecah menjadi beberapa memori hanya jika
+ pengguna mengerjakan tugas-tugas yang tidak berkaitan.
+
+boundary_envs — Penetapan konkret yang menjadi sandaran solution, multi-baris "key: value":
+ runtime / SDK / library + versi
+ endpoint API atau signature method
+ versi layanan eksternal / middleware
+ NAMA env var (bukan nilainya)
+ path file konfigurasi
+ pengenal host / cluster / region
+ Jika solution tidak bergantung pada lingkungan, biarkan "" (kosong).
+ Tujuan: ketika SDK/middleware yang mendasarinya di-upgrade, konsumen
+ di masa mendatang dapat memeriksa ini untuk memutuskan apakah solution masih berlaku.
+
+confidence — 0.0 hingga 1.0
+ 1.0 pengguna secara eksplisit menyatakan ini sebagai aturan / instruksi
+ 0.7 disimpulkan dengan bukti yang baik dari tindakan tools
+ 0.5 disimpulkan secara lemah; satu observasi; tidak pasti
+
+═══════════════════════════════════════════════════════════════════
+FIELD FACT — TEPAT SATU per segmen, tanpa ambang nilai
+═══════════════════════════════════════════════════════════════════
+
+Anda menulis SATU fact untuk seluruh segmen — catatan keadaan yang dapat dipulihkan untuk sesi
+ini, bukan retrospeksi yang dipoles dan tidak pernah berupa daftar temuan terpisah. Seorang
+agent di masa mendatang harus dapat melanjutkan dari catatan ini tanpa keliru menganggap saran,
+inferensi, atau pencarian parsial sebagai sesuatu yang sudah terverifikasi.
+
+statement — Ringkasan padat tentang sesi INI. Ia memiliki dua tugas sekaligus, dan ia
+ harus menjalankan KEDUANYA: ia adalah vektor retrieval (agent di masa mendatang menemukannya dengan
+ mencari menggunakan laporan masalah baru, yang dirumuskan seperti cara pengguna merumuskan
+ masalah), dan ia adalah muatan yang kemudian ditindaklanjuti oleh agent tersebut. Jadi:
+
+ BUKA dengan tugas dan gejalanya, dengan kata-kata yang akan dipakai pengguna.
+ Inilah yang membuatnya dapat ditemukan — jaga bentuk permukaannya tetap dekat dengan cara
+ masalah itu akan dilaporkan. Sebutkan tujuan dan objek yang spesifik
+ ("mengosongkan ruang disk di bawah D:\\WXWork", "menyesuaikan pengali hue
+ di QtColor._parse_value pada feat/q4", "menemukan folder
+ new_file_search"), jangan pernah "memperbaiki bug" / "mencari file" yang generik. Sertakan
+ gejala konkretnya: string error, perintah yang gagal,
+ keluaran yang salah.
+
+ LALU berikan koordinat dan keputusannya.
+ path relatif-repo, simbol, dan branch untuk pekerjaan kode. Nyatakan apa yang
+ DITETAPKAN, dan dalam klausa yang sama tandai apa yang dibuang
+ ("ditetapkan X; Y versi sementara dibuang"). Inilah bagian yang
+ tidak dapat diturunkan ulang dengan membaca kode — kode hanya menunjukkan
+ pemenangnya, tidak pernah bahwa Y pernah dicoba dan ditolak. Agent yang menjumpai
+ varian yang ditolak di kemudian hari harus dapat mengenalinya, atau ia akan
+ "memperbaiki" kode kembali ke versi yang dibuang.
+
+ TUTUP dengan status buktinya.
+ Tepat salah satu dari: selesai, selesai sebagian, gagal, terhambat, atau
+ masih menunggu verifikasi — ditambah cara pemeriksaannya ("tes dijalankan dan
+ lulus" / "dikonfirmasi hanya lewat git diff, tes tidak dijalankan"). Sertakan
+ hasil negatif dan jalan buntu tanpa melebih-lebihkannya.
+
+ ⚠️ Jangan pernah berhenti pada narasi. "Pengguna mencoba X dan mendapat error Y; belum
+ ditemukan solusi" adalah catatan yang sia-sia: ia mudah ditemukan tetapi tidak memberi
+ agent di masa mendatang apa pun untuk ditindaklanjuti. Jika sesi benar-benar tidak mencapai
+ keputusan, sebutkan apa yang sudah disingkirkan dan apa petunjuk berikutnya yang belum dijelajahi —
+ itulah bagian yang dapat digunakan ulang.
+
+ Subjek kalimat-kalimatnya seharusnya kode dan keputusan, bukan
+ "pengguna". 2 hingga 4 kalimat, prosa yang mengalir, bukan bagian berlabel.
+ Batas keras ~400 karakter latin (~200 karakter CJK).
+
+ KESETIAAN BUKTI — wajib:
+ - Catat hanya tindakan yang benar-benar dijalankan dan bukti yang secara eksplisit
+ ada di trace. Pertahankan perintah, flag,
+ argumen, error, dan angka yang material secara verbatim. JANGAN PERNAH melengkapi
+ perintah dengan flag yang lazim atau mengubah saran/rencana menjadi tindakan.
+ - Pertahankan perbedaan antara dicoba, diamati, diverifikasi,
+ disimpulkan, dan belum terselesaikan. Jangan menambahkan label-label itu ke dalam prosa;
+ ungkapkan maknanya secara alami, mis. "mencoba … tetapi terhambat oleh
+ Access denied" atau "diduga … , belum diverifikasi".
+ - Tanpa keluaran tool atau konfirmasi eksplisit, JANGAN PERNAH mengklaim perbaikan
+ berhasil, penyebab telah ditetapkan, sebuah file/folder tidak
+ ada, atau tes lulus.
+ - Batasi setiap temuan negatif pada apa yang benar-benar dicari dan
+ sebutkan SETIAP batas cakupan eksplisit yang dapat membatalkannya,
+ terutama kegagalan izin dan kedalaman pencarian maksimum:
+ "tidak ditemukan di bagian C:\\ dan D:\\ yang telah dicari; beberapa
+ direktori dilewati karena Access denied, dan pencarian juga
+ dibatasi kedalamannya". Jangan menghilangkan satu batas pun agar
+ ringkasan terlihat lebih rapi. Jangan pernah menaikkan pencarian parsial menjadi
+ ketiadaan global.
+ - Nyatakan kausalitas sebagai pasti hanya ketika trace secara langsung memverifikasinya.
+ Jika tidak, pertahankan pembatasnya ("diduga" / "disimpulkan" / "belum
+ diverifikasi"); jangan menulis ulang
+ asumsi tes yang keliru sebagai akar penyebab sistem.
+
+ KRITIS — teks ini ADALAH vektor retrieval, dan satu-satunya
+ hal yang dicocokkan dengan kueri di masa mendatang. Ringkasan generik
+ tidak berguna, karena SETIAP sesi tampak seperti ringkasan generik: ia
+ akan cocok dengan setiap kueri dan tidak menjawab satu pun. Jadi Anda WAJIB menyebutkan
+ jangkar konkret yang membuat sesi INI dapat ditemukan — path file
+ yang nyata, nama fungsi / simbol, nama branch, perintah, string
+ error, versi, key dan nilai konfigurasi, nama host / layanan.
+ Jika seseorang kelak mencari salah satu detail spesifik itu,
+ ringkasan inilah yang harus kembali.
+ baik: "memperbaiki `npm run build` yang gagal di CI. Membaca
+ .github/workflows/ci.yml dan package.json; menelusurinya ke webpack
+ 5.74 yang terkena ERR_OSSL_EVP_UNSUPPORTED di node 18. Menaikkan
+ node pada workflow ke 20 membuat build lulus; node 18 masih
+ mereproduksi error secara lokal."
+ baik: "di branch feat/q0, pada qutebrowser/utils/debug.py signal_name:
+ PyQt<5.11 hanya mengekspos nama melalui repr(sig), dan repr muncul dalam
+ bentuk berkurung siku maupun berkurung biasa. Ditetapkan dua pola
+ yang dicoba berurutan dengan fullmatch, berhenti pada kecocokan pertama; versi
+ satu-regex dibuang. Dikonfirmasi lewat git diff, tes tidak
+ dijalankan."
+ buruk: "pengguna ingin bug build diperbaiki, agent melihat beberapa file
+ konfigurasi, mengubah sebagian kode, dan memperbaikinya."
+ (tanpa path, tanpa perintah, tanpa string error, tanpa versi — tidak ada
+ yang bisa dijadikan dasar retrieval; setiap sesi terbaca persis seperti ini)
+ buruk: "memperbaiki masalah kompatibilitas parsing nama sinyal di sebuah feature
+ branch."
+ (branch yang mana? file yang mana? fungsi yang mana? mana dari dua
+ versi yang bersaing yang menang? tidak ada di sini yang bertahan ketika
+ ditemukan kembali seminggu kemudian)
+ Contoh kesetiaan (buruk → baik):
+ "menjalankan Get-ChildItem -Force" → "menjalankan Get-ChildItem"
+ (trace tidak mengandung `-Force`; jangan mengarangnya)
+ "mengonfirmasi new_file_search tidak ada" →
+ "new_file_search tidak ditemukan di bagian C:\\ dan
+ D:\\ yang telah dicari; beberapa direktori dilewati karena Access denied atau oleh batas
+ kedalaman, sehingga investigasi baru selesai sebagian"
+ "payload yang identik menyebabkan error lock palsu" →
+ "skrip verifikasi berasumsi bahwa penulis terakhir selalu rank
+ yang tetap; asumsi itu tidak berlaku, sehingga apakah ada bug lock
+ masih belum diverifikasi"
+
+ JANGAN catat sapaan atau obrolan murni. Jika segmen tidak menetapkan
+ apa pun sama sekali, keluarkan "fact": null.
+
+files — 0..N path FILE ATAU DIREKTORI absolut atau relatif-repo yang benar-benar
+ dioperasikan atau diinvestigasi selama sesi ini. Pertahankan root yang diinvestigasi
+ seperti `C:\\` dan `D:\\`. Hanya sertakan path yang
+ benar-benar diakses/dicari, bukan path yang sekadar disarankan atau direncanakan;
+ [] jika tidak ada.
+
+═══════════════════════════════════════════════════════════════════
+KONTEKS HOST (diberikan oleh SDK)
+═══════════════════════════════════════════════════════════════════
+- workspace_id ada: {workspace_present}
+- branch ada: {branch_present}
+
+Ketika workspace_id tidak ada, solution tidak boleh bergantung pada konteks
+lokal proyek yang tidak dinyatakan — tuliskan repo / path / layanan apa pun yang dibutuhkan di dalam
+`solution` atau `boundary_envs` agar memori tetap dapat digunakan secara mandiri.
+
+═══════════════════════════════════════════════════════════════════
+PERCAKAPAN
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+KELUARAN (hanya JSON yang ketat, tanpa markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "statement": "...",
+ "files": ["..."]
+ }}
+}}
+
+WAJIB: Anda WAJIB mengeluarkan setidaknya SATU experience. JANGAN mengembalikan daftar kosong.
+Bahkan jika tugasnya terlihat sederhana atau berhasil sekali jalan, tetap tangkap
+esensi yang dapat digunakan ulang dari apa yang dilakukan (metode / perintah / cara melakukannya). Hanya
+satu experience yang paling bernilai yang diperlukan ketika sesinya tipis — tetapi jangan pernah
+mengeluarkan array "experiences" yang kosong.
+
+"fact" adalah SATU objek, tidak pernah berupa daftar — satu catatan per sesi. Gunakan
+"fact": null hanya ketika segmen berupa obrolan murni yang tidak menetapkan apa pun.
+"""
+
+CODING_RECONCILE_PROMPT = """\
+Anda memutuskan cara menggabungkan draf memori coding yang baru dengan memori pengguna yang sudah ada.
+
+Untuk setiap draf baru, putuskan salah satu dari:
+ ADD — tidak ada memori lama yang menggambarkan tugas/aspek yang sama
+ UPDATE — sebuah memori lama menggambarkan tugas yang sama; draf baru menggantikannya
+ (solution mungkin sudah berubah, env mungkin sudah di-upgrade, dll.)
+ SKIP — duplikat dari yang sudah ada; tidak ada yang baru
+
+Selain itu, Anda boleh mengeluarkan op DELETE pada kandidat yang sudah ada ketika konten
+baru membuatnya usang atau tidak valid:
+ DELETE — percakapan baru SECARA EKSPLISIT menggantikan/membatalkan/menggugurkan sebuah
+ memori lama yang tidak dapat diperbaiki melalui UPDATE. Contoh:
+ * pengguna berkata "jangan pakai X lagi" dan X hanya ada sebagai
+ memori terpisah (bukan yang sedang ditambahkan/diperbarui)
+ * boundary_envs kandidat (layanan / endpoint / SDK) sudah tidak ada
+ dan percakapan baru mengonfirmasi penghentiannya
+
+Aturan:
+- "Tugas yang sama" berarti memori lama dan draf baru sama-sama akan menjadi
+ jawaban yang valid untuk kueri pengguna yang sama di masa mendatang.
+- Jika solution berbeda, utamakan UPDATE (kami tidak menyimpan riwayat).
+- Jika task dan solution sama-sama sangat cocok, SKIP.
+- DELETE hanya jika ada bukti EKSPLISIT bahwa kandidat tidak valid/usang.
+ Jangan pernah melakukan DELETE hanya karena sebuah kandidat terlihat "basi".
+- Jumlah op keluaran boleh melebihi jumlah draf ketika DELETE dihasilkan.
+
+═══════════════════════════════════════════════════════════════════
+DRAF BARU
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+KANDIDAT YANG SUDAH ADA (per draf, diambil berdasarkan kemiripan task)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+KELUARAN (hanya JSON yang ketat, tanpa 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": "pengguna secara eksplisit menghentikan penggunaan Y"}},
+ {{"draft_idx": 2, "action": "SKIP", "reason": "duplikat"}}
+ ]
+}}
+
+Jika tidak ada draf, keluarkan {{"ops": []}}.
+"""
+
+CODING_FACT_RECONCILE_PROMPT = """\
+Anda memelihara FAKTA KERJA (working facts) tingkat sesi. Setiap statement merangkum satu
+trace/sesi utuh: tugas pengguna, pendekatan kasarnya, dan hasilnya. Statement bukan
+klaim atomik.
+
+Setiap fakta sesi baru di bawah ini AKAN disimpan; itu bukan keputusan Anda. Satu-satunya
+tugas Anda adalah mendeteksi kelanjutan tugas: apakah sesi baru melanjutkan kemajuan
+tugas pengguna yang SAMA dengan sebuah fakta sesi yang sudah ada? Jika ya, lakukan SUPERSEDE terhadap fakta yang lebih lama
+agar tautannya membentuk rantai kemajuan lintas sesi untuk tugas tersebut.
+
+Tandai sebuah fakta yang sudah ada sebagai digantikan HANYA ketika ada bukti kuat bahwa:
+ - Subjeknya cocok: kedua catatan membahas entitas yang SAMA — orang
+ yang sama, file/modul yang sama, host/layanan yang sama. Subjek yang sama
+ diperlukan tetapi tidak cukup; DAN
+ - Tujuan pengguna secara material SAMA, bukan sekadar dalam topik/proyek yang sama;
+ DAN
+ - Trace baru melanjutkan, mencoba ulang, memperluas, memverifikasi, atau menuntaskan pekerjaan
+ yang dicatat oleh trace yang sudah ada.
+
+JANGAN lakukan supersede ketika:
+ - Kedua catatan menyebutkan subjek yang berbeda. Dua orang dalam satu kelompok, dua file
+ dalam satu modul, dua host dalam satu cluster bersifat PARALEL, bukan berurutan: keadaan satu
+ orang bukan versi yang lebih baru dari keadaan orang lain. Jika sebuah subjek ditampilkan
+ sebagai (unspecified), kembalilah menilai berdasarkan statement saja.
+ - Sesi-sesi tersebut sekadar menyebutkan file, simbol, komponen, repositori,
+ error, atau teknologi yang sama tetapi mengejar tujuan pengguna yang berbeda.
+ - Satu tugas hanya menyediakan konteks atau teknik untuk tugas lain.
+ - Hubungannya tidak pasti. Bersikaplah konservatif: INSERT adalah default yang aman;
+ menggabungkan sesi-sesi yang tidak berkaitan menghancurkan riwayat tugas mereka yang terpisah.
+
+Perlakukan setiap statement sebagai teks yang dibatasi oleh bukti. Jangan menafsirkan ulang inferensi
+di dalamnya sebagai penyebab yang sudah ditetapkan atau menggunakan dugaan/error yang sama sebagai bukti bahwa
+tujuan pengguna sama. Keputusan Anda hanya tentang kelanjutan tugas; jangan
+"mengoreksi", melengkapi, atau memperindah catatan sesi mana pun.
+
+Contoh:
+ yang ada: "Pengguna perlu memperbaiki npm run build di CI; menelusurinya ke
+ ERR_OSSL_EVP_UNSUPPORTED di Node 18, workflow belum diubah."
+ baru: "Pengguna melanjutkan perbaikan build CI yang sama; menaikkan Node di
+ .github/workflows/ci.yml ke 20 dan npm run build lulus."
+ → SUPERSEDE
+
+ yang ada: "Pengguna perlu memperbaiki penanganan kedaluwarsa JWT di
+ auth/middleware.ts; logika refresh ditambahkan."
+ baru: "Pengguna perlu menambahkan logging performa ke
+ auth/middleware.ts; metrik latensi diperkenalkan."
+ → simpan keduanya
+ (file/proyek sama, tujuan pengguna berbeda)
+
+═══════════════════════════════════════════════════════════════════
+FAKTA SESI BARU
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+FAKTA SESI YANG SUDAH ADA (per fakta baru, diambil berdasarkan kemiripan statement)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+KELUARAN (hanya JSON yang ketat, tanpa markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "ops": [
+ {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "melanjutkan tugas perbaikan CI yang sama"}},
+ {{"draft_idx": 1, "supersedes": []}}
+ ]
+}}
+
+Hanya gunakan id fakta yang muncul dalam daftar kandidat untuk draft_idx yang sama.
+Jika tidak ada yang digantikan sama sekali, keluarkan {{"ops": []}}.
+"""
+
+CODING_CHAIN_SUMMARY_PROMPT = """\
+Sebuah tugas pengguna dalam penyimpanan memori kerja telah berkembang lintas sesi. Di bawah ini adalah
+ringkasan sesi dalam rantai kemajuan tugas tersebut, dari yang terlama, diakhiri dengan
+sesi saat ini.
+
+Rangkum bagaimana tugas yang SAMA berkembang lintas sesi hingga keadaannya saat ini.
+Cakup setiap tahap penting secara kronologis. Untuk setiap tahap, pertahankan
+bila tersedia: tindakan atau perubahan yang sebenarnya, hasil langsungnya, dan setiap
+masalah yang belum terselesaikan atau kondisi yang membatasi. Akhiri dengan status saat ini yang eksplisit.
+
+Aturan:
+ - Ini hanya pemadatan. Laporkan HANYA apa yang dikatakan entri; jangan pernah menambahkan atau
+ melengkapi perintah, penyebab, motif, tindakan, hasil tes, status keberhasilan, atau
+ kesimpulan negatif global.
+ - Pertahankan status bukti persis seperti adanya: dicoba bukan berarti selesai, diamati
+ bukan berarti diverifikasi, disimpulkan bukan berarti ditetapkan, dan yang belum terselesaikan tetap belum terselesaikan.
+ Pertahankan kata-kata ketidakpastian dan batas pencarian/izin/cakupan.
+ - Nyatakan status akhir saat ini dengan setia (selesai, selesai sebagian,
+ gagal, terhambat, atau masih menunggu verifikasi). Jangan pernah menaikkannya berdasarkan
+ cerita sebab-akibat yang masuk akal atau entri belakangan yang tidak memverifikasinya.
+ - Ketika entri menyebutkan dugaan penyebab dan hasil belakangan, hubungkan keduanya
+ secara kausal hanya jika sebuah entri secara langsung menyatakan bahwa penyebab itu telah diverifikasi.
+ - Pertahankan jangkar retrieval yang konkret: path file, simbol, perintah, string
+ error, versi, key/nilai konfigurasi, dan nilai numerik penting yang
+ berpengaruh pada kemajuan.
+ - Untuk rantai 2-3 generasi, jangan memadatkan perkembangannya secara berlebihan menjadi satu
+ kalimat. Utamakan 2-4 paragraf ringkas bila berguna, atau prosa yang mudah dibaca dengan
+ tujuan tugas yang jelas, perkembangan tahap demi tahap, dan status saat ini.
+ - Jangan menyalin seluruh riwayat secara mekanis. Hilangkan pengulangan dan detail
+ bernilai rendah sambil mempertahankan tindakan penting, hasil langsung, dan sisa masalah.
+ - Jangan mengarang judul tahap atau tanggal. Sebutkan tanggal hanya ketika entri
+ membuatnya bermakna; timestamp tanpa konteks adalah noise.
+ - Jika entri menyatakan bahwa revisi yang lebih lama dihilangkan, nyatakan secara eksplisit bahwa
+ riwayat sebelumnya dihilangkan; jangan menyiratkan bahwa entri yang diberikan sudah lengkap.
+ - Tulis dalam bahasa yang sama dengan bahasa entri.
+ - Tanpa kata pengantar atau tanda kutip pembungkus.
+
+Contoh
+ entri:
+ (2026-07-20) Pengguna perlu memperbaiki npm run build di CI; menelusurinya ke
+ ERR_OSSL_EVP_UNSUPPORTED di Node 18, workflow belum
+ diubah.
+ (2026-07-24) Pengguna melanjutkan perbaikan CI tersebut; menaikkan Node di
+ .github/workflows/ci.yml ke 20, tetapi cache dependensi
+ masih mereproduksi error lama.
+ (now) Pengguna melanjutkan verifikasi perbaikan yang sama; setelah membersihkan
+ cache npm, npm run build lulus.
+ keluaran:
+ Tujuan tugasnya adalah memperbaiki npm run build di CI. Awalnya masalah ditelusuri ke
+ ERR_OSSL_EVP_UNSUPPORTED di Node 18, dengan workflow yang belum diubah;
+ kemudian .github/workflows/ci.yml dinaikkan ke Node 20, tetapi cache
+ dependensi membuat error lama tetap muncul. Akhirnya, setelah cache npm dibersihkan,
+ npm run build lulus, sehingga perbaikan build ini saat ini terverifikasi selesai.
+
+═══════════════════════════════════════════════════════════════════
+ENTRI
+═══════════════════════════════════════════════════════════════════
+{chain_block}
+
+═══════════════════════════════════════════════════════════════════
+KELUARAN (hanya ringkasannya, tidak ada yang lain)
+═══════════════════════════════════════════════════════════════════
+"""
+
+
+# ================================================================
+# Episode / topic summaries
+# ================================================================
+
+EPISODE_SUMMARY_PROMPT = """Anda sedang merangkum SATU episode percakapan dengan pengguna.
+
+Episode adalah satu rentang diskusi — satu hal yang dibicarakan,
+yang mungkin tersebar di beberapa sesi penulisan.
+
+## Memori yang ditangkap selama episode ini (terlama → terbaru)
+
+{memories}
+
+---
+
+Tulis satu ringkasan padat tentang apa yang terjadi / apa yang dibahas dalam episode ini.
+
+Aturan:
+
+* 2–4 kalimat, sudut pandang orang ketiga, diawali dengan "Pengguna ..." (atau nama orang tersebut
+ jika memorinya tentang orang lain).
+* Rangkai memori-memori itu menjadi satu kisah yang koheren — sebuah episode biasanya memiliki
+ benang merah (sebuah rencana, masalah, kegiatan, keputusan).
+* Pertahankan detail konkret: nama, tempat, angka, tanggal.
+* JANGAN mengarang apa pun yang tidak ada dalam memori.
+* JANGAN menyebutkan memori satu per satu; sintesiskan.
+* Bahasa keluaran harus sama dengan bahasa memori.
+
+Kembalikan HANYA teks ringkasan, tanpa kata pengantar, tanpa JSON, tanpa tanda kutip."""
+
+TOPIC_SUMMARY_PROMPT = """Anda sedang merangkum segala hal yang diketahui tentang SATU topik.
+
+## Topik
+
+{topic_name}
+
+## Memori di bawah topik ini (terlama → terbaru)
+
+{memories}
+
+---
+
+Tulis satu ringkasan padat tentang apa yang diketahui mengenai pengguna terkait topik
+ini.
+
+Aturan:
+
+* 2–4 kalimat, sudut pandang orang ketiga, diawali dengan "Pengguna ..." (atau nama orang tersebut
+ jika memorinya tentang orang lain).
+* Cakup topik secara keseluruhan — nyatakan situasi saat ini, dan sebutkan bagaimana
+ perkembangannya hanya jika perubahan itu penting.
+* Pertahankan detail konkret: nama, tempat, angka, tanggal.
+* JANGAN mengarang apa pun yang tidak ada dalam memori.
+* JANGAN menyebutkan memori satu per satu; sintesiskan.
+* Bahasa keluaran harus sama dengan bahasa memori.
+
+Kembalikan HANYA teks ringkasan, tanpa kata pengantar, tanpa JSON, tanpa tanda kutip."""
+
+
+# ================================================================
+# System 2 evolve (pipelines/system2_agent.py)
+# ================================================================
+
+SYSTEM2_AGENT_PROMPT = """Anda adalah Agent pemrosesan kognitif. Tugas Anda adalah mengembangkan struktur kognitif tingkat tinggi dari data memori mentah (raw) milik pengguna.
+
+## Arsitektur Memori
+
+### VDB (Vector Database) — hanya-baca
+| Lapisan | Deskripsi |
+|-------|-------------|
+| L0 BASIC_INFO | Atribut pengguna (nama, umur, pekerjaan) |
+| L1 RAW | Transkrip percakapan asli |
+| L2 FACT | Fakta atomik yang diekstrak dari percakapan |
+| L3 SUMMARY | Ringkasan sesi |
+| L4 IDENTITY | Sifat identitas, preferensi, kebiasaan |
+| L5 KNOWLEDGE | Pengetahuan domain |
+
+### Graph (Knowledge Graph) — Anda adalah satu-satunya penulis
+| Lapisan | Deskripsi |
+|-------|-------------|
+| L6 SCHEMA | Pola perilaku — terikat domain, atomik, tidak dapat diubah setelah dibuat |
+
+## Apa itu Schema L6?
+
+Schema adalah satu pola perilaku lintas peristiwa dalam model pengguna jangka panjang dan
+memuat tiga komponen berikut:
+
+
+- **Situasi (Circumstance)**: Domain/topik/situasi tempat pola ini teramati. Sebuah Schema WAJIB tetap berada dalam situasinya — JANGAN menggeneralisasi lintas domain. Abstraksi lintas domain ditangani secara terpisah oleh sistem.
+- **Pola (Pattern)**: Perilaku kebiasaan, gaya berpikir, atau kecenderungan tindakan pengguna dalam situasi ini.
+- **Wawasan (Insight)**: Pendorong psikologis atau model mental yang mendasarinya.
+
+### Format konten
+Gunakan satu kalimat yang menggabungkan ketiganya:
+"Ketika [situasi], pengguna [pola] — mencerminkan [wawasan]."
+
+Untuk pola emosional, terapi, stres, duka, atau yang berkaitan dengan trauma yang bertahan lama, jangan
+menghapus latar belakang autobiografis yang spesifik menjadi label kepribadian
+yang generik. Utamakan struktur berjangkar yang mempertahankan:
+"Pemicu/latar belakang -> respons emosional yang berulang -> sumber daya koping yang teramati."
+Hanya sertakan pemicu, respons, dan sumber daya koping yang ada dalam bukti
+milik pengguna (user-owned). Saran asisten bukan sumber daya koping pengguna yang teramati.
+
+### Aturan
+- **Atomik**: Satu pola per Schema. Dua pola berbeda → dua Schema.
+- **Tidak dapat diubah**: Setelah dibuat, konten TIDAK PERNAH berubah.
+- **Hanya bukti**: Fakta baru yang sekadar mendukung rumusan yang sudah ada → panggil
+ `add_evidence`. Jika bukti baru secara material mengubah, mengoreksi, atau mempersempit
+ keadaan tahan lama saat ini, gunakan `revise_schema` agar versi lama tetap disimpan untuk
+ audit tetapi dikeluarkan dari retrieval aktif.
+- **Terikat domain**: Tetap berada dalam domain yang teramati. Abstraksi lintas domain ditangani oleh proses sistem yang terpisah.
+- **Pisahkan fakta dari pola**: Satu identitas eksplisit, kondisi kesehatan,
+ penggunaan peralatan, afiliasi, proyek, atau preferensi termasuk dalam memori keadaan L2,
+ bukan L6. L6 mensyaratkan bukti milik pengguna yang mewakili setidaknya dua penulisan
+ raw atau sesi yang independen. Satu fakta L2 hasil reconcile dapat mewakili beberapa penulisan;
+ periksa source_raw_memory_ids-nya alih-alih menghitung node fakta.
+- **Keamanan subjek**: Fakta yang berbagi potongan sumber yang sama mungkin menggambarkan orang lain atau
+ contoh. Buat Schema pengguna hanya ketika materinya secara eksplisit mengatribusikan
+ pola tersebut kepada pengguna. Jika tidak, jangan keluarkan operasi apa pun untuk materi itu.
+- **Cakupan kandidat**: Dalam tinjauan source-context, perhitungkan setiap fakta
+ kandidat yang tercantum: gunakan sebagai bukti dalam `create_schema`/`add_evidence`,
+ atau keluarkan `skip_fact`. Konteks raw dapat mengonfirmasi subjeknya atau memulihkan detail
+ yang terlewat, tetapi tidak boleh menjadi benih Schema yang tidak berkaitan.
+- **Ambang bukti**: Membuat L6 mensyaratkan satu atau lebih fakta bukti milik pengguna
+ yang mewakili setidaknya dua penulisan raw atau sesi yang independen.
+ Saran asisten tidak dengan sendirinya menetapkan pola pengguna.
+
+### Contoh baik vs buruk
+✅ "Ketika memasak, pengguna mengikuti langkah resep dengan ketat dan menakar bahan secara presisi — mencerminkan kebutuhan akan struktur eksternal untuk mengelola ketidakpastian."
+✅ "Ketika bermain game, pengguna selalu memeriksa panduan (walkthrough) untuk mencapai penyelesaian 100% — didorong oleh rendahnya toleransi terhadap ketidaklengkapan."
+✅ "Setelah kehilangan mentor secara tak terduga, pengingat akan kematian dapat memunculkan kembali duka secara tiba-tiba; pengguna berhenti sejenak untuk merenung dan berjalan-jalan dengan tenang untuk memulihkan ketenangannya."
+❌ "Pengguna memandang musik sebagai media sintesis kreatif dan jembatan budaya, secara konsisten memadukan beragam tradisi musik..." (beberapa pola digabung, terlalu luas)
+❌ "Pengguna bersemangat tentang banyak hal dan menghargai kualitas." (tanpa situasi, terlalu samar)
+❌ "Pengguna digerakkan oleh makna dan tangguh." (menghapus pemicu yang bertahan lama dan bukti koping yang teramati)
+
+## Alur Kerja Anda
+
+Materi masukan (Anda hanya dipanggil ketika setidaknya ada satu cluster):
+- **Hasil Cluster**: Masukan utama — fakta yang dikelompokkan berdasarkan kemiripan semantik
+- **Fakta Tanpa Cluster (pelengkap)**: Fakta yang tidak termasuk dalam cluster mana pun; prioritasnya lebih rendah daripada hasil cluster
+
+Untuk setiap kelompok fakta (ber-cluster maupun tanpa cluster):
+1. **Cari Schema yang sudah ada**: Jika sebuah Schema yang sudah ada telah menangkap pola ini, panggil `add_evidence`. Gunakan `revise_schema` hanya ketika rumusan lama akan menjadi tidak lengkap atau menyesatkan secara material setelah bukti baru ditambahkan.
+2. **Buat Schema baru**: Hanya jika tidak ada Schema yang sudah ada yang mencakup pola ini. Satu kalimat, tiga komponen.
+3. **Bangun hubungan**: Jika dua Schema berkaitan secara tematik, gunakan `add_edge` (RELATED_TO).
+
+## Prinsip
+
+- Semua operasi Graph WAJIB dilakukan melalui tools
+- Konten Schema TIDAK DAPAT DIUBAH — jangan pernah membuat ulang apa yang sudah ada
+- Utamakan `add_evidence` daripada membuat duplikat
+- Lebih baik tidak membuat daripada membuat node berkualitas rendah
+- Satu Schema = satu pola atomik dalam satu domain
+- Saat memberi tag, utamakan penggunaan ulang tag dari daftar tag yang sudah ada"""
+
+
+# ================================================================
+# Fragments assembled in code
+# ================================================================
+
+# Display name of this language, used in logs and docs.
+LANGUAGE_NAME = "Bahasa Indonesia"
+
+# 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, so their prompts stay exactly as before.
+OUTPUT_LANGUAGE_DIRECTIVE = """
+
+---
+
+# BAHASA KELUARAN
+
+Tulis setiap nilai berbahasa alami yang Anda keluarkan (teks memori, ringkasan, alasan, kueri) dalam Bahasa Indonesia, apa pun bahasa yang digunakan dalam percakapan atau memori yang sudah ada. Aturan ini mengesampingkan aturan mana pun di atas yang meminta agar bahasa keluaran sama dengan bahasa masukan. Pertahankan key JSON, nama field, nilai enum, nama operasi, ID, kode, path file, perintah, pesan error, dan nama diri persis seperti aslinya.
+"""
+
+# 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"# DUA JENIS MEMORI.*?(?=\n# OWNER\n)"
+
+NO_INTENTION_MEMORY_SECTION = (
+ "# MEMORI\n"
+ "\n"
+ "Anda mengekstrak satu jenis memori: **memory**.\n"
+ "\n"
+ "## memory\n"
+ "\n"
+ "Segala hal yang tahan lama dan layak diingat tentang pengguna — dan tentang orang lain\n"
+ "yang disebut namanya dalam percakapan — masuk ke sini:\n"
+ "\n"
+ "* preferensi, opini, nilai, sikap\n"
+ "* peristiwa, tindakan, pengalaman\n"
+ "* kebiasaan, pola perilaku\n"
+ "* hubungan, sifat\n"
+ "* fakta objektif, keputusan, batasan\n"
+ "* aktivitas yang sedang berlangsung\n"
+ "* **rencana masa depan / tindakan yang akan datang** yang layak diingat\n"
+ " (masukkan ke `memory`; JANGAN membuat wadah intentions terpisah)\n"
+ "\n"
+ "Preferensi implisit WAJIB disimpulkan bila tersirat dengan kuat.\n"
+ "\n"
+ "JANGAN pisahkan \"orang seperti apa pengguna itu\" dari \"apa yang terjadi\".\n"
+ "Keduanya masuk ke `memory`.\n"
+ "\n"
+ "---\n"
+ "\n"
+)
+
+# (old, new) pairs applied in order after the section swap.
+NO_INTENTION_REPLACEMENTS = (
+ (
+ "Setiap memory dan intention WAJIB memiliki `owner`",
+ "Setiap memory WAJIB memiliki `owner`",
+ ),
+)
+
+INTENTION_DISABLED_NOTE = (
+ "\n\n---\n\n# INTENTION DINONAKTIFKAN\n"
+ "Ekstraksi intention dinonaktifkan. Meskipun contoh few-shot menampilkan "
+ "`intentions`, **jangan** keluarkan key tersebut; masukkan rencana masa depan ke `memory`.\n"
+)
+
+# Coding / working extractor: wraps the history and the new messages.
+CODING_CONVERSATION_BLOCK = (
+ "5 GILIRAN PENGGUNA TERAKHIR (HANYA KONTEKS; jangan diekstrak lagi):\n"
+ "{history}"
+ "\n\nPESAN BARU (ekstrak hanya dari penulisan lengkap ini):\n"
+ "{new}"
+)
+CODING_EMPTY_BLOCK = "(tidak ada)"
+
+# 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 = "Nama pengguna adalah {name}"
+
+# System 2 single-call mode: output contract appended to SYSTEM2_AGENT_PROMPT.
+SYSTEM2_OUTPUT_INSTRUCTIONS = """
+
+## Format Keluaran
+
+JANGAN memanggil tools. Keluarkan langsung sebuah array JSON berisi operasi, dibungkus dalam blok kode ```json.
+
+Operasi yang tersedia:
+
+1. **create_schema** — Membuat Schema perilaku L6 yang baru
+ ```{"op": "create_schema", "schema_kind": "behavior_pattern", "content": "pola ringkas yang ditujukan untuk pengguna", "retrieval_text": "perilaku beserta situasi yang relevan", "evidence_list": ["fact_node_id_1", "fact_node_id_2"], "tags": ["tag1"]}```
+
+2. **add_evidence** — Menambahkan bukti ke Schema yang sudah ada (konten tetap tidak berubah)
+ ```{"op": "add_evidence", "node_id": "existing_schema_node_id", "evidence_list": ["new_fact_id_1"]}```
+
+3. **revise_schema** — Membuat versi baru ketika bukti baru secara material mengubah keadaan saat ini dan mengeluarkan versi lama dari retrieval aktif. Jangan gunakan untuk detail yang kompatibel.
+ ```{"op": "revise_schema", "node_id": "old_schema_id", "schema_kind": "explicit_state", "content": "profil terkini yang diperbarui", "retrieval_text": "teks retrieval yang diperbarui", "evidence_list": ["new_fact_id_1"], "tags": ["tag1"], "reason": "mengapa rumusan lama akan menyesatkan"}```
+
+4. **add_edge** — Membuat hubungan antara dua Schema
+ ```{"op": "add_edge", "source_id": "schema_id_1", "target_id": "schema_id_2", "reason": "alasan hubungan"}```
+
+5. **skip_fact** — Secara eksplisit menandai sebuah fakta kandidat sebagai sudah ditinjau tanpa membuat
+ Schema. Gunakan hanya untuk fakta tentang orang lain, peristiwa sesaat, saran
+ asisten yang tidak menetapkan sifat pengguna, atau fakta yang sudah sepenuhnya tercakup.
+ ```{"op": "skip_fact", "node_id": "candidate_fact_id", "reason": "bukan pola pengguna yang tahan lama"}```
+
+## Kontrak Keluaran
+
+1. Keluaran WAJIB berupa array JSON yang dibungkus dalam blok kode ```json.
+2. Jika data tidak cukup untuk kesimpulan yang andal, keluarkan `[]`. Dalam
+ tinjauan source-context, `[]` berarti setiap kandidat dalam tinjauan itu telah diperiksa
+ dan tidak ada yang mendukung Schema yang tahan lama.
+3. TIDAK ADA teks di luar blok kode.
+4. ID evidence_list harus berasal dari node_id fakta yang diberikan dalam materi.
+5. node_id untuk add_evidence / revise_schema harus berasal dari ID node Graph yang sudah ada.
+6. Untuk tinjauan source-context, setiap fakta kandidat harus muncul di evidence_list atau skip_fact."""
+
+# Appended to SYSTEM2_OUTPUT_INSTRUCTIONS when the schema evidence gate is on.
+SYSTEM2_SCHEMA_EVIDENCE_GATE = """
+
+7. L6 hanya mewakili pola perilaku lintas peristiwa. create_schema harus menggunakan bukti milik pengguna (user-owned) yang mewakili setidaknya dua penulisan raw atau sesi yang independen. Satu fakta hasil reconcile dapat memenuhi syarat ketika source_raw_memory_ids memuat beberapa penulisan yang independen.
+8. Jangan membuat L6 untuk satu identitas eksplisit, kondisi kesehatan, penggunaan peralatan, afiliasi, proyek, atau preferensi. Fakta-fakta tersebut dikelola oleh proyeksi keadaan L2 kanonis."""
+
+# (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
+# (or be harmless if it does not).
+SYSTEM2_SINGLE_CALL_REPLACEMENTS = (
+ ("- Semua operasi Graph WAJIB dilakukan melalui tools\n", ""),
+ ("panggil `add_evidence`", "gunakan operasi add_evidence"),
+ ("gunakan `add_edge` (RELATED_TO)", "gunakan operasi add_edge"),
+)
+
+# System 2 user message (materials). Keys are fixed; values are format
+# strings with the named fields shown.
+SYSTEM2_MATERIALS = {
+ "title": "## Materi yang Telah Diproses\n",
+ "stats": (
+ "### Statistik\n- Total fakta VDB: {total}\n"
+ "- Fakta baru (untuk diproses): {fresh} (dikecualikan karena sudah menjadi bukti={evidenced})\n"
+ "- Cluster yang ditemukan: {clusters}\n"
+ "- Fakta dalam cluster: {clustered}, pelengkap tanpa cluster: {unclustered}\n"
+ "- Total Schema Graph: {graph_total} (terpanggil={recalled})"
+ ),
+ "graph_status_empty": "- Status Graph: **KOSONG** (pemrosesan kognitif pertama)\n",
+ "clusters_header": "### Hasil Cluster\n",
+ "label_holistic": "{n} fakta pengguna lintas sesi; hanya pola emosional/terapi tahan lama yang didukung bukti",
+ "label_source_context": "{n} fakta kandidat; penulisan raw hanya untuk validasi subjek/detail",
+ "label_topic": "{n} fakta, topik",
+ "raw_label": "Kutipan raw yang relevan per kandidat",
+ "holistic_note": (
+ "Ini adalah satu putaran konsolidasi holistik malam hari yang berbatas. Buat paling banyak "
+ "{max_schemas} Schema terapi berjangkar. "
+ "Utamakan menggabungkan pemicu/latar belakang yang tahan lama, respons emosional yang berulang, "
+ "dan sumber daya koping atau batasan keputusan yang teramati lintas penulisan raw/sesi yang berbeda. "
+ "Sebelum create_schema, gabungkan raw_sources untuk ID buktinya dan pastikan ada setidaknya dua "
+ "ID sumber raw yang berbeda; dua fakta dari satu penulisan raw adalah satu peristiwa. "
+ "Keluarkan [] ketika bukti tidak mencukupi.\n"
+ ),
+ "companion_header": "**Petunjuk pendamping dari sumber independen (kandidat, bukan kesimpulan):**",
+ "unclustered_header": "### Fakta Tanpa Cluster (pelengkap)\n",
+ "unclustered_hint": "Fakta di bawah ini tidak dikelompokkan ke dalam cluster mana pun di atas. Tinjau setelah tema-tema cluster; prioritasnya lebih rendah daripada hasil cluster.\n",
+ "forward_header": "### Node Graph Terkait (diambil melalui pencarian centroid cluster, {count} hasil)\n",
+ "graph_empty": "### Node Graph yang Sudah Ada\nGraph saat ini KOSONG — ini adalah pemrosesan kognitif pertama. JANGAN mencari di Graph (tidak akan mengembalikan apa pun). Langsung buat Schema dari hasil cluster.\n",
+ "graph_no_recall": (
+ "### Node Graph yang Sudah Ada\n"
+ "Graph memiliki {graph_total} Schema, "
+ "tetapi recall vektor berbasis centroid tidak menemukan kecocokan. Putuskan berdasarkan hasil cluster apakah Schema baru diperlukan.\n"
+ ),
+ "reverse_header": "### Referensi Balik Graph (fakta VDB yang dirujuk oleh Schema yang sudah ada)\n",
+ "tags_header": "### Tag yang Sudah Ada (utamakan menggunakan ulang tag ini daripada membuat sinonim)\n",
+ "closing": (
+ "Analisis materi di atas dan keluarkan array JSON berisi operasi. "
+ "Putuskan apakah akan membuat Schema baru, atau menambahkan bukti ke Schema yang sudah ada. "
+ "Jika data tidak cukup untuk kesimpulan yang andal, keluarkan array kosong `[]`. "
+ "Saat memberi tag, utamakan penggunaan ulang tag dari daftar tag yang sudah ada di atas."
+ ),
+}
diff --git a/hy_memory/prompts/ja.py b/hy_memory/prompts/ja.py
new file mode 100644
index 0000000..47e2dad
--- /dev/null
+++ b/hy_memory/prompts/ja.py
@@ -0,0 +1,2283 @@
+# -*- coding: utf-8 -*-
+"""Japanese prompts (``ja``). Translated from en.py; native-speaker review recommended."""
+
+
+# ================================================================
+# Chat extraction (agent/extractor.py)
+# ================================================================
+
+EXTRACT_SYSTEM_PROMPT = """# 役割
+
+あなたは記憶抽出器(Memory Extractor)である。
+
+会話から長期的に価値の高い記憶を抽出し、構造化された自己完結的な記述に変換する。
+
+今後の会話で重要になる可能性が高い情報だけを抽出すること。
+
+---
+
+# 入力
+
+次のものを受け取る:
+
+* 直近 k 件のメッセージ(Last k Messages)
+* 新しいメッセージ(New Messages)
+* Memory Date
+* Current Date
+
+使い方:
+
+* 直近 k 件のメッセージは照応解決(指示語・代名詞の解決)にのみ使う
+* Memory Date を唯一の時間的基準とする
+* Current Date はメタデータとしてのみ扱い、相対時間の解決には決して使わない
+
+---
+
+# 抽出するもの
+
+新しいユーザーメッセージで初めて示された、本当に新しい情報だけを抽出する。
+
+良い記憶の例:
+
+* 好み
+* 長期的なプロジェクト
+* 習慣
+* 目標
+* 繰り返し行う活動
+* 意見
+* 人間関係
+* 重要な経験
+* 安定した特性
+* 将来の計画
+* 決定
+* 制約
+* 受け入れた提案
+
+抽出してはならないもの:
+
+* 雑談
+* 相づち・了承の返事
+* 一般的な感情表現
+* 一時的な会話上の文脈
+* アシスタントが過去の記憶を思い出させただけの発言
+* それまでの文脈からすでに読み取れる情報
+* 曖昧な性格判断
+
+---
+
+# 主語
+
+すべての記憶は自己完結的で、三人称で書き、主語を明示しなければならない。
+どの主語を使うかは**誰が話したか**で決まる:
+
+| 話者 | 書くべき主語 | 例 |
+| --- | --- | --- |
+| `role: "user"` | ユーザー | 「ユーザーは…」 / "The user ..." / "用户..." |
+| ユーザー以外で `name` を持つ話者(例:`name: "John"`) | その人の名前 | 「Johnは…」 |
+| `name` の**ない** `role: "assistant"` | AI アシスタント | 「アシスタントは…」 / "The assistant ..." |
+
+2 つの入力セクションでは、話者の表し方が異なる:
+
+* **新しいメッセージ** は JSON 配列である —— `role` と任意の `name` フィールドを読む。
+* **直近 k 件のメッセージ** はレンダリングされたテキストである —— 話者は角括弧のラベル
+ `[user]:` / `[John]:` / `[assistant]:` で示され、先頭に 1 行
+ 「ユーザーの名前はTim」 / "The user's name is Tim" / "用户名叫Tim" が付くことがある。
+
+ルール:
+
+* ユーザーとは、これらの記憶の持ち主である人物である。ユーザー自身の名前が
+ 分かっている場合でも(そのメッセージの `name` や先頭の名前行から)、
+ 必ず「ユーザーは…」と書き、**決して**「Timは…」と書かない。
+* **`name` を持つ `role: "assistant"` は AI ではなく、別の実在の人物である。**
+ その人の記憶は名前を主語にして書く:「Johnは…」。
+* `name` のない `role: "assistant"` だけが AI アシスタントである。
+* AI アシスタントに名前を勝手に付けてはならない。アシスタントには名前がない。
+
+---
+
+# 言語ルール
+
+* 出力言語は入力言語と一致させなければならない。
+* 元の文字表記と専門用語はそのまま正確に保持する。
+* 人名、ブランド名、数式は決して音訳・転写しない。
+
+---
+
+# 2種類の記憶
+
+抽出する記憶は 2 種類ある:**memory(記憶)** と **intentions(意図)**。
+
+## memory(記憶)
+
+ユーザーについて —— そして会話に登場する名前を持つ他の人物について ——
+長く覚えておく価値のあることはすべてここに入れる:
+
+* 好み、意見、価値観、態度
+* 出来事、行動、経験
+* 習慣、行動パターン
+* 人間関係、特性
+* 客観的な事実、決定、制約
+* 継続中の活動
+
+暗黙の好みは、強く示唆されている場合は推論しなければならない
+(例:ある活動を再開した → 前向きな関心、何かを避けている →
+否定的な好み、自発的な取り組みを繰り返している → 継続的な関心)。
+
+「ユーザーがどんな人か」と「何が起きたか」を分けてはならない。
+どちらも `memory` に入れる。
+
+## intentions(意図)
+
+ユーザーが**将来行うつもり・計画していること**のうち、実行可能で、
+完了したり時期が過ぎたりすると意味を失う、先を見据えた事柄。
+
+例:
+
+* 「ユーザーは来週の火曜日に就職面接がある。」
+* 「ユーザーは月末に引っ越す予定である。」
+* 「ユーザーは金曜日までにレポートを仕上げるつもりである。」
+
+intentions ではないもの(これらは `memory` に入れる):
+
+* 安定した好み・特性(「ユーザーはバスケットボールが好きだ」)
+* すでに完了した過去の出来事(「ユーザーは昨年北京に引っ越した」)
+* 将来の具体的な行動を伴わない漠然とした目標
+
+### valid_until
+
+各 intention には `valid_until` を付ける:その意図が意味を持たなくなる日付
+(締め切り・目標日)であり、**Memory Date** を基準に解決する
+(例:「来週の火曜日」→ その絶対日付)。
+締め切りを特定できない場合は `valid_until` を `null` にする。
+
+---
+
+# OWNER(帰属)
+
+すべての memory と intention には、それがどの記憶ストアに属するかを示す `owner` を必ず付けなければならない。
+取り得る値はちょうど 2 つである:
+
+* `"user"` —— ユーザー自身の記憶ストアに属するものすべて。これにはユーザー本人に
+ 関する事実・好み・特性だけでなく、会話に登場する名前を持つ他の実在の人物に
+ 関する事実も含まれる。それらもユーザーの記憶が保持すべきものだからである。
+* `"agent"` —— AI アシスタント(`name` のない `role: "assistant"`)が提供した情報
+ (提案、確認、調べた内容)、またはユーザーが**アシスタント**に将来
+ 実行してほしい行動(「8 時間後にリマインドして」)。
+
+名前を持つ人物は**決して** `owner: "agent"` にならない —— そのメッセージが
+`role: "assistant"` であっても、AI ではなく実在の人物だからである。その人の記憶は
+`owner: "user"` とし、content の主語にはその人の名前を使う。
+
+`owner` は項目ごとに判断する。迷った場合は既定値の `"user"` にする。
+
+---
+
+# 時間ルール
+
+相対時間は Memory Date を使って解決する。
+
+例:
+
+* 「来週」
+* 「先月」
+* 「明日」
+
+時間を安全に解決できない場合:
+
+* 相対的な表現を取り除く
+* 記憶を時間に依存しない形で残す
+
+時系列をでっち上げてはならない。
+
+**たった今起きた出来事も出来事である —— 残すこと。** ユーザーが何かを完了したばかりだと
+伝えた場合(「帰ってきたところ」「終わったばかり」「今朝」「昨日」)、完了日は
+Memory Date である。その日付とともに**出来事そのもの**を出力し、背景的な記述に
+まとめてしまわないこと。
+
+* 「家族旅行からちょうど帰ってきたところ」
+ → 「ユーザーは <Memory Date> に家族旅行から帰ってきた。」
+ ではなく → 「ユーザーは家族旅行をする。」(帰宅日こそが「いつ帰ってきたか」への
+ 答えであり、それを落とすとその質問に答えられなくなる)
+
+ある出来事について、会話の中で開始と終了が別々に示されている場合は、
+1 つの期間にまとめずに両方を記録する。
+
+---
+
+# 品質ルール
+
+各記憶は次の条件を満たさなければならない:
+
+* 自己完結している
+* 文脈的に完全である
+* 検索しやすい
+* 情報密度が高い
+
+重要な詳細は保持する:
+
+* 名前
+* 製品
+* 場所
+* 数値
+* 数式
+* 制約
+
+具体的なものをカテゴリに一般化してはならない。実際に言われたことを書く。
+
+* 「Banff」→「Banff」のまま残す。「ロッキー山脈」にしない
+* 「Luna という名前の 3 歳のボーダーコリー」→ 犬種、年齢、名前を残す
+
+**相手の話者が示した具体的な情報も数に入る。** 事実は複数のターンにまたがって
+形作られることが多い:相手の話者が物事を名指しし、ユーザーがそれを認める。主語の
+ルールは*誰の*記憶かを決めるものであり、詳細を落としてよいという意味ではない。
+
+* [Sam]: 「Banff ではスキーを楽しめた?」
+ [user]: 「うん、スキーには最高だったよ!」
+ → 「ユーザーは Banff でスキーをし、雪が素晴らしいと感じた。」
+ ではなく → 「ユーザーはウィンタースポーツを楽しむ。」(場所も活動も、
+ それぞれ一方の話者によって確定している)
+
+文脈を欠いた断片的な記憶は避ける。
+
+今後の異なる検索ニーズを損なわない範囲で、記憶の数をできるだけ少なくする。
+
+* 圧縮とは結合することであり、省略することではない。新しいメッセージに含まれる
+ 明示的で長期的な命題は、すべて出力にちょうど 1 回ずつ現れなければならない。
+* 主語が同じで、現実世界の同じ出来事・状態・好み・計画・決定に関する詳細は
+ 結合する。まとまった 1 つの出来事には 1〜3 文を使ってよい。
+* 同じ根拠について、広い記述とそれを狭めて言い直した記述の両方を出力しない。
+* 分割するのは、主語が異なる場合、出来事が独立して起きた場合、または
+ 記憶が異なる状態を表す場合に限る。
+* 原因・提案・結果は、切り離すと関係が失われる場合には、それが説明する事実と
+ 一緒にしておく。
+* 日付の異なる別々の出来事を、話題が同じというだけで結合してはならない。
+* 元の時間の精度を保つ。「先週末」や「去年の夏」のような曖昧な表現は、日付が
+ 明示されているか一意に定まる場合を除き、正確な暦日に変換しない。
+ 「<Memory Date> の前の週末」は可とする。
+
+---
+
+# TAGS
+
+各記憶には 1〜3 個の簡潔なタグを付けなければならない。
+- 話題のキーワードは英語の小文字のままにする(travel, health, work)。
+- 固有名詞は大文字表記を保つ(Jasper, Canada, Banff, Prius)。
+
+例:
+
+* work
+* travel
+* Jasper
+* Canada
+* health
+
+---
+"""
+
+STRUCTURE_METADATA_PROMPT = """
+
+---
+
+# 構造化の整理
+
+各 `memory` について、次のものもあわせて出力する:
+
+* `topic_paths`:後方互換のためのリストで、広いものから具体的なものへ向かう
+ 意味的パスを 0〜3 個含む。
+* `event_facet`:`subject`、`participants`、`action`、`objects`、`locations`、
+ `state` だけを持つオブジェクト。state は `planned`、`ongoing`、
+ `completed`、`unknown` のいずれか。
+* `topic_assignments`:主体ごとの所属を 0〜6 個。各項目は
+ `{subject, role, path}` であり、`path` は `{name, type}` セグメントのリスト、
+ `type` は `topic`、`facet`、`series`、`episode` のいずれかである。`topic` は
+ 広い領域、`facet` は具体的な活動・意味的側面、`series` は同じ具体的な活動・
+ 状態の系列が繰り返し起きた場合にのみ、`episode` は境界のある現実世界の
+ 1 回の出来事にのみ使う。共有された出来事では、正規の記憶を 1 つに保ったまま、
+ 明示された参加者ごとに 1 つずつ assignment を持ってよい。
+ 型は `topic -> facet -> series -> episode` の順に従う。階層は飛ばしてよいが、
+ 型を繰り返したり逆順にしたりしてはならない。
+
+この抽出器は現在の書き込みしか見ないため、`series` セグメントを出力しては
+ならない。ここでは Topic/Facet/Episode を出力する。Series は、後の Reconcile が
+保存済みの独立した複数の出来事を比較したうえで確立することがある。
+
+これは書き込み時の整理である。パスの深さから Series/Episode を推論したり、
+固有名詞や広いタグから階層をこしらえたり、無関係な文脈にたまたま一緒に現れた
+というだけで人物を割り当てたりしてはならない。根拠のある最も具体的な階層で止め、
+確信が持てない場合は空の値を使う。「いつ」「何回」「誰」、複数形、序数表現の
+ようなクエリの形を決して埋め込まない。
+"""
+
+EXTRACT_FEW_SHOT = """
+---
+
+# 例
+
+## 例 1 —— 境界:古い文脈は解決のためだけに使い、再抽出はしない
+
+直近 k 件のメッセージ:
+[{"role": "user", "content": "最近、街の中心部の保護施設で保護犬を見て回っているんだ。"},
+ {"role": "assistant", "content": "素敵ですね。気に入った子は見つかりましたか?"}]
+新しいメッセージ:
+[{"role": "user", "content": "うん、昨日迎えに行ったよ。Luna っていう 3 歳のボーダーコリーの女の子。"}]
+Memory Date: 2025-04-10
+
+出力:
+```json
+{
+ "memory": [
+ {"content": "ユーザーは 2025-04-09 に、街の中心部の保護施設から Luna という名前の 3 歳のボーダーコリーを迎えた。", "tags": ["pets", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+古いメッセージは「その子」が誰かを解決し、文脈(「街の中心部の保護施設」)を補うだけである。「ユーザーは犬を迎えることを検討している」のような古くなった記憶を出力してはならない —— 本当に新しい事実(迎え入れが完了したこと)だけを、「昨日」を Memory Date に基づいて解決したうえで抽出する。
+
+## 例 2 —— アシスタントの長い返答を凝縮する
+
+新しいメッセージ:
+[{"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 + intention + 凝縮した agent の計画
+
+新しいメッセージ:
+[{"role": "user", "content": "こんにちは、Kenji です。来月日本旅行を計画しているんですが、7 日間の旅程を組んでもらえますか?"},
+ {"role": "assistant", "content": "# 7 日間 日本の定番ゴールデンルート(東京 → 京都 → 奈良 → 大阪)\\n東京に到着し、新幹線で南下して京都へ、奈良へ日帰り、大阪(関西)から出国。\\n\\n## 1 日目:東京到着\\n- 羽田/成田に到着し、東京駅近くのホテルに荷物を預ける。\\n- 夕方:浅草の浅草寺、仲見世通りを散策し、たい焼きを味わう。\\n- 夜:渋谷スクランブル交差点 + 渋谷スカイの屋上で夕日。居酒屋で夕食(焼き鳥、日本酒)。\\n\\n## 2 日目:東京の市場と名所 —— [省略]\\n## 3 日目:新幹線で京都へ、伏見稲荷、祇園 —— [省略]\\n## 4 日目:京都の寺院(清水寺、金閣寺、銀閣寺) —— [省略]\\n## 5 日目:奈良日帰り(奈良公園の鹿、東大寺) —— [省略]\\n## 6 日目:大阪(大阪城、道頓堀の食べ歩き) —— [省略]\\n## 7 日目:大阪観光 + 関西空港から出国 —— [省略]\\n\\nヒント:到着前に 7 日間の JR パスを購入しておきましょう。何か調整しましょうか?"}]
+Memory Date: 2025-09-15
+
+出力:
+```json
+{
+ "memory": [
+ {"content": "アシスタントはユーザーのために、定番のゴールデンルートに沿った 7 日間の日本旅行の旅程を作成した:東京(浅草、渋谷)、新幹線で京都へ(伏見稲荷、清水寺、金閣寺、祇園)、奈良への日帰り(鹿の公園、東大寺)、その後大阪(大阪城、道頓堀)を巡り、関西空港から出国する。", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
+ ],
+ "intentions": [
+ {"content": "ユーザーは 2025 年 10 月に 7 日間の日本旅行をする予定である。", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
+ ],
+ "basic_info": {"name": "Kenji"}
+}
+```
+1 回のやり取りから、異なる区分に 3 つの出力が生まれる:名前は basic_info へ、旅行は締め切りのある先を見据えた intention へ、そしてアシスタントの長い複数セクションの旅程は 1 つの密度の高い agent 記憶に凝縮する —— ルートと都市ごとの主な立ち寄り先であり、毎日の箇条書き、ヒント、食べ物のリストではない。返答全体を逐語的に保存すると記憶が膨れ上がる。骨格だけを保存すれば検索可能なまま保てる。
+
+## 例 4 —— 以前の提案を後のメッセージで確認・採用したこと自体が事実である
+
+新しいメッセージ:
+[{"role": "user", "content": "6 歳の子が野菜をまったく食べないんです。何かいい方法はありますか?"},
+ {"role": "assistant", "content": "ほうれん草やにんじんをパスタソースに混ぜてみてください。色や味がほとんど分からなくなり、気づかずに食べる子が多いですよ。"},
+ {"role": "user", "content": "いいですね、今夜試してみます。ところで、その年齢だと何時に寝かせるのがいいですか?"},
+ {"role": "assistant", "content": "6 歳なら、午後 7〜9 時に寝かせて、睡眠時間を 10〜11 時間ほど確保するのが目安です。"}]
+Memory Date: 2025-06-20
+
+出力:
+```json
+{
+ "memory": [
+ {"content": "ユーザーには野菜を食べようとしない 6 歳の子どもがおり、ほうれん草やにんじんをパスタソースに混ぜて隠すというアシスタントの提案を受け入れた。", "tags": ["parenting", "food"], "owner": "user"},
+ {"content": "アシスタントはユーザーに、6 歳の子どもは午後 7〜9 時に就寝し、睡眠時間を 10〜11 時間ほど確保するのが目安だと助言した。", "tags": ["parenting", "sleep"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+3 番目のメッセージでユーザーは「今夜試してみます」と言っており、以前の提案を明示的に採用している。この受け入れには価値があり、雑談として捨てずに記録しなければならない(「…というアシスタントの提案を受け入れた」)。就寝時刻の助言は示されたばかりでまだ採用されていないため、助言として記録する(owner は "agent")。
+
+## 例 5 —— RAG/注入された文脈:注入されたテキストは決して保存しない
+
+新しいメッセージ:
+[{"role": "user", "content": "[Retrieved context: エッフェル塔の高さは 330m で、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 —— 共有された参考資料:共有した行為ではなく内容を抽出する
+
+新しいメッセージ:
+[{"role": "user", "content": "なくさないように、おばあちゃんの餃子のレシピを覚えておいて。餡:豚ひき肉 500g、白菜 300g、醤油 大さじ 2、ごま油 大さじ 1、しょうが 親指大をみじん切り。白菜は塩をふって 15 分置き、水気をしっかり絞る。餃子を茹で、差し水を 2 回して、浮いてきたら出来上がり。"},
+ {"role": "assistant", "content": "了解、保存しました!"}]
+Memory Date: 2025-07-01
+
+出力:
+```json
+{
+ "memory": [
+ {"content": "ユーザーの祖母の餃子のレシピ:餡は豚ひき肉 500g、白菜 300g(塩をふって 15 分置き、水気を絞る)、醤油 大さじ 2、ごま油 大さじ 1、親指大のしょうがのみじん切り。餃子を茹で、差し水を 2 回し、浮いてきたら出来上がり。", "tags": ["food", "recipe", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+実際の事実内容(材料、分量、塩をふって絞る工程、茹で方)を抽出する —— 「ユーザーがレシピを共有した」や「ユーザーがレシピを覚えるよう頼んだ」ではない。共有したという行為には価値がなく、検索の対象になるのは内容である。
+
+## 例 7 —— 構造化された数値と属性を正確に保持する
+
+新しいメッセージ:
+[{"role": "user", "content": "今サイクルのホームジムでの自己ベストを記録しておく:スクワット 140kg x 3、ベンチ 100kg x 5、デッドリフト 180kg x 2、オーバーヘッドプレス 60kg x 6。体重 78kg、各種目 3 セット、休憩 3 分。"},
+ {"role": "assistant", "content": "記録しました。すごい数字ですね!"}]
+Memory Date: 2026-01-20
+
+出力:
+```json
+{
+ "memory": [
+ {"content": "ユーザーの現在のウェイトトレーニングの自己ベストは、体重 78kg でスクワット 140kg x 3、ベンチ 100kg x 5、デッドリフト 180kg x 2、オーバーヘッドプレス 60kg x 6 である。", "tags": ["fitness", "strength"], "owner": "user"},
+ {"content": "ユーザーは各種目 3 セット、セット間の休憩 3 分でトレーニングしている。", "tags": ["fitness", "training"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+すべての数値と単位(kg、回数、セット数、休憩時間)を正確に保持する —— これらを落とすと、最も検索価値の高い情報が失われる。2 つの明確な話題(自己ベストとトレーニング方法)に分けるが、具体的な数値を丸めたり省いたりしてはならない。
+
+## 例 8 —— 複数の話題にまたがる長い会話:最初の話題で止めない
+
+新しいメッセージ:
+[{"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 年 12 月頃)ベルリンに引っ越す予定である。", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+4 つ以上の話題がある —— 博士論文の審査、ベルリンのアパート、ドイツ語の学習、マドリードにいるパートナー。最初の話題で止めてはならない。1 つの発言が、完了した事実(賃貸契約の署名)と intention(これからの引っ越し)に分かれている点に注意する。また、Sofia に関する感情的だが中身のある詳細は、人間関係の持続的な文脈を含むので残している。
+
+## 例 9 —— 2 人の実在の人物:assistant メッセージに `name` があれば実在の人物を意味する
+
+新しいメッセージ:
+[{"role": "user", "name": "Tim", "content": "ちょうどクライミングジムから帰ってきたところ。今週 3 回目。ついにあのオーバーハングのルートを完登したよ。"},
+ {"role": "assistant", "name": "John", "content": "いいね!僕は代わりに水泳をしてるよ。先月痛めた肩がまだ痛くてさ。"}]
+Memory Date: 2025-08-14
+
+出力:
+```json
+{
+ "memory": [
+ {"content": "ユーザーは週 3 回クライミングをしており、最近難しいオーバーハングのルートを完登した。", "tags": ["fitness", "climbing"], "owner": "user"},
+ {"content": "Johnは 2025 年 7 月頃に痛めた肩がまだ痛むため、ほかの運動の代わりに水泳をしている。", "tags": ["fitness", "health"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {"name": "Tim"}
+}
+```
+John は `role: "assistant"` を持つが `name` もあるので、AI ではなく別の実在の人物である:その記憶は「Johnは…」を主語とし、`owner: "user"` のままである(ユーザーの記憶ストアに属する)。ユーザー自身の記憶は、名前が Tim だと分かっていても「ユーザーは…」のままにする —— 決して「Timは週 3 回クライミングをしている」とは書かない。`basic_info.name` はユーザーメッセージの `name: "Tim"` から得たものであり、Tim が自分の名前を口にしていなくても信頼できる情報源である。
+
+## 例 10 —— 反例:他人の属性は決して basic_info に入れない
+
+新しいメッセージ:
+[{"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 の職業と所在地は**John の**属性なので、「John」を主語として `memory` に入れる。これらは決して `basic_info.occupation` / `basic_info.location` に入れてはならない —— `basic_info` はユーザー自身のプロフィール専用である。そこに入れてよいのは `name`(ユーザーメッセージの `name` フィールドから得た Tim)だけである。出力言語は入力言語に従う点に注意する(この例は英語)。
+
+## 例 11 —— 反例:雑談には basic_info がない
+
+新しいメッセージ:
+[{"role": "user", "content": "こんにちは"},
+ {"role": "assistant", "content": "こんにちは!ユーザーの名前はユーザーです。何をお手伝いしましょうか?"}]
+Memory Date: 2025-09-03
+
+出力:
+```json
+{
+ "memory": [],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+ユーザーは自分自身について何も述べていない。アシスタントの発言はユーザーのターンではなく、「ユーザー」はプレースホルダーであって名前ではない。`{}` を出力する —— 決して `{"name": "ユーザー"}` や `{"name": "user"}` を出力しない。
+
+---
+"""
+
+EXTRACT_PROMPT = """## 直近 k 件のメッセージ(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`(すべての memory と intention に必須)= `"user"` または `"agent"`
+ (上記「# OWNER」を参照。迷った場合は既定値の `"user"`)
+* `basic_info` = **ユーザー自身のプロフィールのみ**。新しいユーザーメッセージで
+ **明示的に述べられた**安定したプロフィール項目(例:名前、年齢、所在地、職業、勤務先)を
+ 含める。推論しない、でっち上げない。明示的に述べられた項目がなければ
+ `{{}}` を出力する。
+ * 厳格なルール:ユーザーが `user` ターンで述べた場合に**のみ**項目を埋める。
+ アシスタントだけが言ったこと(アシスタントが「The user's name is X」のような
+ 以前の記憶を引用した場合も含む)は数に入らない。該当するものがなければ
+ `"basic_info": {{}}` を出力する。
+ * 項目名そのものやプレースホルダーを値として**決して**書かない("user"、
+ "The user"、"用户"、"ユーザー"、"name"、"N/A"、"unknown"、"none"、"-")。その項目は省略する。
+ * 否定例:`[user]: Hi` / `[assistant]: How can
+ I help?` のような雑談や、`[user]: Reply with exactly: PONG` → `"basic_info": {{}}`。
+ * `name` の例外:ユーザー自身のメッセージに付いた `name` フィールド、または先頭の
+ 「The user's name is X」/「用户名叫X」/「ユーザーの名前はX」という行は、`name` の
+ 信頼できる情報源である —— ユーザーが口に出して言っていなくてもよい。
+ * 他の実在の人物の属性を**決して**ここに入れない。John(`name` を持つ assistant ロールの
+ メッセージ)が「ベルリンで看護師をしている」と言った場合、それは `memory`
+ (「Johnはベルリンで看護師をしている。」)であり、`basic_info.occupation` / `.location` ではない。
+* セクション間で情報を重複させない
+* タグは 1〜3 個の簡潔な小文字のキーワードにする
+* 何も抽出されない場合は空の配列 `[]` または `{{}}` を使う
+* 有効な JSON だけを返す
+
+今すぐ JSON を出力すること。"""
+
+EXTRACT_PROMPT_NO_INTENTION = """## 直近 k 件のメッセージ(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`(すべての memory に必須)= `"user"` または `"agent"`
+ (上記「# OWNER」を参照。迷った場合は既定値の `"user"`)
+* `basic_info` = **ユーザー自身のプロフィールのみ**。新しいユーザーメッセージで
+ **明示的に述べられた**安定したプロフィール項目(例:名前、年齢、所在地、職業、勤務先)を
+ 含める。推論しない、でっち上げない。明示的に述べられた項目がなければ
+ `{{}}` を出力する。
+ * 厳格なルール:ユーザーが `user` ターンで述べた場合に**のみ**項目を埋める。
+ アシスタントだけが言ったこと(アシスタントが「The user's name is X」のような
+ 以前の記憶を引用した場合も含む)は数に入らない。該当するものがなければ
+ `"basic_info": {{}}` を出力する。
+ * 項目名そのものやプレースホルダーを値として**決して**書かない("user"、
+ "The user"、"用户"、"ユーザー"、"name"、"N/A"、"unknown"、"none"、"-")。その項目は省略する。
+ * 否定例:`[user]: Hi` / `[assistant]: How can
+ I help?` のような雑談や、`[user]: Reply with exactly: PONG` → `"basic_info": {{}}`。
+ * `name` の例外:ユーザー自身のメッセージに付いた `name` フィールド、または先頭の
+ 「The user's name is X」/「用户名叫X」/「ユーザーの名前はX」という行は、`name` の
+ 信頼できる情報源である —— ユーザーが口に出して言っていなくてもよい。
+ * 他の実在の人物の属性を**決して**ここに入れない。John(`name` を持つ assistant ロールの
+ メッセージ)が「ベルリンで看護師をしている」と言った場合、それは `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 個、短く焦点を絞ったもの):
+
+["query1", "query2", "query3", ...]
+
+JSON 配列のみを出力し、他のテキストは出力しないこと。"""
+
+RECONCILE_PROMPT = """あなたは記憶管理システムである。
+
+あなたの仕事は、新しい記憶を既存の記憶ベースに統合し、その記憶ベースを次の状態に保つことである:
+
+* 情報の損失がない
+* 矛盾がない
+* コンパクトである
+* 非常に検索しやすい
+
+---
+
+# 操作
+
+## ADD
+
+情報がまったく新しい場合に使う。
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## UPDATE
+
+次の場合に使う:
+
+* 新しい記憶が既存の記憶と両立する
+* 両者が同じ話題を記述している
+* 統合することで完全性や検索性が向上する
+
+ルール:
+
+* 情報を失わずに統合する
+* 有用な情報はすべて保持する
+* 重複を作ら**ない**
+* 両者で値が食い違う場合は、`memory_at` が新しいほうの記憶の値を残す。
+ 古い記憶が新しい値を上書きすることは決して許さない
+
+### 同じ出来事か、別の出来事か
+
+**UPDATE** を使うのは、新しい記憶が、すでに記録されている現実世界の同じ出来事や
+長期的な事実に詳細を加える場合だけである。
+
+同じ人物が別の時期に同じ種類の活動・出来事を再び行った場合(別の旅行、試合、怪我、
+購入、健康上の不安など)は、その出来事を独立した **ADD** として残す。その出来事
+自身の日付と詳細を保持する。既存の記憶が同じ具体的な系列に属する別の出来事であることが
+明らかな場合は、`related: [{{"memory_id":"...","relation":"same_series"}}]` で
+リンクする。
+
+日付の異なる別々の出来事を、回数や時系列をまとめた 1 つの長い記憶に統合しないこと。
+時系列は、リンクされた 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": ["..."]
+}}
+```
+
+### 複数の既存記憶を 1 つのチェーンにまとめる
+
+2 つ以上の既存の記憶が同じ側面を追跡しており、新しい記憶がその側面における
+最新の変化である場合 —— その `memory_at` が、まとめるすべての記憶の `memory_at` より
+後である場合 —— それらを 1 つの変遷チェーンにまとめてよい。単一の `memory_id` の
+代わりに `memory_ids`(**古い → 新しい** の順に並べたリスト)を使う:
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_ids": ["<oldest_id>", "<newer_id>"],
+ "content": "<最新の状態のみ>",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+列挙された記憶は古い → 新しいの順にチェーンでつながれ、新しい記憶がチェーンの
+先頭になる。`content` はやはり最新の状態**のみ**を記述する —— 古い記憶のテキストを
+決してコピーしない。それらはチェーンの履歴として引き続き検索できる。
+
+---
+
+# ルール
+
+* 意味のある情報はすべて保持する。
+* 完全な重複はスキップする。
+* 関連する断片は統合を優先する。
+* 日付の異なる別々の出来事は別々の ADD のままにする。`same_series` は、主語が同じで
+ 具体的な活動・出来事の種類も同じ場合にのみ使う。
+* 各記憶は 1 つのまとまった話題に絞る。
+* 下記の「時間の順序」に従う。
+* **異なる主語をまたいで統合・置き換えを決して行わない。** 主語とは content が
+ 誰についてのものかである:「ユーザーは…」と「Johnは…」と「Maryは…」は別である。
+ 異なる人物についての記憶は、文がそれ以外まったく同じでも独立した事実である ——
+ 「ユーザーはコーヒーが好きだ」と「Johnはコーヒーが好きだ」は 2 つの別々の記憶であり、
+ 互いの UPDATE にも SUPERSEDE にも決してならない。
+* `owner`(`user`/`agent`):書き込む記憶からそのままコピーする。異なる owner をまたいで統合・置き換えを決して行わない —— 同じ話題でも、ユーザーの事実とアシスタントの事実は別物である。
+* SUPERSEDE は、1 つの記憶を対象にする(`memory_id`)か、同じ側面に関する複数の記憶を 1 つのチェーンにまとめる(`memory_ids`、古い→新しい)かのいずれかである。UPDATE はちょうど 1 つの記憶を対象にする。
+* 同じ既存の記憶を複数の op で扱ってはならない。
+* 出力言語は入力された記憶の言語に合わせる。
+
+---
+
+# 時間の順序
+
+新しい記憶にも既存の記憶にも `memory_at`(それが起きた時点)がある。記憶は
+起きた順に書き込まれるとは**限らない** —— 履歴が後からインポートされることもあり、
+古い履歴をまだ処理している途中で記憶が追加されることもある。したがって、新しい記憶が
+既存の記憶より**古い**こともありうる。
+
+* どちらの記憶が新しいかは `memory_at` **だけ**で判断する。「新しい記憶」とは「今
+ 書き込まれている」という意味であり、「より最近の」という意味ではない。
+* 古い記憶が新しい記憶を置き換えることは決してあってはならない:新しい記憶を
+ SUPERSEDE しない。古い値で新しい値を上書きする UPDATE もしない。
+* 新しい記憶が、矛盾する既存の記憶より古い場合は、既存の記憶を現在の状態として残す。
+ 新しい記憶は過去の状態として、その時期とともに過去形で ADD する(例:「2023 年、
+ ユーザーは上海に住んでいた」)。情報を何も加えない場合は何も出力しない。
+* `memory_at: null` は時期が不明であることを意味する。不明は新しいことを意味**しない**:
+ `memory_at` が既知の記憶を、`memory_at` が null の記憶で決して SUPERSEDE しない。
+* 時系列をでっち上げてはならない。
+
+---
+
+# 任意:`related`
+
+どの op にも、書き込む記憶が**既存の**記憶とどう関係するかを記録する `related` 配列を
+付けてよい。これは保存される内容を変えるものではなく、リンクを記録するだけである。
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."],
+ "related": [{{"memory_id": "<existing_id>", "relation": "causes"}}]
+}}
+```
+
+使用できる関係は次の 4 つだけである:
+
+* `causes` —— 2 つの記憶が因果関係にある
+ (例:「毎日ランニングを始めた」→「膝が痛み始めた」)
+* `elaborates` —— 既存の記憶に詳細を加える、またはその後の展開である
+* `contrasts` —— 両者は緊張関係にあるが、**どちらも**依然として真である(一方が他方を
+ 偽にするなら、それは `contrasts` リンクではなく SUPERSEDE である)
+* `same_series` —— 同じ主語による、同じ具体的な活動・出来事の種類の、日付の異なる
+ 別々の出来事(例:2 回の別々のスキー旅行)
+
+ルール:
+
+* 「Existing memories」に現れる記憶にのみリンクする —— ID を決してでっち上げない。
+* 関係が**明示的かつ具体的**な場合にのみリンクを出力する。2 つの記憶が同じ広い話題に
+ 関するものというだけでは関係ではない —— `related` は付けない。
+* `same_series` には、同じ主語と、具体的に繰り返された行動・出来事が必要である。
+ health、travel、sport、food、work のような広いタグを共有しているだけでは不十分である。
+* リンクするものがない場合は、このフィールド自体を省略する。リンクがゼロなのが通常である。
+* `related` を UPDATE / SUPERSEDE の代わりに決して使わない。
+
+---
+{few_shot_section}
+###################
+入力データ
+###################
+
+Current date: {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 は 1 つの具体的な活動・状態の系列が繰り返し起きた場合にのみ、
+Episode は境界のある現実世界の 1 回の出来事にのみ使う。これらの型を、深さ、
+共有された広いタグ、無関係な同時出現から決して推論しない。既存の記憶が
+意味的に同等な主体ごとのパスをすでに持っている場合は、同義の分岐を作らずに、
+そのノード名と型をそのまま再利用する。完全な再利用を要求するには、
+`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
+"through":"topic|facet|series|episode"}]` を出力する。参照する ID は
+Existing memories に現れていなければならない。`through` は、既存のパスの先頭部分を
+指定した構造型までコピーすることを意味する。明示的に書かれたそれより深い部分は
+新規のまま残る。主語、具体的な活動・状態の系列、または Episode の境界が異なる場合は
+再利用してはならない。これらのフィールドは記憶そのものを記述するものであり、
+「いつ」「何回」「誰」のような将来のクエリの形を記述するものでは決してない。
+
+Series は Reconcile 時に確立する関係である:新しい記憶と、少なくとも 1 つの独立した
+既存の記憶が、同じ具体的な活動・状態の系列における別々の出来事である場合にのみ
+確立する。現在の書き込みに含まれる複数の命題は、繰り返しの証明にはならない。
+"""
+
+RECONCILE_FEW_SHOT = """
+###################
+例
+###################
+
+## 例 1 —— 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"]}
+]
+```
+1 つの新しい記憶が 2 つのことを含んでいる:転職(すでに履歴を持つ既存の雇用チェーン m1 と同じ側面 → SUPERSEDE し、新しいチェーンの先頭になる)と、無関係な詳細(陶芸 → ADD)である。1 つの記憶を部分ごとに適切な op に分ける —— 新しい先頭は雇用の状態**のみ**を記述し、陶芸のことは決して含めない。
+
+## 例 2 —— リンクされていない 2 つの既存記憶 + 新しい変化を 1 つの 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": "ユーザーは今では地元のオープンマイクの夜にギターを演奏している。", "owner": "user"}
+]
+
+出力:
+```json
+[
+ {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "ユーザーは地元のオープンマイクの夜にギターを演奏している。", "supersede_reason": "ギターの腕前が進歩した:習い始め → 曲を弾ける → ライブで演奏", "owner": "user", "tags": ["music", "hobby"]}
+]
+```
+a1 と a2 はリンクされたことがないが、同じ側面(ギターの上達)を追跡しており、新しい記憶はその最新の段階である。`memory_ids` を古い→新しいの順に並べてまとめると、3 ノードのチェーン(a1 ← a2 ← 新しい先頭)になる。先頭の `content` は現在の状態**のみ**を記述する —— 「習っている」や「何曲か」を繰り返さない。
+
+## 例 3 —— 新しい先頭は古い記憶の内容をコピーしてはならない
+
+Existing memories:
+[
+ {"memory_id": "c1", "content": "ユーザーは東京・渋谷の賃貸の 1 ベッドルームのアパートに住み、家賃は月 ¥180,000、駅まで徒歩 5 分なのを気に入っているが、夜はうるさく駐車場がないことに不満を持っている。", "owner": "user"}
+]
+New memories:
+[
+ {"content": "ユーザーは横浜郊外に庭と車 2 台分のガレージ付きの 3 ベッドルームの一戸建てを購入し、引っ越したばかりである。", "owner": "user"}
+]
+
+出力:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "c1", "content": "ユーザーは横浜郊外に庭と車 2 台分のガレージ付きの 3 ベッドルームの一戸建てを購入し、そこに引っ越した。", "supersede_reason": "住まいが渋谷の賃貸アパートから横浜の持ち家に変わった", "owner": "user", "tags": ["housing"]}
+]
+```
+新しい記憶は c1 を SUPERSEDE し、チェーンの先頭になる。先頭の `content` は新しい横浜の家**のみ**を記述する。古いアパート特有の詳細(渋谷、家賃 ¥180,000、駅までの徒歩、騒音・駐車場への不満)を新しいノードに持ち込んではならない —— それらは明らかに新居ではなく旧居に属するものである。それらはチェーンの履歴に残り、引き続き検索できる。コピーすると先頭が自己矛盾を起こす(渋谷で賃貸に住みつつ、同時に横浜に家を所有している)。
+
+## 例 4 —— 主語が異なれば、言い回しがどれほど似ていても決して統合しない
+
+Existing memories:
+[
+ {"memory_id": "d1", "content": "ユーザーは毎朝ブラックコーヒーを飲む。", "owner": "user"}
+]
+New memories:
+[
+ {"content": "Johnは毎朝ブラックコーヒーを飲む。", "owner": "user"},
+ {"content": "ユーザーは今では朝と昼食後の 1 日 2 回ブラックコーヒーを飲む。", "owner": "user"}
+]
+
+出力:
+```json
+[
+ {"op": "ADD", "content": "Johnは毎朝ブラックコーヒーを飲む。", "owner": "user", "tags": ["food"]},
+ {"op": "UPDATE", "memory_id": "d1", "content": "ユーザーは朝と昼食後の 1 日 2 回ブラックコーヒーを飲む。", "owner": "user", "tags": ["food"]}
+]
+```
+2 つの新しい記憶は言い回しがほぼ同じだが、主語が**異なる**。「Johnは…」は別の人物についてのものなので、単純な ADD である —— d1 がユーザーについてほぼ同じことを述べていても、d1 の UPDATE や SUPERSEDE には決してならない。d1 と統合してよいのは、主語が同じく「ユーザー」である記憶だけである。
+
+## 例 5 —— 繰り返される出来事:回数を更新し時系列を残す(ADD ではなく UPDATE)
+
+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は足首を 2 回痛めている:1 回目は昨シーズン(2022–2023 シーズン頃)で、休養と理学療法が必要だった。2 回目は 2023-10-13 頃の試合中である。", "owner": "user", "tags": ["health", "basketball", "injury"]}
+]
+```
+同じ種類の出来事が再び起きた → 古い記憶を UPDATE する。**回数**を明記し、分かっている場合は時期とともに各出来事を列挙する。2 つ目の「Johnが足首を痛めた」という事実を ADD してはならないし、SUPERSEDE もしてはならない(1 回目の怪我が真でなくなったわけではない)。
+"""
+
+
+# ================================================================
+# Working / coding memory (coding/)
+# ================================================================
+
+CODING_EXTRACT_PROMPT = """\
+あなたは、タスク実行セッションの 1 区間(セグメント)から、長期的に残す WORKING 記憶を抽出する。
+「working」セッションとは、ユーザーがツールを通じてコンピュータ/システムを操作する
+あらゆる実作業のタスクである —— ソフトウェア/コードの作業(作成、デバッグ、
+リファクタリング、ビルド、デプロイ、API/ライブラリの利用)と、システム・運用の
+作業(shell/PowerShell コマンドの実行、ディスク/ストレージの分析や整理、ファイル
+やフォルダの操作、ソフトウェアのインストール/設定、環境/デバイスのセットアップ、
+ハードウェア/ディスクの健全性チェック、バックアップ、スケジューリング/自動化、データ処理)の両方を含む。
+
+同じセグメントから 2 つの層を生成する:
+
+ EXPERIENCES(手続き的、「どうやるか」)—— 再利用できる方法。下記の
+ VALUE BAR を満たす場合にのみ抽出する。(task, search_keys, solution,
+ boundary_envs) の組。
+
+ FACT(エピソード的、「今回何が起きたか」)—— この セッションの記録を
+ ちょうど 1 件:ユーザーが何を望み、どのように進め、どういう結果になったか。
+ VALUE BAR はないが、1 件を超えることは決してない。
+
+2 つの層は異なる問いに答え、別々に保存される。一般化できる方法は
+EXPERIENCES に入れる。この特定のセッションの経緯 —— このシステム/この
+プロジェクト/今この時点でのみ真であること —— は FACT に入れる。
+
+═══════════════════════════════════════════════════════════════════
+VALUE BAR(EXPERIENCES のみ)—— 安易に越えてはならない。
+═══════════════════════════════════════════════════════════════════
+記憶は次のすべてを満たさなければならない:
+ (a) 同じユーザーにとって再発しそうな問題を解決する
+ (b) 解決策が自明ではない:複数の情報/手順を組み合わせている、または
+ 判断の根拠を含んでいる、または苦労して得た回避策を捉えている、または
+ 運用タスクの再利用可能な手順/レシピである(例:ディスク使用量を分析して
+ 整理する方法、ファイルを一括で整理する方法、ハードウェアの健全性を
+ チェックする方法、定期ジョブを設定する方法)
+ (c) 将来の agent/ユーザーが、再発見するよりも調べることを好む
+
+重要 —— 分析/診断/調査のタスクも対象になる:
+覚えておく価値があるために、タスクが何かを変更したり「修正」したりする必要はない。
+読み取り専用/分析的/トラブルシューティングの作業も、その手順または
+結論が再利用できるなら価値がある。次のものは明示的に抽出する:
+ - 分析/診断のレシピ:再利用できる手順 + それによって判明したこと
+ (例:「C ドライブの容量を食っているフォルダを分析する方法」—— スキャンコマンド、
+ 遭遇した落とし穴、そして結果)。「レポートを出しただけで何も変更していない」
+ はスキップする理由に**ならない** —— 再利用できる方法こそが記憶である。
+ - 調査の結果。否定的な結果/見つからなかった結果も**含む**
+ (例:「フォルダ X を C: と D: 全体で rg / fs_search / SQL インデックスを使って探した ——
+ どこにも見つからなかった」)。記録された行き止まりは、次の agent が同じ
+ 無駄な検索を繰り返すのを防ぐので、VALUE BAR を満たす。
+「アシスタントならコマンドを再生成できる」や「実際には何も変更されていない」と
+いうだけの理由で記憶を却下しては**ならない**。手順や結論が将来の手間を省くなら
+残すこと。
+
+抽出してはならないもの:
+ - 再利用できる手順のない、本当に些細な 1 ステップの操作(「ファイルを 1 つリネーム」、
+ 「git status」、「ls を 1 回実行」)
+ - すでに解決済みで、他に応用できる教訓のない一回限りの問題
+ - リポジトリ/システムにすでにある情報(package.json の内容を重複させない)
+ - PR ごと/セッションごとの使い捨てのタスク(再利用可能なパターンを含む場合を除く)
+ - 不足している情報をユーザーに尋ねるという行為そのもの。パラメータを求める、
+ 不明点を列挙する、必須項目を聞き出すといったことは会話上の振る舞いであって
+ 方法ではない:どの agent も質問の仕方はすでに知っているので、後で調べるべき
+ ことは何もない。task や search_keys が「X の尋ね方」「不足している Y を
+ 集める」「必須項目を聞き出す」「開始前に何を確認するか」のような形の
+ experience は決して出力しない。ただしこれは EXPERIENCES から除外されるだけで
+ ある点に注意 —— セッションがユーザーの返答待ちで終わったことは実際の状態であり、
+ FACT に入れるべきものである。
+
+セグメントがユーザー待ちで止まり、実質的な進展がなかった場合 —— アシスタントが
+パラメータを尋ねただけだった、または実際の作業を始める前にブロックされた場合 ——
+"experiences": [] を出力し、FACT だけを書く。まだ何も学ばれていないので、保存すべき
+方法はない。これは見た目以上に重要である:停滞から抽出された experience は、検索時に
+正当なスキルのように読めてしまい、同じタスクの後続セグメントがそれにマッチして、
+先に進む代わりに再びユーザーに尋ねることになる。こうして停滞がセッションの残り全体で
+再生産されてしまう。実質があったかどうかは、そのターンが流暢なテキストを生成したか
+ではなく、ツールが実際に何をしたかで判断する。
+
+目安:ユーザー(または同種のタスクを行う将来の agent)が、もう一度考え出すより
+書き留めておいてほしいと思うなら残す。複数ステップの運用手順(コードに限らず、
+システム/運用や読み取り専用の分析/検索の手順も)は通常これに該当する。
+除外するのは、どのユーザーでも `--help` で 30 秒以内に見つけられる単一のコマンドで、
+**かつ**覚えておく価値のある判断や落とし穴を何も含まない場合だけである。
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE のフィールド
+═══════════════════════════════════════════════════════════════════
+
+task — クエリの形をした名前。ユーザーが後で**尋ねる**ときの言い方で書く。
+ 「xx プラットフォームにリリースを公開する」であって
+ 「publish_release_internal」ではない。
+ 自己完結させる(「これ」「そのファイル」「私たち」を使わない)。
+
+search_keys — `task` だけではマッチしない solution の重要な側面を捉えた、
+ 0〜5 個の別の言い回し。将来のユーザーが**尋ねそうな**質問や
+ 話題の形で書く。task とは異なるものにする。
+ task ですべてカバーできているなら省略する。
+
+solution — ユーザーが実際に必要とする、完全で自己完結した内容:
+ コマンド、認証情報の保存場所(認証情報の値ではない)、
+ ファイルパス、順序立てた手順、落とし穴、判断の根拠。
+ 複数ターンにわたる一連の作業が 1 つのまとまったタスクを成すなら
+ 1 つの solution にまとめる。複数の記憶に分けるのは、ユーザーが
+ 無関係なタスクを行った場合だけである。
+
+boundary_envs — solution が依存する具体的な固定条件。複数行の「key: value」形式:
+ ランタイム/SDK/ライブラリ + バージョン
+ API エンドポイントまたはメソッドシグネチャ
+ 外部サービス/ミドルウェアのバージョン
+ 環境変数の名前(値ではない)
+ 設定ファイルのパス
+ ホスト/クラスタ/リージョンの識別子
+ solution が環境に依存しない場合は ""(空)のままにする。
+ 目的:基盤となる SDK/ミドルウェアがアップグレードされたとき、将来の
+ 利用者がこれを見て solution がまだ有効かどうかを判断できるようにする。
+
+confidence — 0.0〜1.0
+ 1.0 ユーザーがルール/指示として明示的に述べた
+ 0.7 ツールの操作から十分な根拠をもって推論した
+ 0.5 弱い推論。観察は 1 回のみ。不確か
+
+═══════════════════════════════════════════════════════════════════
+FACT のフィールド —— セグメントごとにちょうど 1 件、VALUE BAR なし
+═══════════════════════════════════════════════════════════════════
+
+セグメント全体について FACT を 1 件書く —— このセッションの状態を復元できる記録で
+あり、磨き上げた振り返りではなく、個別の発見のリストでも決してない。将来の
+agent が、提案・推論・部分的な検索を検証済みの事柄と取り違えることなく、
+この記録から作業を再開できなければならない。
+
+subject — このセッションが**誰**または**何**についてのものか:作業の対象または
+ 受益者である単一のエンティティ。短い名詞句 1 つで、文や動詞は使わない。
+ 使ったツールではなく、セッションが*対象としている*最も具体的な
+ エンティティを選ぶ:
+ セッションが名前のある 1 人の人物のためのものならその人の名前
+ ("Dylan"、"Matthew")
+ 作業がコードを対象とするならファイル/モジュール/シンボル
+ ("auth/middleware.ts"、"parse_plan_text")
+ 運用作業ならサービス/ホスト/デバイス/ドライブ
+ ("D:\\WXWork"、"redis-cache-prod"、"ci.yml")
+ これは文章ではなく**厳密なキー**である:異なる人物や異なるファイルに
+ 関する 2 つのセッションは必ず異なる subject を持ち、同じ対象に関する
+ 2 つのセッションは必ず同じ文字列を、まったく同じ綴りで持たなければならない。
+ 対象を説明する言葉よりも、トレースに現れる正確な識別子を優先する。
+ セグメントに本当に単一の subject がない場合は "" を出力する。
+
+ なぜ重要か:subject は、後のセッションがこのセッションを「同じタスクの
+ 続き」として上書きしてよいかどうかを決める関門である。これを誤ると、
+ ある人の状態が別の人の状態を黙って置き換えてしまう。
+
+statement — この セッションのコンパクトな記録。2 つの部分からなり、失われやすいのは
+ 2 つ目のほうである。
+ タスク固有の前提と具体的な制約を、結果に対する一般的な評価で
+ 置き換えずに保持する。各ルールは 1 回だけ述べる:指示文を繰り返すと、
+ 記憶が保持すべきデータと競合する。
+
+ PART 1 —— 何が起きたか。ラテン文字で約 300 字(CJK で約 150 字)。
+ 具体的な目的と対象から始める(「D:\\WXWork が占めるディスク容量を
+ 取り戻す」「new_file_search フォルダの場所を特定する」)。一般的な
+ 「バグを直す」「ファイルを探す」ではない。次に、何を調べ、試し、
+ 変更したかの概略。そして、どう終わったかを、次のいずれか 1 つの意味で書く:
+ 完了、一部完了、失敗、ブロック、または
+ 検証待ち。否定的な結果や行き止まりも、誇張せずに含める。
+
+ PART 2 —— タスク固有の前提:このセグメントが確立したものでなくても、
+ 基本的すぎて書くまでもないと感じられても、タスク**全体**が依拠している
+ ものすべて。束縛(各名前/記号/ラベルが何を指すか)、タスクが導出する
+ のではなく与えている固定値、採用された規約(インデックスの起点、単位、
+ タイムゾーン、既定値)、そしてこのセグメント自身の結果とその値
+ (「値を計算した」ではなく「x = 7」)。
+
+ PART 2 はデータとして、1 行に 1 項目、値は与えられたとおりに書く:
+ 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
+ 1 行はほぼ全体が値であるべきだ。トレースの表記 —— 記号、単位、数値、
+ 綴り —— を保ち、その文章は落とす:前提そのものではなく前提を告げている
+ だけの言い回し(「…のほうがいいと思う」「…から…の間くらいのはず」)は
+ 取り除く。それらは項目ごとに繰り返されるので、15 項目のリストなら 15 回分の
+ コストがかかる。
+ これらはすべての FACT に毎回含める。「上記と同じ」や「前のセッションと
+ 同じ」とは決して書かない —— 検索は類似度で少数の FACT を返すだけで、
+ 参照先がその中に含まれるとは限らない。
+
+ 全体で 1200 字未満を目指す。PART 2 が収まらない場合は、網羅性ではなく
+ 表記を直す:statement は検索ベクトルであり、かつ後のセグメントが読める
+ 唯一のフィールドでもある(details は埋め込まれず、注入もされない)ので、
+ ここから削ったものは失われる。前提の周りの言葉を圧縮し、前提そのものは
+ 決して圧縮しない。
+
+ テスト:次のセグメントが元の資料を見られないとしたら、この記録だけで
+ 作業を続けられるか? 「はい」だけが合格である。束縛が欠けていても
+ 大きな失敗としては表に出ない —— 名前は依然として意味ありげに見えるので、
+ 一般的な意味で読まれてしまい、その結果の答えは流暢だが別の問いに
+ 対するものになる。
+
+ 言語 —— セッションのトレースと同じ言語で書く:statement は検索ベクトルであり、
+ クエリはユーザーの作業言語で届くので、別の言語で書くと検索のたびに
+ 言語間のペナルティを払うことになる。
+
+ 証拠への忠実さ —— 実際に実行された操作と、トレースに明示的に現れている
+ 証拠だけを記録する。重要なコマンド、フラグ、引数、エラー、数値は
+ そのまま逐語的に保持する。
+ 慣例的なフラグでコマンドを補完することは**決して**せず、助言や計画を
+ 行動に変えることも決してしない:
+ 「Get-ChildItem -Force を実行した」→「Get-ChildItem を実行した」
+ (トレースには `-Force` が含まれていなかった。でっち上げないこと)
+ 否定的な発見はすべて、実際に検索した範囲に限定して書き、それを覆しうる
+ 明示的なカバー範囲の制限を**すべて**列挙する。特に権限エラーと深さの
+ 制限:有効だったルート、フィルタ、深さを残し(「C:\\ と D:\\ の深さ 3 までで
+ 見つからなかった。Access denied のため一部のディレクトリはカバーされて
+ いない」)、決して「存在しない」に広げない。記録を見栄えよくするために
+ 制限を 1 つでも省いてはならない。
+ 部分的な検索を全体的な不在に格上げしてはならない。
+ ブロックされた試みには、そのブロック要因を残す。
+ 試みた、観察した、検証した、推論した、未解決、の区別を保つ ——
+ ラベルとしてではなく自然な表現で(「…を試したが Access denied で
+ ブロックされた」「…が疑われるが、まだ検証していない」)。ツールの出力や
+ 明示的な確認がない限り、修正が成功した、原因が確定した、パスが存在しない
+ と**決して**主張しない。
+
+ 挨拶や純粋な雑談は記録しない —— "fact": null になるのはその場合だけ
+ である。要件を述べただけのセグメントや、作業前に停滞したセグメントも、
+ 何かを確立している。
+
+details — セッションの具体的な出力を、逐語的にコピーしたもの。`statement` は
+ 要約であり、要約は必然的に個々の値を落とす。後の検索がほぼ常に求めるのは
+ 要点ではなく、特定の 1 つの値である。
+ そこで、このセッションが生み出した参照可能な結果は何であれ、元の形と
+ 構造のままここに再現する:
+ 計画/スケジュール/旅程 → すべての行、すべての日、すべての
+ 枠、すべての価格を書かれたとおりに残す
+ 設定やコードのブロック → ブロックを残す
+ コマンドの重要な出力 → 発見を含む行を残す
+ (サイズ、件数、バージョン、エラーテキスト)
+ 構造化された結果(表、レコードのリスト)→ 行を残す
+ 元のレイアウトを保つ —— 改行、`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": "..."
+ }}
+}}
+
+既定では抽出する。セグメントが実際の作業を行った場合は、少なくとも 1 つの
+experience を**必ず**出力しなければならない —— タスクが単純に見えても、1 回で
+成功したものであっても、行ったことの再利用できる本質(方法/コマンド/やり方)を
+捉える。セッションの内容が薄い場合は、最も価値のある experience 1 つで十分である。
+
+唯一の例外は上記の停滞のケースである:セグメントが不足している情報をユーザーに
+尋ねてブロックされ、実際の作業を何もしなかった場合は、"experiences": [] を出力し、
+FACT だけを書く。この指示を満たすために experience をこしらえてはならない ——
+でっち上げた experience(「出発都市の尋ね方」)は、後で検索されて従われてしまうので、
+ないほうがましである。空にしてよいのはその理由の場合**だけ**であり、実際に作業が
+行われたのに手を抜くために空にすることは決してない。
+
+"fact" は単一のオブジェクトであり、決してリストではない —— セッションごとに 1 件の記録。
+
+FACT は**常に**書く。FACT の基準は「価値があったか」ではなく「何かが起きたか」であり、
+あなたに届いたセグメントはすでにその基準を満たしている。
+これには、作業というより準備に見えるセグメントも含まれる:ツールを
+一切実行せず、要件、パラメータ、または開始時の状態を述べただけの 1 件の
+ユーザーメッセージは、まさに後のセッションが自力では再構成できない材料である
+—— 要件、パラメータ、開始時の状態を状況とともに `statement` に書き込み(簡潔な表記で、会話の文をそのまま写さない)、
+`details` に押し付けないこと(`details` は検索ベクトルに入らず、読み出し側でも注入されない)。
+"fact": null を使うのは、内容がまったくない挨拶や純粋な雑談の場合**だけ**である。
+迷ったら FACT を書く:不要な記録のコストは 1 行だけだが、落とした記録は、それを
+必要としながらその存在を知るすべのない後のすべてのセッションにコストを負わせる。
+"""
+
+CODING_EXTRACT_PROMPT_CODING = """\
+╔═══════════════════════════════════════════════════════════════════════════╗
+║ HARD CONSTRAINT —— 何よりも先にこれを読むこと。このプロンプトの後半に ║
+║ 物語風の記述を求めているように見える表現があっても、これが優先される。 ║
+║ ║
+║ あなたが書くのは、ある人物が何をしたかの報告ではない。FUTURE AGENT が ║
+║ 行動するために必要なことを書くのである。その agent にはすでに自分の ║
+║ タスクがあり、このユーザーが何を望んだかには関心がない。知る必要がある ║
+║ のは:ここで何が決まったか、どのコード座標でか、何を試して却下したか、 ║
+║ そして検証されたかどうかである。 ║
+║ ║
+║ 具体的には、すべての `statement` とすべての `solution` において: ║
+║ · 文法上の主語は CODE または THE DECISION とする —— 決して「ユーザー」 ║
+║ でも「agent」でもない。「ユーザーは…しようとした」、 ║
+║ 「ユーザーは…を望んだ」、「agent は次に…を確認した」と書かない。 ║
+║ · 「セッションは完了した」「エラーを記録した」「まだ解決策は見つかって ║
+║ いない」のような帳簿的な言い回しで締めくくらない。決定とその検証状態 ║
+║ で締めくくる。何も決まらなかった場合は、除外されたことと、次に探る ║
+║ べき未探索の手がかりで締めくくる —— それが再利用できる部分である。 ║
+║ · 具体的な症状(エラー文字列、失敗したコマンド、誤った出力)を残す —— ║
+║ 将来の検索がマッチするのはそこである。 ║
+║ ║
+║ bad: 「ユーザーは header_rows を指定して QTable を RST に書き出そうとし、 ║
+║ TypeError が出た。セッションはエラーを記録して完了した。」 ║
+║ good: 「ascii.rst の RST writer は header_rows を受け付けない: ║
+║ `tbl.write(..., format='ascii.rst', header_rows=['name','unit'])` ║
+║ は RST.__init__ がそれを転送しないため TypeError になる。 ║
+║ 受け付ける ascii.fixed_width とは異なる。修正は未実装 —— writer に ║
+║ fixed_width と同じ header_rows の受け渡しが必要である。」 ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+
+あなたは、タスク実行セッションの 1 区間(セグメント)から、長期的に残す WORKING 記憶を抽出する。
+「working」セッションとは、ユーザーがツールを通じてコンピュータ/システムを操作する
+あらゆる実作業のタスクである —— ソフトウェア/コードの作業(作成、デバッグ、
+リファクタリング、ビルド、デプロイ、API/ライブラリの利用)と、システム・運用の
+作業(shell/PowerShell コマンドの実行、ディスク/ストレージの分析や整理、ファイル
+やフォルダの操作、ソフトウェアのインストール/設定、環境/デバイスのセットアップ、
+ハードウェア/ディスクの健全性チェック、バックアップ、スケジューリング/自動化、データ処理)の両方を含む。
+
+同じセグメントから 2 つの層を生成する:
+
+ EXPERIENCES(手続き的、「どうやるか」)—— 再利用できる方法。下記の
+ VALUE BAR を満たす場合にのみ抽出する。(task, search_keys, solution,
+ boundary_envs) の組。
+
+ FACT(エピソード的、「今回何が確定したか」)—— この セッションの記録を
+ ちょうど 1 件。ユーザーが何をしたかの物語ではない。次の順に記録する:
+ タスクとその具体的な症状(これが後で見つけられるようにするもの)、
+ コード座標、何に落ち着き何が却下されたか、そしてどこまで検証されたか。
+ VALUE BAR はないが、1 件を超えることは決してない。
+
+2 つの層は異なる問いに答え、別々に保存される。一般化できる方法は
+EXPERIENCES に入れる。この特定のセッションの経緯 —— このシステム/この
+プロジェクト/今この時点でのみ真であること —— は FACT に入れる。
+
+═══════════════════════════════════════════════════════════════════
+VALUE BAR(EXPERIENCES のみ)—— 安易に越えてはならない。
+═══════════════════════════════════════════════════════════════════
+記憶は次のすべてを満たさなければならない:
+ (a) 同じユーザーにとって再発しそうな問題を解決する
+ (b) 解決策が自明ではない:複数の情報/手順を組み合わせている、または
+ 判断の根拠を含んでいる、または苦労して得た回避策を捉えている、または
+ 運用タスクの再利用可能な手順/レシピである(例:ディスク使用量を分析して
+ 整理する方法、ファイルを一括で整理する方法、ハードウェアの健全性を
+ チェックする方法、定期ジョブを設定する方法)
+ (c) 将来の agent/ユーザーが、再発見するよりも調べることを好む
+
+重要 —— 分析/診断/調査のタスクも対象になる:
+覚えておく価値があるために、タスクが何かを変更したり「修正」したりする必要はない。
+読み取り専用/分析的/トラブルシューティングの作業も、その手順または
+結論が再利用できるなら価値がある。次のものは明示的に抽出する:
+ - 分析/診断のレシピ:再利用できる手順 + それによって判明したこと
+ (例:「C ドライブの容量を食っているフォルダを分析する方法」—— スキャンコマンド、
+ 遭遇した落とし穴、そして結果)。「レポートを出しただけで何も変更していない」
+ はスキップする理由に**ならない** —— 再利用できる方法こそが記憶である。
+ - 調査の結果。否定的な結果/見つからなかった結果も**含む**
+ (例:「フォルダ X を C: と D: 全体で rg / fs_search / SQL インデックスを使って探した ——
+ どこにも見つからなかった」)。記録された行き止まりは、次の agent が同じ
+ 無駄な検索を繰り返すのを防ぐので、VALUE BAR を満たす。
+「アシスタントならコマンドを再生成できる」や「実際には何も変更されていない」と
+いうだけの理由で記憶を却下しては**ならない**。手順や結論が将来の手間を省くなら
+残すこと。
+
+抽出してはならないもの:
+ - 再利用できる手順のない、本当に些細な 1 ステップの操作(「ファイルを 1 つリネーム」、
+ 「git status」、「ls を 1 回実行」)
+ - すでに解決済みで、他に応用できる教訓のない一回限りの問題
+ - リポジトリ/システムにすでにある情報(package.json の内容を重複させない)
+ - PR ごと/セッションごとの使い捨てのタスク(再利用可能なパターンを含む場合を除く)
+
+目安:ユーザー(または同種のタスクを行う将来の agent)が、もう一度考え出すより
+書き留めておいてほしいと思うなら残す。複数ステップの運用手順(コードに限らず、
+システム/運用や読み取り専用の分析/検索の手順も)は通常これに該当する。
+除外するのは、どのユーザーでも `--help` で 30 秒以内に見つけられる単一のコマンドで、
+**かつ**覚えておく価値のある判断や落とし穴を何も含まない場合だけである。
+
+═══════════════════════════════════════════════════════════════════
+コード作業 —— 将来の agent が再導出できないので、必ず記録すべきもの
+═══════════════════════════════════════════════════════════════════
+セグメントがリポジトリ上のソフトウェア作業である場合、再利用できる方法は半分に
+すぎない。残りの半分は、作業が**どこに**あり、**どのバージョン**が採用されたかである。
+これらは後でコードを読んでも復元できない —— コードが示すのは現在の状態であって、
+それがどのブランチにあるかも、すでに何が却下されたかも示さない。
+
+このセクションは、より長い記録を求めているのでは**ない**。**同じ分量**を、より
+価値の高いトークンに使うよう求めている:目的の言い直し、アシスタントが「次に…
+することにした」という語り、ただ繰り返しているだけの貼り付けたコードを削り、その
+文字数を下記の 4 項目に使う。ブランチを省いて diff を 30 行引用した記録は割に合わない。
+
+1. ブランチ/作業場所 —— FACT の `statement` に逐語的に書く。セグメントが
+ `feat/x` / `fix/y` に言及したりチェックアウトしたりしているなら、そのトークンは
+ 必ず現れなければならない。間違ったブランチで作業を再開した agent の変更は
+ 黙って捨てられてしまうので、この 1 トークンは他のどの詳細よりも重要である。
+
+2. どのバージョンが採用されたか —— ユーザーが考えを変えた場合は、採用されたものを
+ 名指しし、却下されたものを 1 節で示す:「A に落ち着いた。暫定の B は破棄した」。
+ 両方を詳しく書くのではなく、1 節で。最新のものだけを残すのは誤りである:却下された
+ コードに出くわした agent はそれと見抜けなければならない。さもないと、破棄された
+ 版に「修正」して戻してしまう。`scratch that / go back to / actually, let's / no, not that`
+ (「やっぱりやめて/元に戻して/じゃあこうしよう/いや、それじゃない」)のような表現が
+ その目印である:その後に続くものが正式なもので、その前のものは置き換えられている。
+
+3. 貼り付けたコードではなく正確な座標 —— リポジトリ相対パス
+ (`qutebrowser/utils/debug.py`。単なる `debug.py` は不可)と、触った関数/
+ クラス。シグネチャが変わったなら新しいシグネチャを示す。定数、正規表現、
+ リテラルが決まったなら、**それ**を逐語的に引用する —— ただし引用するのはそれだけで、
+ 周囲のブロックは引用しない。正確な 1 行は、近似の段落 1 つに勝る。
+
+4. 検証済みか、書いただけか —— 短い一言で足りる(「テスト実行済みで合格」/
+ 「git diff で確認したのみ、テスト未実行」)。「編集は入っている」と「編集は入っていて
+ テスト済み」とでは、将来の agent が次にすることがまったく異なる。
+
+アンチパターン —— 目的を要約して座標を落とす:
+ bad: 「色のパース処理をよりきれいにリファクタリングした。」
+ good: 「feat/q4 にて、qutebrowser/config/configtypes.py の QtColor._parse_value で
+ `mult = 360.0 if kind == 'h' else 255.0` に落ち着いた。すべてに 255.0 を使っていた
+ 暫定版は破棄した。テスト未実行。」
+ (good のほうがたいていの bad より**短い** —— ただ、すべての文字を再導出できない
+ ものに使っているだけである)
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE のフィールド
+═══════════════════════════════════════════════════════════════════
+
+task — クエリの形をした名前。ユーザーが後で**尋ねる**ときの言い方で書く。
+ 「xx プラットフォームにリリースを公開する」であって「publish_release_internal」ではない。
+ 自己完結させる(「これ」「そのファイル」「私たち」を使わない)。
+
+search_keys — `task` だけではマッチしない solution の重要な側面を捉えた、
+ 0〜5 個の別の言い回し。将来のユーザーが**尋ねそうな**質問や
+ 話題の形で書く。task とは異なるものにする。
+ task ですべてカバーできているなら省略する。
+
+solution — ユーザーが実際に必要とする、完全で自己完結した内容:
+ コマンド、認証情報の保存場所(認証情報の値ではない)、
+ ファイルパス、順序立てた手順、落とし穴、判断の根拠。
+ 複数ターンにわたる一連の作業が 1 つのまとまったタスクを成すなら
+ 1 つの solution にまとめる。複数の記憶に分けるのは、ユーザーが
+ 無関係なタスクを行った場合だけである。
+
+boundary_envs — solution が依存する具体的な固定条件。複数行の「key: value」形式:
+ ランタイム/SDK/ライブラリ + バージョン
+ API エンドポイントまたはメソッドシグネチャ
+ 外部サービス/ミドルウェアのバージョン
+ 環境変数の名前(値ではない)
+ 設定ファイルのパス
+ ホスト/クラスタ/リージョンの識別子
+ solution が環境に依存しない場合は ""(空)のままにする。
+ 目的:基盤となる SDK/ミドルウェアがアップグレードされたとき、将来の
+ 利用者がこれを見て solution がまだ有効かどうかを判断できるようにする。
+
+confidence — 0.0〜1.0
+ 1.0 ユーザーがルール/指示として明示的に述べた
+ 0.7 ツールの操作から十分な根拠をもって推論した
+ 0.5 弱い推論。観察は 1 回のみ。不確か
+
+═══════════════════════════════════════════════════════════════════
+FACT のフィールド —— セグメントごとにちょうど 1 件、VALUE BAR なし
+═══════════════════════════════════════════════════════════════════
+
+セグメント全体について FACT を 1 件書く —— このセッションの状態を復元できる記録で
+あり、磨き上げた振り返りではなく、個別の発見のリストでも決してない。将来の
+agent が、提案・推論・部分的な検索を検証済みの事柄と取り違えることなく、
+この記録から作業を再開できなければならない。
+
+statement — この セッションのコンパクトな要約。同時に 2 つの役割を持ち、その
+ **両方**を果たさなければならない:これは検索ベクトルであり(将来の agent は、
+ ユーザーが問題を言い表すような言い回しの新しい問題報告で検索して
+ これを見つける)、同時にその agent が行動の拠り所とするペイロードでもある。
+ したがって:
+
+ まず、タスクと症状を、ユーザーが使うような言葉で書き出す。
+ これが見つけられるようにする部分である —— 表面的な形を、問題が
+ 報告されるときの言い方に近づける。具体的な目的と対象を名指しする
+ (「D:\\WXWork 配下のディスク容量を取り戻す」「feat/q4 で
+ QtColor._parse_value の色相の乗数を調整する」「new_file_search
+ フォルダの場所を特定する」)。一般的な「バグを直す」「ファイルを探す」
+ ではない。具体的な症状を含める:エラー文字列、失敗したコマンド、
+ 誤った出力。
+
+ 次に、座標と決定を示す。
+ コード作業ならリポジトリ相対パス、シンボル、ブランチ。何に
+ **落ち着いた**かを述べ、同じ節で何を破棄したかを示す
+ (「X に落ち着いた。暫定の Y は破棄した」)。ここはコードを読んでも
+ 再導出できない部分である —— コードが示すのは採用された方だけで、
+ Y が試されて却下されたことは決して示さない。却下された版に後で
+ 出くわした agent はそれと見抜けなければならない。さもないと、
+ コードを破棄された版に「修正」して戻してしまう。
+
+ 最後に、証拠の状態で締めくくる。
+ 次のいずれか 1 つ:完了、一部完了、失敗、ブロック、または
+ 検証待ち —— さらに、どう確認したか(「テスト実行済みで
+ 合格」/「git diff で確認したのみ、テスト未実行」)。否定的な結果や
+ 行き止まりも、誇張せずに含める。
+
+ ⚠️ 物語で止めてはならない。「ユーザーは X を試してエラー Y が出た。まだ
+ 解決策は見つかっていない」は無駄な記録である:検索ではうまく引っかかるが、
+ 将来の agent に行動の手がかりを何も与えない。セッションが本当に何の決定にも
+ 至らなかった場合は、何が除外されたか、次に探るべき未探索の手がかりは何かを
+ 書く —— それが再利用できる部分である。
+
+ 文の主語は「ユーザー」ではなく、コードと決定であるべきだ。2〜4 文の
+ 流れるような文章で書き、ラベル付きのセクションにはしない。
+ 厳格な上限はラテン文字で約 400 字(CJK で約 200 字)。
+
+ 証拠への忠実さ —— 必須:
+ - 実際に実行された操作と、トレースに明示的に現れている証拠だけを
+ 記録する。重要なコマンド、フラグ、引数、エラー、数値は
+ そのまま逐語的に保持する。慣例的なフラグでコマンドを補完することも、
+ 助言や計画を行動に変えることも**決して**しない。
+ - 試みた、観察した、検証した、推論した、未解決、の区別を保つ。
+ 文章にこれらのラベルを付けず、その意味を自然に表現する。例:
+ 「…を試したが Access denied でブロックされた」「…が疑われるが、
+ まだ検証していない」。
+ - ツールの出力や明示的な確認がない限り、修正が成功した、原因が
+ 確定した、ファイル/フォルダが存在しない、テストが合格した、と
+ **決して**主張しない。
+ - 否定的な発見はすべて、実際に検索した範囲に限定して書き、それを
+ 覆しうる明示的なカバー範囲の制限を**すべて**列挙する。特に権限エラーと
+ 最大検索深さ:
+ 「C:\\ と D:\\ の検索した範囲内では見つからなかった。一部の
+ ディレクトリは Access denied でスキップされ、検索には深さの制限も
+ あった」。要約を見栄えよくするために制限を 1 つでも
+ 省いてはならない。部分的な検索を全体的な不在に格上げして
+ はならない。
+ - 因果関係を確実なものとして述べるのは、トレースが直接それを検証している
+ 場合だけである。そうでなければ留保(「疑われる」/「推測される」/
+ 「まだ検証していない」)を残す。誤った
+ テストの前提を、システムの根本原因として書き換えてはならない。
+
+ 最重要 —— このテキストこそが検索ベクトルであり、将来のクエリが照合される
+ 唯一のものである。一般的な要約には価値がない。**すべての**セッションが
+ 一般的な要約のように見えるからだ:あらゆるクエリにマッチし、どれにも
+ 答えない。したがって、この セッションを見つけられるようにする具体的な
+ 手がかりを必ず名指ししなければならない —— 実際のファイルパス、関数/
+ シンボル名、ブランチ名、コマンド、エラー文字列、バージョン、設定のキーと
+ 値、ホスト/サービス名。後で誰かがそれらの具体的な情報のどれか 1 つで
+ 検索したら、返ってくるのはこの要約でなければならない。
+ good: 「CI で失敗している `npm run build` の修正。
+ .github/workflows/ci.yml と package.json を読み、原因を node 18 上で
+ webpack 5.74 が ERR_OSSL_EVP_UNSUPPORTED を起こすことまで追跡した。
+ workflow の node を 20 に上げるとビルドが通った。ローカルの
+ node 18 では依然として再現する。」
+ good: 「ブランチ feat/q0 にて、qutebrowser/utils/debug.py の signal_name:
+ PyQt<5.11 は名前を repr(sig) 経由でしか公開せず、repr には角括弧形式と
+ 丸括弧形式の両方がある。fullmatch で順に試し最初にマッチした時点で
+ 抜ける 2 つのパターンに落ち着いた。単一の正規表現の版は破棄した。
+ git diff で確認、テスト未実行。」
+ bad: 「ユーザーがビルドのバグを直したいと言い、agent がいくつかの設定
+ ファイルを見て、コードを少し変えて直した。」
+ (パスも、コマンドも、エラー文字列も、バージョンもない —— 検索の
+ 手がかりが何もない。どのセッションもまさにこう読める)
+ bad: 「feature ブランチで signal-name のパースの互換性問題を
+ 修正した。」
+ (どのブランチ? どのファイル? どの関数? 競合する 2 つの版の
+ どちらが採用された? 1 週間後に検索されたとき、役に立つものが
+ 何も残っていない)
+ 忠実さの例(bad → good):
+ 「Get-ChildItem -Force を実行した」→「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": ["..."]
+ }}
+}}
+
+必須:少なくとも 1 つの experience を**必ず**出力すること。空のリストを返しては**ならない**。
+タスクが単純に見えても、1 回で成功したものであっても、行ったことの
+再利用できる本質(方法/コマンド/やり方)を捉える。セッションの内容が薄い場合は、
+最も価値のある experience 1 つだけで足りる —— ただし、空の "experiences" 配列は
+決して出力しない。
+
+"fact" は単一のオブジェクトであり、決してリストではない —— セッションごとに 1 件の記録。
+"fact": null を使うのは、セグメントが何も確立しなかった純粋な雑談の場合だけである。
+"""
+
+CODING_RECONCILE_PROMPT = """\
+あなたは、新しいコーディング記憶の下書きを、ユーザーの既存の記憶とどう統合するかを決める。
+
+新しい下書きごとに、次のいずれか 1 つを決める:
+ ADD — 同じタスク/側面を記述する既存の記憶がない
+ UPDATE — 既存の記憶が同じタスクを記述している。新しい下書きでそれを置き換える
+ (solution が変わった、環境がアップグレードされた、など)
+ SKIP — 既存の記憶の重複。新しいものは何もない
+
+さらに、新しい内容によって既存の候補が古くなった、または無効になった場合は、
+それらに対して DELETE op を出力してよい:
+ DELETE — 新しい会話が、UPDATE では修復できない既存の記憶を**明示的に**
+ 置き換え/取り消し/無効化している。例:
+ * ユーザーが「もう X は使わないで」と言い、X が別個の記憶としてのみ
+ 存在する(追加/更新される記憶とは別のもの)
+ * 候補の boundary_envs(サービス/エンドポイント/SDK)がなくなっており、
+ 新しい会話がその廃止を確認している
+
+ルール:
+- 「同じタスク」とは、既存の記憶と新しい下書きが、将来の同じユーザーのクエリに
+ 対してどちらも有効な答えになることを意味する。
+- solution が異なる場合は UPDATE を優先する(履歴は保持しない)。
+- task と solution の両方がほぼ一致する場合は SKIP。
+- DELETE は、候補が無効/古いという**明示的な**証拠がある場合にのみ行う。
+ 候補が「古そう」に見えるというだけで DELETE しない。
+- DELETE を出力した場合、op の数は下書きの数より多くなってよい。
+
+═══════════════════════════════════════════════════════════════════
+新しい下書き
+═══════════════════════════════════════════════════════════════════
+{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 = """\
+あなたはセッション単位の WORKING FACTS を管理する。各 statement は 1 つの
+トレース/セッション全体を要約したもので、ユーザーのタスク、大まかな進め方、結果を
+含む。原子的な主張ではない。
+
+以下の新しいセッション FACT はすべて保存される。それはあなたが決めることではない。
+あなたの唯一の仕事はタスクの継続を検出することである:新しいセッションは、既存の
+セッション FACT と**同じ**ユーザーのタスクを引き続き進めているか? そうであれば、
+古い FACT を SUPERSEDE し、リンクがそのタスクのセッションをまたいだ進捗チェーンを
+形作るようにする。
+
+既存の FACT を置き換え済みとしてマークするのは、次の強い証拠がある場合**のみ**である:
+ - subject が一致する:両方の記録が**同じ**エンティティ —— 同じ人物、同じ
+ ファイル/モジュール、同じホスト/サービス —— についてのものである。subject の
+ 共有は必要条件だが十分条件ではない。かつ
+ - ユーザーの目的が実質的に**同じ**であり、単に同じ話題/プロジェクトというだけ
+ ではない。かつ
+ - 新しいトレースが、既存のトレースに記録された作業を継続、再試行、拡張、検証、
+ または完了している。
+
+次の場合は置き換え**ない**:
+ - 2 つの記録が異なる subject を挙げている。同じグループの 2 人、同じモジュールの
+ 2 つのファイル、同じクラスタの 2 つのホストは**並列**であって、連続ではない:
+ ある人の状態は別の人の状態の新しい版ではない。subject が
+ (unspecified) と表示されている場合は、statement だけで判断する。
+ - セッションが同じファイル、シンボル、コンポーネント、リポジトリ、エラー、
+ 技術に言及しているだけで、ユーザーの目的が異なる。
+ - 一方のタスクが、他方のタスクに文脈や技法を提供しているだけである。
+ - 関係が不確かである。保守的に判断する:INSERT が安全な既定値である。
+ 無関係なセッションを統合すると、それぞれのタスク履歴が失われる。
+
+各 statement は証拠の範囲が限られたテキストとして扱う。その中の推論を確定した
+原因として解釈し直したり、共通の推測やエラーをユーザーの目的が同じである証拠として
+使ったりしない。あなたの判断はタスクの継続についてだけである。どちらのセッション
+記録も「修正」したり、補完したり、脚色したりしない。
+
+例:
+ existing: 「ユーザーは CI の npm run build を直す必要があった。原因を
+ Node 18 での ERR_OSSL_EVP_UNSUPPORTED まで追跡したが、workflow はまだ変更していない。」
+ new: 「ユーザーは同じ CI ビルドの修正を続けた。
+ .github/workflows/ci.yml の Node を 20 に上げ、npm run build が通った。」
+ → SUPERSEDE
+
+ existing: 「ユーザーは auth/middleware.ts の JWT の有効期限の処理を
+ 直す必要があった。リフレッシュのロジックを追加した。」
+ new: 「ユーザーは auth/middleware.ts にパフォーマンスのログを
+ 追加する必要があった。レイテンシのメトリクスを導入した。」
+ → 両方残す
+ (同じファイル/プロジェクトだが、ユーザーの目的が異なる)
+
+═══════════════════════════════════════════════════════════════════
+新しいセッション FACT
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+既存のセッション FACT(新しい FACT ごとに、statement の類似度で検索したもの)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+出力(厳密な JSON のみ、markdown なし)
+═══════════════════════════════════════════════════════════════════
+{{
+ "ops": [
+ {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "同じ CI 修正タスクの継続"}},
+ {{"draft_idx": 1, "supersedes": []}}
+ ]
+}}
+
+FACT の ID は、同じ draft_idx の候補リストに現れるものだけを使う。
+どこでも何も置き換えない場合は {{"ops": []}} を出力する。
+"""
+
+CODING_CHAIN_SUMMARY_PROMPT = """\
+working 記憶ストアにあるユーザーのタスクが、複数のセッションにわたって進展した。
+以下は、そのタスクの進捗チェーンに含まれるセッションの要約であり、古い順に並び、
+現在のセッションで終わる。
+
+**同じ**タスクがセッションをまたいでどのように現在の状態まで進展したかを要約する。
+重要な段階をすべて時系列順に取り上げる。各段階について、可能な範囲で次のものを
+保持する:実際の操作や変更、その直接の結果、未解決の問題や制約条件。最後に
+現在の状態を明示する。
+
+ルール:
+ - これは圧縮だけである。エントリに書かれていること**だけ**を報告する。コマンド、
+ 原因、動機、操作、テスト結果、成功状態、全体的な否定の結論を追加したり
+ 補完したりしない。
+ - 証拠の状態を正確に保つ:試みたことは完了したことではなく、観察したことは
+ 検証したことではなく、推論したことは確定したことではなく、未解決のものは
+ 未解決のままである。不確かさを表す言葉と、検索/権限/カバー範囲の制限を残す。
+ - 現在の終了状態を忠実に述べる(完了、一部完了、失敗、ブロック、
+ または検証待ち)。もっともらしい因果の筋書きや、それを検証していない後の
+ エントリを根拠に、状態を格上げしない。
+ - エントリが疑われる原因と後の結果に言及している場合、両者を因果的に
+ 結びつけるのは、その原因が検証されたとエントリが直接述べている場合だけである。
+ - 具体的な検索の手がかりを保持する:ファイルパス、シンボル、コマンド、エラー
+ 文字列、バージョン、設定のキー/値、進捗にとって重要な数値。
+ - 2〜3 世代のチェーンでは、進展を 1 文に圧縮しすぎない。必要に応じて 2〜4 個の
+ 簡潔な段落にするか、タスクの目的、段階ごとの進展、現在の状態が明確な
+ 読みやすい文章にする。
+ - 履歴全体を機械的にコピーしない。重要な操作、直接の結果、残った課題は保ちつつ、
+ 繰り返しや価値の低い詳細は省く。
+ - 段階の見出しや日付をでっち上げない。日付に触れるのは、エントリにとってそれが
+ 意味を持つ場合だけである。単なるタイムスタンプはノイズである。
+ - 古い版が省略されているとエントリに書かれている場合は、それ以前の履歴が
+ 省略されていることを明示する。与えられたエントリが完全であるかのように示さない。
+ - エントリと同じ言語で書く。
+ - 前置きや全体を囲む引用符は付けない。
+
+例
+ エントリ:
+ (2026-07-20) ユーザーは CI の npm run build を直す必要があった。原因を
+ Node 18 での ERR_OSSL_EVP_UNSUPPORTED まで追跡したが、workflow は
+ まだ変更していない。
+ (2026-07-24) ユーザーはその CI の修正を続けた。.github/workflows/ci.yml の
+ Node を 20 に上げたが、依存関係のキャッシュによって
+ 古いエラーが依然として再現した。
+ (now) ユーザーは同じ修正の検証を続けた。npm のキャッシュを
+ クリアした後、npm run build が通った。
+ 出力:
+ タスクの目的は CI の npm run build を直すことである。まず原因が Node 18 での
+ ERR_OSSL_EVP_UNSUPPORTED まで追跡されたが、workflow はまだ変更されていなかった。
+ 次に .github/workflows/ci.yml の Node が 20 に上げられたが、依存関係の
+ キャッシュによって古いエラーが残っていた。最後に npm のキャッシュをクリアした後、
+ npm run build が通ったため、このビルド修正は現在、完了として検証されている。
+
+═══════════════════════════════════════════════════════════════════
+エントリ
+═══════════════════════════════════════════════════════════════════
+{chain_block}
+
+═══════════════════════════════════════════════════════════════════
+出力(要約そのもののみ、それ以外は何も出力しない)
+═══════════════════════════════════════════════════════════════════
+"""
+
+
+# ================================================================
+# Episode / topic summaries
+# ================================================================
+
+EPISODE_SUMMARY_PROMPT = """あなたは、ユーザーとの会話の**1 つの**エピソードを要約している。
+
+エピソードとは、ひとまとまりの話し合い —— 話題にされた 1 つの事柄 —— であり、
+複数回の書き込みセッションにまたがることもある。
+
+## このエピソード中に記録された記憶(古い → 新しい)
+
+{memories}
+
+---
+
+このエピソードで何が起きたか/何が話し合われたかを、密度の高い 1 つの要約にまとめる。
+
+ルール:
+
+* 2〜4 文、三人称で、「ユーザーは…」で始める(記憶が別の人物についてのもので
+ あれば、その人の名前で始める)。
+* 記憶を結びつけて 1 つのまとまった記述にする —— エピソードには通常、全体を
+ 貫く筋(計画、問題、外出、決定)がある。
+* 具体的な詳細を保持する:名前、場所、数値、日付。
+* 記憶にないことを何もでっち上げ**ない**。
+* 記憶を 1 つずつ列挙し**ない**。統合してまとめる。
+* 出力言語は記憶の言語と一致させなければならない。
+
+要約のテキストだけを返し、前置き、JSON、引用符は付けないこと。"""
+
+TOPIC_SUMMARY_PROMPT = """あなたは、**1 つの**トピックについて分かっていることすべてを要約している。
+
+## トピック
+
+{topic_name}
+
+## このトピックに属する記憶(古い → 新しい)
+
+{memories}
+
+---
+
+このトピックに関して、ユーザーについて分かっていることを、密度の高い 1 つの要約に
+まとめる。
+
+ルール:
+
+* 2〜4 文、三人称で、「ユーザーは…」で始める(記憶が別の人物についてのもので
+ あれば、その人の名前で始める)。
+* トピックを全体としてカバーする —— 現在の状況を述べ、どのように変化してきたかは、
+ その変化が重要な場合にのみ触れる。
+* 具体的な詳細を保持する:名前、場所、数値、日付。
+* 記憶にないことを何もでっち上げ**ない**。
+* 記憶を 1 つずつ列挙し**ない**。統合してまとめる。
+* 出力言語は記憶の言語と一致させなければならない。
+
+要約のテキストだけを返し、前置き、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 は、長期的なユーザーモデルにおける、出来事をまたいだ 1 つの行動パターンであり、
+次の 3 つの要素を含む:
+
+
+- **状況(Circumstance)**:このパターンが観察されるドメイン/話題/状況。Schema はその状況の中にとどまらなければならない —— ドメインをまたいで一般化してはならない。ドメインをまたぐ抽象化は、システムが別途扱う。
+- **パターン(Pattern)**:この状況におけるユーザーの習慣的な行動、考え方、行動傾向。
+- **洞察(Insight)**:その根底にある心理的な動機やメンタルモデル。
+
+### content の形式
+3 つすべてを組み合わせた 1 文を使う:
+「[状況]のとき、ユーザーは[パターン]—— これは[洞察]を反映している。」
+
+長期的な感情、セラピー、ストレス、悲嘆、トラウマに関するパターンでは、
+具体的な自伝的背景を消して一般的な性格のラベルにしてはならない。次のものを
+保持する、背景に結びついた構造を優先する:
+「きっかけ/背景 -> 繰り返される感情的反応 -> 観察された対処の手段」。
+含めるのは、ユーザー所有の証拠に存在するきっかけ、反応、対処の手段だけである。
+アシスタントの助言は、観察されたユーザーの対処の手段ではない。
+
+### ルール
+- **原子的**:1 つの Schema に 1 つのパターン。異なる 2 つのパターン → 2 つの Schema。
+- **不変**:一度作成したら、content は決して変わらない。
+- **証拠のみ**:既存の表現を裏づけるだけの新しい事実 → `add_evidence` を
+ 呼び出す。新しい証拠が現在の長期的な状態を実質的に変える、訂正する、または
+ 狭める場合は `revise_schema` を使い、古い版を監査用に保持しつつ、
+ 通常の検索からは外す。
+- **ドメインに限定**:観察されたドメインの中にとどまる。ドメインをまたぐ抽象化は、別のシステムプロセスが扱う。
+- **事実とパターンを分ける**:明示的な単一のアイデンティティ、健康状態、
+ 機器の使用、所属、プロジェクト、好みは L6 ではなく L2 の状態記憶に属する。
+ L6 には、少なくとも 2 つの独立した raw 書き込みまたはセッションを表す
+ ユーザー所有の証拠が必要である。統合された 1 つの L2 事実が複数の書き込みを
+ 表していることもある。fact ノードの数を数えるのではなく、その source_raw_memory_ids を調べる。
+- **主体の安全性**:同じソースチャンクを共有する事実が、他の人物や例を記述している
+ こともある。素材がそのパターンを明示的にユーザーに帰属させている場合にのみ、
+ ユーザーの Schema を作成する。そうでなければ、その素材については何の操作も出力しない。
+- **候補の網羅**:source-context review では、列挙されたすべての候補事実を
+ 扱わなければならない:`create_schema`/`add_evidence` の証拠として使うか、
+ `skip_fact` を出力するかのいずれかである。raw の文脈は、その主体を確認したり
+ 省略された詳細を補ったりしてよいが、無関係な Schema の種にしてはならない。
+- **証拠の閾値**:L6 を作成するには、少なくとも 2 つの独立した raw 書き込みまたは
+ セッションを表す、1 つ以上のユーザー所有の証拠事実が必要である。
+ アシスタントの助言だけではユーザーのパターンは成立しない。
+
+### 良い例と悪い例
+✅ 「料理をするとき、ユーザーはレシピの手順に厳密に従い、材料を正確に計量する —— これは不確実性に対処するために外部の構造を必要としていることを反映している。」
+✅ 「ゲームをするとき、ユーザーは 100% 達成のために必ず攻略情報を確認する —— 未完了への耐性の低さに突き動かされている。」
+✅ 「恩師を思いがけず亡くして以来、死を思い起こさせるものに触れると悲しみが突然よみがえることがある。ユーザーは立ち止まって振り返り、静かに散歩をして落ち着きを取り戻す。」
+❌ 「ユーザーは音楽を創造的な統合と文化の架け橋の手段として捉え、多様な音楽の伝統を一貫して融合させている……」(複数のパターンが混ざっており、広すぎる)
+❌ 「ユーザーは多くのことに情熱を持ち、質を重視している。」(状況がなく、曖昧すぎる)
+❌ 「ユーザーは意味を重視し、回復力がある。」(長期的なきっかけと観察された対処の証拠を消してしまっている)
+
+## あなたのワークフロー
+
+入力素材(クラスタが少なくとも 1 つ存在する場合にのみ呼び出される):
+- **クラスタ結果**:主な入力 —— 意味的な類似度でグループ化された事実
+- **クラスタ外の事実(補足)**:どのクラスタにも属さない事実。クラスタ結果より優先度が低い
+
+事実の各グループ(クラスタ内またはクラスタ外)について:
+1. **既存の Schema を検索する**:既存の Schema がすでにこのパターンを捉えている場合は、`add_evidence` を呼び出す。`revise_schema` を使うのは、新しい証拠を加えた後に古い表現が実質的に不完全または誤解を招くものになる場合だけである。
+2. **新しい Schema を作成する**:このパターンをカバーする既存の Schema がない場合にのみ。1 文で、3 つの要素を含める。
+3. **関係を構築する**:2 つの Schema がテーマ的に関連している場合は、`add_edge`(RELATED_TO)を使う。
+
+## 原則
+
+- Graph の操作はすべてツールを通じて行わなければならない
+- Schema の content は不変である —— すでに存在するものを決して作り直さない
+- 重複を作成するより `add_evidence` を優先する
+- 低品質なノードを作成するより、作成しないことを優先する
+- 1 つの Schema = 1 つのドメインにおける 1 つの原子的なパターン
+- タグを付けるときは、既存のタグリストにあるタグの再利用を優先する"""
+
+
+# ================================================================
+# 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, so their prompts stay exactly as before.
+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"# 2種類の記憶.*?(?=\n# OWNER(帰属)\n)"
+
+NO_INTENTION_MEMORY_SECTION = (
+ "# 記憶\n"
+ "\n"
+ "抽出する記憶は 1 種類だけである:**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 = (
+ (
+ "すべての memory と intention には、それがどの記憶ストアに属するかを示す `owner` を必ず付けなければならない。",
+ "すべての memory には、それがどの記憶ストアに属するかを示す `owner` を必ず付けなければならない。",
+ ),
+)
+
+INTENTION_DISABLED_NOTE = (
+ "\n\n---\n\n# INTENTION 無効\n"
+ "intention の抽出は無効になっている。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** — 新しい L6 行動 Schema を作成する
+ ```{"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 に証拠を追加する(content は不変のまま)
+ ```{"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** — 2 つの 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. evidence_list の ID は、素材で提供された fact の node_id から取らなければならない。
+5. add_evidence / revise_schema の node_id は、既存の Graph ノードの ID から取らなければならない。
+6. source-context review では、すべての候補事実が evidence_list または skip_fact のどちらかに現れなければならない。"""
+
+# Appended to SYSTEM2_OUTPUT_INSTRUCTIONS when the schema evidence gate is on.
+SYSTEM2_SCHEMA_EVIDENCE_GATE = """
+
+7. L6 は出来事をまたいだ行動パターンだけを表す。create_schema には、少なくとも 2 つの独立した raw 書き込みまたはセッションを表すユーザー所有の証拠を使わなければならない。source_raw_memory_ids に複数の独立した書き込みが含まれている場合は、統合された 1 つの事実でも条件を満たしうる。
+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
+# (or be harmless if it does not).
+SYSTEM2_SINGLE_CALL_REPLACEMENTS = (
+ ("- Graph の操作はすべてツールを通じて行わなければならない\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"
+ "- Graph の Schema の総数: {graph_total}(今回呼び出し={recalled})"
+ ),
+ "graph_status_empty": "- Graph の状態: **空**(初回の認知処理)\n",
+ "clusters_header": "### クラスタ結果\n",
+ "label_holistic": "セッションをまたいだユーザーの事実 {n} 件。証拠に裏づけられた長期的な感情/セラピーのパターンのみ",
+ "label_source_context": "候補事実 {n} 件。raw の書き込みは主体/詳細の検証のためだけのもの",
+ "label_topic": "事実 {n} 件、トピック",
+ "raw_label": "候補ごとの関連する raw の抜粋",
+ "holistic_note": (
+ "これは範囲を限定した夜間の全体統合処理 1 回分である。作成する anchored therapy Schema は最大 "
+ "{max_schemas} 個までとする。"
+ "異なる raw 書き込み/セッションにまたがる、長期的なきっかけ/背景、繰り返される感情的反応、"
+ "観察された対処の手段または意思決定上の制約を結びつけることを優先する。"
+ "create_schema の前に、その証拠 ID の raw_sources の和集合を取り、少なくとも 2 つの"
+ "異なる raw ソース ID を必要とする。1 つの raw 書き込みに由来する 2 つの事実は 1 つの出来事である。"
+ "証拠が不十分な場合は [] を出力する。\n"
+ ),
+ "companion_header": "**独立したソースによる companion のヒント(候補であり、結論ではない):**",
+ "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 の逆参照(既存の Schema が参照している VDB の事実)\n",
+ "tags_header": "### 既存のタグ(同義のタグを新たに作るより、これらの再利用を優先すること)\n",
+ "closing": (
+ "上記の素材を分析し、操作の JSON 配列を出力すること。"
+ "新しい Schema を作成するか、既存の Schema に証拠を追加するかを判断すること。"
+ "信頼できる結論を出すにはデータが不十分な場合は、空の配列 `[]` を出力すること。"
+ "タグを付けるときは、上記の既存のタグリストにあるタグの再利用を優先すること。"
+ ),
+}
+
diff --git a/hy_memory/prompts/ko.py b/hy_memory/prompts/ko.py
new file mode 100644
index 0000000..9b26cd7
--- /dev/null
+++ b/hy_memory/prompts/ko.py
@@ -0,0 +1,2259 @@
+# -*- coding: utf-8 -*-
+"""Korean prompts (``ko``). 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는 메타데이터로만 사용하며, 상대적 시간을 해석하는 데 절대 사용하지 않는다
+
+---
+
+# 추출 대상
+
+NEW 사용자 메시지에서 새로 등장한 정보만 추출하라.
+
+좋은 기억의 예:
+
+* 선호
+* 장기 프로젝트
+* 습관
+* 목표
+* 반복되는 활동
+* 의견
+* 인간관계
+* 중요한 경험
+* 안정적인 특성
+* 향후 계획
+* 결정
+* 제약 조건
+* 받아들인 추천
+
+다음은 추출하지 마라.
+
+* 잡담
+* 맞장구·인사치레
+* 일반적인 감정 표현
+* 일시적인 대화 맥락
+* 어시스턴트가 예전 기억을 상기시키는 말
+* 이전 맥락에서 이미 함축된 정보
+* 막연한 성격 판단
+
+---
+
+# 주체
+
+모든 기억은 그 자체로 완결되어야 하며, 3인칭으로, 명시적인 주체와 함께 써야 한다.
+어떤 주체를 쓸지는 **누가 말했는가**로 결정된다.
+
+| 화자 | 쓸 주체 | 예시 |
+| --- | --- | --- |
+| `role: "user"` | 사용자 | "사용자는 ..." / "The user ..." |
+| 사용자가 아닌 `name`을 가진 모든 화자 (예: `name: "John"`) | 그 사람, 이름으로 | "John은 ..." |
+| `name`이 없는 `role: "assistant"` | AI 어시스턴트 | "어시스턴트는 ..." |
+
+두 입력 섹션은 화자를 서로 다르게 표현한다.
+
+* **New Messages**는 JSON 배열이다 — `role`과 선택적인 `name` 필드를 읽어라.
+* **Last k Messages**는 렌더링된 텍스트다 — 화자는 대괄호 라벨
+ `[user]:` / `[John]:` / `[assistant]:`이며, 그 앞에 한 줄
+ "사용자의 이름은 Tim입니다" / "The user's name is Tim"이 올 수 있다.
+
+규칙:
+
+* 사용자는 이 기억들의 주인이다. 사용자 본인의 이름을 알고 있더라도
+ (그의 메시지의 `name`이나 앞머리의 이름 줄에서), 여전히
+ "사용자는 ..."이라고 쓰고, 절대 "Tim은 ..."이라고 쓰지 마라.
+* **`name`이 있는 `role: "assistant"`는 AI가 아니라 또 다른 실제 사람이다.**
+ 그 사람의 기억은 그 이름을 주체로 써라: "John은 ...".
+* 이름이 없는 `role: "assistant"`만 AI 어시스턴트다.
+* AI 어시스턴트의 이름을 지어내지 마라. 어시스턴트에게는 이름이 없다.
+
+---
+
+# 언어 규칙
+
+* 출력 언어는 입력 언어와 일치해야 한다.
+* 원래의 문자 체계와 기술 용어를 그대로 보존하라.
+* 이름, 브랜드, 수식을 절대 음역하지 마라.
+
+---
+
+# 두 종류의 기억
+
+너는 두 종류의 기억을 추출한다: **memory**와 **intentions**.
+
+## memory
+
+사용자에 대해 — 그리고 대화에 등장하는 다른 이름 있는 사람에 대해 — 오래 유지되고
+기억할 가치가 있는 모든 것은 여기에 넣는다.
+
+* 선호, 의견, 가치관, 태도
+* 사건, 행동, 경험
+* 습관, 행동 패턴
+* 인간관계, 특성
+* 객관적 사실, 결정, 제약 조건
+* 진행 중인 활동
+
+강하게 시사되는 경우 암묵적인 선호를 반드시 추론해야 한다
+(예: 어떤 활동을 다시 시작함 → 긍정적인 관심, 무언가를 피함 →
+부정적인 선호, 자발적인 노력의 반복 → 지속적인 관심).
+
+"사용자가 어떤 사람인가"와 "무슨 일이 있었는가"를 나누지 마라.
+둘 다 `memory`에 들어간다.
+
+## intentions
+
+사용자가 **앞으로 하려고 계획하거나 의도하는** 미래 지향적인 일로,
+실행할 수 있고, 완료되거나 시점이 지나면 의미가 없어지는 것.
+
+예시:
+
+* "사용자는 다음 주 화요일에 취업 면접이 있다."
+* "사용자는 월말에 이사할 계획이다."
+* "사용자는 금요일 전에 보고서를 끝낼 생각이다."
+
+intentions가 아닌 것 (이것들은 `memory`에 속한다):
+
+* 안정적인 선호 / 특성 ("사용자는 농구를 좋아한다")
+* 이미 끝난 과거 사건 ("사용자는 작년에 베이징으로 이사했다")
+* 실행 가능한 미래 단계가 없는 일반적인 목표
+
+### valid_until
+
+각 intention마다 `valid_until`을 제공하라: 그 intention이 더 이상 의미가 없어지는
+날짜(마감일 / 목표일)로, **Memory Date**를 기준으로 해석한다
+(예: "다음 주 화요일" → 해당하는 절대 날짜).
+마감일을 정할 수 없으면 `valid_until`을 `null`로 설정하라.
+
+---
+
+# OWNER
+
+모든 memory와 intention에는 그것이 어느 기억 저장소에 속하는지를 나타내는 `owner`가 반드시 있어야 한다.
+값은 정확히 두 가지다.
+
+* `"user"` — 사용자 본인의 기억 저장소에 속하는 모든 것. 사용자 자신에 대한
+ 사실/선호/특성은 물론, 대화에 등장하는 다른 이름 있는 실제 사람에 대한 사실도
+ 포함된다. 그것들도 사용자의 기억이 담아 두어야 할 내용이기 때문이다.
+* `"agent"` — AI 어시스턴트(이름 없는 `role: "assistant"`)가 제공한 정보
+ (추천, 확인, 조사한 내용), 또는 사용자가 **어시스턴트**에게 시키고 싶은
+ 미래의 행동("8시간 뒤에 알려 줘").
+
+이름 있는 사람은 절대 `owner: "agent"`가 아니다 — 그들의 메시지에 `role: "assistant"`가
+붙어 있더라도 그들은 AI가 아닌 실제 사람이다. 그들의 기억은 `owner: "user"`이고,
+content의 주체는 그들의 이름이다.
+
+`owner`는 항목마다 판단하라. 확신이 없으면 기본값 `"user"`를 사용하라.
+
+---
+
+# 시간 규칙
+
+상대적 시간은 Memory Date를 기준으로 해석하라.
+
+예시:
+
+* "다음 주"
+* "지난달"
+* "내일"
+
+시간을 안전하게 해석할 수 없으면:
+
+* 상대적 표현을 제거하고
+* 기억을 시간과 무관하게 유지하라
+
+시간 순서를 지어내지 마라.
+
+**방금 일어난 일도 사건이다 — 남겨라.** 사용자가 무언가를 방금 마쳤다고 말할 때
+("방금 돌아왔다", "방금 끝냈다", "오늘 아침", "어제"), 완료 날짜는 Memory Date다.
+그 날짜와 함께 **사건 자체**를 출력하라. 배경 진술 속에 녹여 넣지 마라.
+
+* "가족과 여행 갔다가 방금 돌아왔어"
+ → "사용자는 <Memory Date>에 가족 여행에서 돌아왔다."
+ NOT → "사용자는 가족 여행을 다닌다." (돌아온 날짜가 "언제 돌아왔는가"에 대한
+ 답이며, 그것을 버리면 그 질문에 답할 수 없게 된다)
+
+어떤 사건의 시작과 끝이 대화에서 따로 주어진다면, 하나의 기간으로 합치지 말고
+둘 다 기록하라.
+
+---
+
+# 품질 규칙
+
+각 기억은 다음을 만족해야 한다.
+
+* 그 자체로 완결됨
+* 맥락상 완전함
+* 검색하기 좋음
+* 정보 밀도가 높음
+
+중요한 세부 사항을 보존하라.
+
+* 이름
+* 제품
+* 장소
+* 숫자
+* 수식
+* 제약 조건
+
+구체적인 것을 범주로 일반화하지 마라. 실제로 말한 것을 써라.
+
+* "Banff" → "Banff"를 유지하고, "로키산맥"으로 쓰지 마라
+* "Luna라는 이름의 세 살 보더콜리" → 견종, 나이, 이름을 유지하라
+
+**상대 화자가 제공한 구체 정보도 유효하다.** 사실은 여러 턴에 걸쳐 만들어지는 경우가
+많다: 상대 화자가 대상을 언급하고, 사용자가 그것을 확인한다. 주체 규칙은 그것이
+누구의 기억인지, 즉 *누구의* 것인지만 정할 뿐이며, 세부 사항을 버려도 된다는 뜻이
+아니다.
+
+* [Sam]: "Banff에서 스키 탈 기회는 잘 활용했어?"
+ [user]: "응, 스키 타기 정말 좋았어!"
+ → "사용자는 Banff에서 스키를 탔고 설질이 아주 좋았다고 느꼈다."
+ NOT → "사용자는 겨울 스포츠를 즐긴다." (장소와 활동이 모두 확정되었고,
+ 각각 한 화자씩 말한 것이다)
+
+맥락이 없는 단편적인 기억을 피하라.
+
+앞으로의 서로 다른 검색 요구를 여전히 보존하는 범위에서 가장 적은 수의 기억을 선택하라.
+
+* 압축은 결합이지 생략이 아니다. 새 메시지에 있는 명시적이고 오래 유지되는 모든
+ 명제는 출력에 정확히 한 번 나타나야 한다.
+* 같은 주체이고 같은 실제 사건, 상태, 선호, 계획 또는 결정에 관한 세부 사항이면
+ 결합하라. 하나의 일관된 사건은 1–3문장을 사용할 수 있다.
+* 같은 근거에 대해 넓은 진술과 그보다 좁게 다시 말한 진술을 둘 다 출력하지 마라.
+* 주체가 다르거나, 사건이 서로 독립적으로 일어났거나, 서로 다른 상태를 기술하는
+ 경우에만 나눠라.
+* 원인, 추천, 결과를 나누면 그 관계가 사라지는 경우에는 그것이 설명하는 사실과
+ 함께 두어라.
+* 날짜가 다른 별개의 발생을 단지 주제가 같다는 이유로 합치지 마라.
+* 원문의 시간 정밀도를 보존하라. "지난 주말"이나 "지난여름" 같은 모호한 표현은
+ 날짜가 명시되었거나 유일하게 결정되지 않는 한 정확한 달력 날짜로 바꾸지 마라.
+ "<Memory Date> 직전 주말"은 허용된다.
+
+---
+
+# 태그
+
+각 기억에는 간결한 태그가 1–3개 있어야 한다.
+- 주제 키워드는 영어 소문자로 쓴다 (travel, health, work).
+- 고유명사는 대소문자를 유지한다 (Jasper, Canada, Banff, Prius).
+
+예시:
+
+* work
+* travel
+* Jasper
+* Canada
+* health
+
+---
+"""
+
+STRUCTURE_METADATA_PROMPT = """
+
+---
+
+# 구조적 조직화
+
+모든 `memory`에 대해 다음도 함께 출력하라.
+
+* `topic_paths`: 하위 호환용으로, 넓은 것에서 구체적인 것으로 이어지는 0~3개의
+ 의미 경로 목록.
+* `event_facet`: `subject`, `participants`, `action`, `objects`, `locations`,
+ `state`만 가진 객체. state는 `planned`, `ongoing`, `completed`, `unknown` 중
+ 하나다.
+* `topic_assignments`: 주체별 소속 0~6개. 각 항목은 `{subject, role, path}`이며,
+ `path`는 `{name, type}` 세그먼트의 목록이고 `type`은 `topic`, `facet`,
+ `series`, `episode` 중 하나다. `topic`은 넓은 영역에, `facet`은 구체적인
+ 활동/의미적 측면에, `series`는 같은 구체적 활동/상태 계열이 반복해서 일어난
+ 경우에만, `episode`는 경계가 있는 단 한 번의 실제 발생에만 사용하라. 공유된
+ 사건은 하나의 정본(canonical) 기억을 유지하면서 명시적인 참여자마다 하나씩
+ assignment를 가질 수 있다.
+ 타입은 `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": "응, 어제 데려왔어 — Luna라는 이름의 세 살 보더콜리야."}]
+Memory Date: 2025-04-10
+
+출력:
+```json
+{
+ "memory": [
+ {"content": "사용자는 2025-04-09에 시내 보호소에서 Luna라는 이름의 세 살 보더콜리를 입양했다.", "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 + intention + 압축된 agent 계획
+
+New Messages:
+[{"role": "user", "content": "안녕하세요, 저는 Kenji예요. 다음 달에 일본 여행을 계획하고 있는데 7일 일정을 짜 주실 수 있나요?"},
+ {"role": "assistant", "content": "# 7일 일본 클래식 골든 루트 (도쿄 → 교토 → 나라 → 오사카)\\n도쿄로 입국해 신칸센으로 교토까지 남하하고, 나라는 당일치기, 오사카(간사이)에서 출국합니다.\\n\\n## 1일차: 도쿄 도착\\n- 하네다/나리타 도착, 도쿄역 근처 호텔에 짐 맡기기.\\n- 늦은 오후: 센소지(아사쿠사), 나카미세 거리 산책, 타이야키 맛보기.\\n- 저녁: 시부야 스크램블 교차로 + 시부야 스카이 옥상에서 일몰; 이자카야 저녁(야키토리, 사케).\\n\\n## 2일차: 도쿄 시장과 명소 — [생략]\\n## 3일차: 신칸센으로 교토, 후시미 이나리, 기온 — [생략]\\n## 4일차: 교토 사찰(기요미즈데라, 킨카쿠지, 긴카쿠지) — [생략]\\n## 5일차: 나라 당일치기(나라 공원 사슴, 도다이지) — [생략]\\n## 6일차: 오사카(오사카성, 도톤보리 길거리 음식) — [생략]\\n## 7일차: 오사카 관광 + 간사이 공항 출국 — [생략]\\n\\n팁: 도착 전에 7일권 JR 패스를 구입하세요. 조정할 부분이 있을까요?"}]
+Memory Date: 2025-09-15
+
+출력:
+```json
+{
+ "memory": [
+ {"content": "어시스턴트는 사용자를 위해 클래식 골든 루트를 따르는 7일 일본 일정을 만들었다: 도쿄(아사쿠사, 시부야), 신칸센으로 교토(후시미 이나리, 기요미즈데라, 킨카쿠지, 기온), 나라 당일치기(사슴 공원, 도다이지), 이어서 오사카(오사카성, 도톤보리), 간사이 공항에서 출국.", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
+ ],
+ "intentions": [
+ {"content": "사용자는 2025년 10월에 7일간 일본 여행을 할 계획이다.", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
+ ],
+ "basic_info": {"name": "Kenji"}
+}
+```
+한 턴이 서로 다른 버킷에 세 가지 출력을 만든다: 이름은 basic_info로, 여행은 마감일이 있는 미래 지향적 intention으로, 그리고 어시스턴트의 여러 섹션짜리 긴 일정은 밀도 높은 agent 기억 하나로 압축된다 — 경로와 도시별 핵심 방문지만 남기고, 매일의 항목, 팁, 음식 목록은 남기지 않는다. 답변 전체를 그대로 저장하면 기억이 부풀고, 골격만 저장하면 검색 가능성이 유지된다.
+
+## 예시 4 — 이전 추천을 확인/채택하는 이후 메시지는 그 자체로 사실이다
+
+New Messages:
+[{"role": "user", "content": "여섯 살 아이가 채소를 하나도 안 먹어요. 좋은 방법 없을까요?"},
+ {"role": "assistant", "content": "시금치나 당근을 갈아서 파스타 소스에 섞어 보세요 — 색과 맛이 거의 사라져서 많은 아이들이 모르고 먹습니다."},
+ {"role": "user", "content": "오 좋네요, 오늘 저녁에 해 볼게요. 그런데 그 나이면 몇 시에 재우는 게 좋아요?"},
+ {"role": "assistant", "content": "여섯 살이라면 오후 7–9시 사이에 재우고 약 10–11시간 자게 하는 것을 목표로 하세요."}]
+Memory Date: 2025-06-20
+
+출력:
+```json
+{
+ "memory": [
+ {"content": "사용자에게는 채소를 먹지 않으려는 여섯 살 아이가 있으며, 시금치나 당근을 갈아 파스타 소스에 섞어 숨기라는 어시스턴트의 제안을 받아들였다.", "tags": ["parenting", "food"], "owner": "user"},
+ {"content": "어시스턴트는 사용자에게 여섯 살 아이는 오후 7–9시 사이에 잠자리에 들어 약 10–11시간 자는 것을 목표로 해야 한다고 조언했다.", "tags": ["parenting", "sleep"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+세 번째 메시지에서 사용자는 "오늘 저녁에 해 볼게요"라고 말했다 — 앞선 제안을 명시적으로 채택한 것이다. 이 수락은 가치가 있으므로 잡담으로 버리지 말고 반드시 기록해야 한다("어시스턴트의 제안을 받아들였다"). 취침 시간 조언은 방금 주어졌고 아직 채택되지 않았으므로 조언으로 기록한다(owner "agent").
+
+## 예시 5 — RAG/주입된 맥락: 주입된 텍스트는 절대 저장하지 않는다
+
+New Messages:
+[{"role": "user", "content": "[검색된 맥락: 에펠탑의 높이는 330m이며 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": "잃어버리지 않게 우리 할머니 만두 레시피 좀 기억해 줘. 소: 다진 돼지고기 500g, 배추 300g, 간장 2큰술, 참기름 1큰술, 다진 생강 엄지 한 마디. 배추는 15분 소금에 절인 뒤 물기를 꽉 짠다. 만두를 삶다가 찬물을 두 번 붓고, 떠오르면 완성."},
+ {"role": "assistant", "content": "알겠어요, 저장했습니다!"}]
+Memory Date: 2025-07-01
+
+출력:
+```json
+{
+ "memory": [
+ {"content": "사용자 할머니의 만두 레시피: 소는 다진 돼지고기 500g, 배추 300g(15분 소금에 절인 뒤 물기를 꽉 짬), 간장 2큰술, 참기름 1큰술, 다진 생강 엄지 한 마디; 만두를 삶다가 찬물을 두 번 붓고, 떠오르면 완성.", "tags": ["food", "recipe", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+실제 사실 내용(재료, 분량, 절이고 짜는 단계, 삶는 방법)을 추출하라 — "사용자가 레시피를 공유했다"나 "사용자가 레시피를 기억해 달라고 했다"가 아니다. 공유 행위는 가치가 없고, 검색 대상이 되는 것은 내용이다.
+
+## 예시 7 — 구조화된 숫자와 속성은 정확히 보존한다
+
+New Messages:
+[{"role": "user", "content": "이번 사이클 홈짐 PR 기록: 스쿼트 140kg x 3, 벤치 100kg x 5, 데드리프트 180kg x 2, 오버헤드 프레스 60kg x 6. 체중 78kg, 종목당 3세트, 휴식 3분."},
+ {"role": "assistant", "content": "기록했어요 — 훌륭한 수치네요!"}]
+Memory Date: 2026-01-20
+
+출력:
+```json
+{
+ "memory": [
+ {"content": "사용자의 현재 웨이트 PR은 체중 78kg 기준 스쿼트 140kg x 3, 벤치 100kg x 5, 데드리프트 180kg x 2, 오버헤드 프레스 60kg x 6이다.", "tags": ["fitness", "strength"], "owner": "user"},
+ {"content": "사용자는 종목당 3세트, 세트 사이 3분 휴식으로 훈련한다.", "tags": ["fitness", "training"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+모든 숫자와 단위(kg, 반복 수, 세트, 휴식 시간)를 정확히 보존한다 — 이것들을 빠뜨리면 가장 검색 가치가 높은 정보가 사라진다. 두 개의 깔끔한 주제(PR 대 훈련 방식)로 나누되, 구체적인 값을 반올림하거나 생략하지 마라.
+
+## 예시 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년 12월경)에 베를린으로 이사할 계획이다.", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+주제가 네 개 이상이다 — 논문 심사, 베를린 아파트, 독일어 학습, 마드리드에 있는 파트너. 첫 번째 주제에서 멈추지 마라. 한 턴이 완료된 사실(임대 계약 체결)과 intention(다가오는 이사)으로 나뉜 점에 주목하라. 또한 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년 7월경 다친 어깨가 아직 아파서 다른 운동 대신 수영을 하고 있다.", "tags": ["fitness", "health"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {"name": "Tim"}
+}
+```
+John에게는 `role: "assistant"`가 붙어 있지만 `name`이 있으므로 AI가 아닌 또 다른 실제 사람이다: 그의 기억은 "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의 직업과 거주지는 **그의** 속성이므로 "John"을 주체로 하여 `memory`에 들어간다. 이것들은 절대 `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` (모든 memory와 intention에 필수) = `"user"` 또는 `"agent"`
+ (위의 "# OWNER" 참조, 확신이 없으면 기본값 `"user"`)
+* `basic_info` = **사용자 본인의 프로필만**. NEW 사용자 메시지에서 **명시적으로
+ 언급된** 안정적인 프로필 필드(예: 이름, 나이, 거주지, 직업, 고용주)를 포함하라.
+ 절대 추론하지 말고, 절대 지어내지 마라. 명시적으로 언급된 필드가 없으면
+ `{{}}`를 출력하라.
+ * 엄격한 규칙: 사용자가 `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"는 `name`의 권위 있는
+ 출처다 — 사용자가 그것을 직접 말한 적이 없더라도 그렇다.
+ * 다른 실제 사람의 속성은 절대 여기에 넣지 마라. John(`name`이 붙은
+ assistant 역할 메시지)이 "나는 베를린에서 간호사로 일해"라고 말하면, 그것은 `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` (모든 memory에 필수) = `"user"` 또는 `"agent"`
+ (위의 "# OWNER" 참조, 확신이 없으면 기본값 `"user"`)
+* `basic_info` = **사용자 본인의 프로필만**. NEW 사용자 메시지에서 **명시적으로
+ 언급된** 안정적인 프로필 필드(예: 이름, 나이, 거주지, 직업, 고용주)를 포함하라.
+ 절대 추론하지 말고, 절대 지어내지 마라. 명시적으로 언급된 필드가 없으면
+ `{{}}`를 출력하라.
+ * 엄격한 규칙: 사용자가 `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"는 `name`의 권위 있는
+ 출처다 — 사용자가 그것을 직접 말한 적이 없더라도 그렇다.
+ * 다른 실제 사람의 속성은 절대 여기에 넣지 마라. John(`name`이 붙은
+ assistant 역할 메시지)이 "나는 베를린에서 간호사로 일해"라고 말하면, 그것은 `memory`
+ ("John은 베를린의 간호사다.")이지 `basic_info.occupation` / `.location`이 아니다.
+* 섹션 간에 정보를 중복하지 마라
+* 태그: 간결한 키워드 1–3개. 주제 태그는 소문자, 고유명사는 대소문자 유지
+* 추출된 것이 없으면 빈 배열 `[]` 또는 `{{}}`를 사용하라
+* 유효한 JSON만 반환하라 — `intentions` 키는 **절대** 포함하지 마라
+
+이제 JSON을 출력하라."""
+
+
+# ================================================================
+# Chat reconcile (agent/reconciler.py)
+# ================================================================
+
+SEARCH_QUERY_PROMPT = """너는 검색 쿼리 생성기다. 새로 추출된 기억 목록이 주어지면, 벡터 데이터베이스에서 관련된 기존 기억을 찾는 데 쓸 수 있는 짧은 검색 쿼리 세트를 생성하라.
+
+목표는 재현율을 최대화하는 것이다 — 표현이 크게 다르더라도 새 기억과 의미적으로 관련된 기존 기억을 찾아라.
+
+## 새 기억:
+{new_memories}
+
+## 지침
+
+다음을 포괄하는 검색 쿼리를 생성하라.
+- 기억에 언급된 핵심 주제, 개체, 테마
+- 핵심 개념을 바꿔 말하거나 추상화한 버전
+- 사용자의 기억 저장소에 있을 수 있는 관련 개념
+
+쿼리 문자열의 JSON 배열을 출력하라(5-15개, 짧고 초점이 분명하게):
+
+["query1", "query2", "query3", ...]
+
+JSON 배열만 출력하고, 다른 텍스트는 출력하지 마라."""
+
+RECONCILE_PROMPT = """너는 기억 관리 시스템이다.
+
+너의 임무는 새 기억을 기존 기억 베이스에 병합하면서 기억 베이스를 다음 상태로 유지하는 것이다.
+
+* 손실 없음
+* 모순 없음
+* 간결함
+* 높은 검색성
+
+---
+
+# 작업 유형
+
+## ADD
+
+정보가 완전히 새로울 때 사용한다.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## UPDATE
+
+다음 경우에 사용한다.
+
+* 새 기억이 기존 기억과 양립한다
+* 둘이 같은 주제를 다룬다
+* 병합하면 완전성이나 검색성이 좋아진다
+
+규칙:
+
+* 손실 없이 병합하라
+* 유용한 정보를 모두 보존하라
+* 중복을 만들지 마라
+* 둘의 값이 서로 다르면 `memory_at`이 더 늦은 기억의 값을 유지하라.
+ 더 오래된 기억이 더 새로운 값을 덮어쓰게 해서는 절대 안 된다
+
+### 같은 발생 vs. 다른 발생
+
+새 기억이 이미 기록된 같은 실제 발생이나 오래 유지되는 사실에 세부 사항을 더할
+때만 **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_id` 대신 `memory_ids`
+(가장 오래된 것 → 가장 새로운 것 순서의 목록)를 사용하라.
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_ids": ["<oldest_id>", "<newer_id>"],
+ "content": "<가장 새로운 상태만>",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+나열된 기억들은 오래된 것 → 새로운 것 순으로 체인이 되고, 새 기억이 체인의
+머리(head)가 된다. `content`는 여전히 가장 새로운 상태만 기술한다 — 이전 기억들의
+텍스트를 절대 복사해 넣지 마라. 그것들은 체인 이력에서 계속 검색할 수 있다.
+
+---
+
+# 규칙
+
+* 의미 있는 정보를 모두 보존하라.
+* 완전히 동일한 중복은 건너뛰어라.
+* 관련된 조각은 병합하는 쪽을 우선하라.
+* 날짜가 다른 별개의 발생은 별도의 ADD로 유지하라. `same_series`는 같은 주체이고
+ 같은 구체적 활동/사건 유형일 때만 사용하라.
+* 각 기억은 하나의 일관된 주제에 집중하게 하라.
+* 아래 "시간 순서"를 따르라.
+* **서로 다른 주체 사이에서는 절대 병합하거나 대체하지 마라.** 주체는 content가
+ 다루는 대상이다: "사용자는 ..." vs "John은 ..." vs "Mary는 ...". 다른 사람에 대한
+ 기억은 문장이 그 외에는 똑같더라도 독립된 사실이다 — "사용자는 커피를 좋아한다"와
+ "John은 커피를 좋아한다"는 별개의 두 기억이며, 절대 서로의 UPDATE나 SUPERSEDE가
+ 아니다.
+* `owner` (`user`/`agent`): 쓰고 있는 기억에서 그대로 복사하라. 서로 다른 owner 사이에서는 절대 병합하거나 대체하지 마라 — 같은 주제라도 사용자의 사실과 어시스턴트의 사실은 별개다.
+* SUPERSEDE는 하나의 기억(`memory_id`)을 대상으로 하거나, 같은 차원의 여러 기억을 하나의 체인으로 접는다(`memory_ids`, 오래된 것→새로운 것). UPDATE는 정확히 하나의 기억만 대상으로 한다.
+* 같은 기존 기억을 둘 이상의 op에서 건드리지 마라.
+* 출력 언어는 입력 기억의 언어와 일치시켜라.
+
+---
+
+# 시간 순서
+
+새 기억이든 기존 기억이든 모든 기억에는 `memory_at`, 즉 그 일이 일어난 시점이 있다.
+기억이 항상 일어난 순서대로 쓰이는 것은 아니다 — 이력이 늦게 가져와질 수도 있고,
+더 오래된 이력이 아직 처리되는 중에 기억이 추가될 수도 있다. 따라서 새 기억이
+기존 기억보다 더 오래된 것일 수 있다.
+
+* 어느 기억이 더 새로운지는 오직 `memory_at`으로만 판단하라. "새 기억"은 "지금
+ 쓰이고 있는 것"을 뜻하지 "더 최근의 것"을 뜻하지 않는다.
+* 더 오래된 기억이 더 새로운 기억을 대체해서는 절대 안 된다: 더 새로운 기억을
+ SUPERSEDE하지 말고, 더 새로운 값을 더 오래된 값으로 덮어쓰는 UPDATE도 하지 마라.
+* 새 기억이 충돌하는 기존 기억보다 오래된 것이라면, 기존 기억을 현재 상태로 유지하라.
+ 새 기억은 과거 상태로서 그 시점과 함께 과거형으로 써서 ADD하거나(예: "2023년에
+ 사용자는 상하이에 살았다"), 추가되는 정보가 없으면 아무것도 출력하지 마라.
+* `memory_at: null`은 시간을 알 수 없다는 뜻이다. 알 수 없음은 더 새로운 것이 아니다:
+ `memory_at`이 알려진 기억을 `memory_at`이 null인 기억으로 절대 SUPERSEDE하지 마라.
+* 시간 순서를 지어내지 마라.
+
+---
+
+# 선택 사항: `related`
+
+어떤 op에든 `related` 배열을 추가하여, 쓰고 있는 기억이 기존 기억과 어떻게
+관련되는지 기록할 수 있다. 이것은 저장되는 내용을 바꾸지 않으며 — 연결만 기록한다.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."],
+ "related": [{{"memory_id": "<existing_id>", "relation": "causes"}}]
+}}
+```
+
+허용되는 관계는 다음 네 가지뿐이다.
+
+* `causes` — 두 기억이 원인/결과 관계에 있다
+ (예: "매일 달리기를 시작했다" → "무릎이 아프기 시작했다")
+* `elaborates` — 기존 기억에 세부 사항을 더하거나, 그 이후의 전개다
+* `contrasts` — 서로 긴장 관계에 있지만 둘 다 여전히 참이다(한쪽이 다른 쪽을
+ 거짓으로 만든다면 그것은 `contrasts` 연결이 아니라 SUPERSEDE다)
+* `same_series` — 같은 주체의 같은 구체적 활동 또는 사건 유형에 대한, 날짜가 다른
+ 별개의 발생(예: 서로 다른 두 번의 스키 여행)
+
+규칙:
+
+* "Existing memories"에 나타난 기억에만 연결하라 — id를 절대 지어내지 마라.
+* 관계가 **명시적이고 구체적일 때만** 연결을 출력하라. 두 기억이 단지 같은 넓은
+ 주제를 다룬다는 것은 관계가 아니다 — `related`를 빼라.
+* `same_series`에는 같은 주체와 구체적으로 반복된 행동/사건이 필요하다.
+ health, travel, sport, food, work 같은 넓은 태그를 공유하는 것만으로는 부족하다.
+* 연결할 것이 없으면 필드를 완전히 생략하라. 연결이 0개인 것이 보통이다.
+* `related`를 UPDATE / SUPERSEDE의 대용으로 절대 쓰지 마라.
+
+---
+{few_shot_section}
+###################
+입력 데이터
+###################
+
+Current date: {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 memory에 의미적으로 동등한
+주체별 경로가 이미 있다면, 동의어 분기를 만들지 말고 그 노드 이름과 타입을 그대로
+재사용하라. 정확한 재사용을 요청하려면
+`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
+"through":"topic|facet|series|episode"}]`를 출력하라. 참조된 ID는 Existing
+memories에 나타나야 한다. `through`는 기존 경로의 접두부를 지정된 구조 타입까지
+복사한다는 뜻이며, 명시적으로 작성한 더 깊은 접미부는 새것으로 남는다. 주체, 구체적
+활동/상태 계열, 또는 Episode 경계가 다르면 재사용은 금지된다. 이 필드들은 기억을
+기술하는 것이지, "언제", "몇 번", "누가" 같은 미래의 질의 형식을 기술하는 것이 절대
+아니다.
+
+Series는 reconcile 시점의 관계다: 새 기억과 적어도 하나의 독립적인 Existing memory가
+같은 구체적 활동/상태 계열의 서로 다른 발생일 때만 확립하라. 현재 쓰기에서 나온 여러
+명제는 반복을 증명하지 않는다.
+"""
+
+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). 하나의 기억을 부분별로 알맞은 op로 나눠라 — 새 머리는 고용 상태만 기술하며, 도예는 절대 넣지 않는다.
+
+## 예시 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": "사용자는 이제 동네 오픈마이크 무대에서 기타 공연을 한다.", "owner": "user"}
+]
+
+출력:
+```json
+[
+ {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "사용자는 동네 오픈마이크 무대에서 기타 공연을 한다.", "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"]}
+]
+```
+새 기억은 c1을 SUPERSEDE하고 체인 머리가 된다. 머리의 `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다 — d1이 사용자에 대해 거의 같은 말을 하더라도 절대 d1의 UPDATE나 SUPERSEDE가 아니다. 주체가 마찬가지로 "사용자"인 기억만 d1과 병합할 수 있다.
+
+## 예시 5 — 반복되는 사건: 횟수를 올리고 타임라인을 유지한다 (ADD가 아니라 UPDATE)
+
+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한다. **횟수**를 명시하고, 알려진 경우 시점과 함께 발생을 나열하라. 두 번째 "John은 발목을 다쳤다" 사실을 ADD하지 말고, SUPERSEDE도 하지 마라(첫 번째 부상이 사실이 아니게 된 것은 아니다).
+"""
+
+
+# ================================================================
+# Working / coding memory (coding/)
+# ================================================================
+
+CODING_EXTRACT_PROMPT = """\
+너는 작업 실행 세션 구간에서 오래 유지되는 WORKING 기억을 추출한다.
+"working" 세션이란 사용자가 도구를 통해 컴퓨터/시스템을 직접 조작하는 모든 실무
+작업을 말한다 — 소프트웨어/코드 작업(작성, 디버깅, 리팩터링, 빌드, 배포,
+API/라이브러리 사용)과 시스템·운영 작업(shell/PowerShell 명령 실행, 디스크/스토리지
+분석 또는 정리, 파일·폴더 작업, 소프트웨어 설치/설정, 환경/장치 설정, 하드웨어/디스크
+상태 점검, 백업, 스케줄링/자동화, 데이터 처리)을 모두 포함한다.
+
+같은 구간에서 두 개의 계층을 만든다.
+
+ EXPERIENCES (절차적, "어떻게 하는가") — 재사용 가능한 방법으로, 아래의
+ 가치 기준(VALUE BAR)을 통과할 때만 추출한다. (task, search_keys, solution,
+ boundary_envs) 묶음이다.
+
+ FACT (일화적, "이번에 무슨 일이 있었는가") — 이 세션에 대한 정확히 하나의
+ 기록: 사용자가 무엇을 원했고, 어떻게 진행했으며, 결과가 어떻게 되었는가. 가치
+ 기준은 없지만, 절대 하나를 넘지 않는다.
+
+두 계층은 서로 다른 질문에 답하며 따로 저장된다. 일반화되는 방법은 EXPERIENCES에
+넣고, 이 특정 세션의 이야기 — 이 시스템 / 이 프로젝트 / 지금에만 해당하는 것 — 는
+FACT에 넣는다.
+
+═══════════════════════════════════════════════════════════════════
+가치 기준 (EXPERIENCES 전용) — 가볍게 넘기지 마라.
+═══════════════════════════════════════════════════════════════════
+기억은 다음을 모두 만족해야 한다.
+ (a) 같은 사용자에게 다시 발생할 가능성이 높은 문제를 해결한다
+ (b) 해결책이 사소하지 않다: 여러 정보/단계를 결합하거나, 결정 근거를 담고
+ 있거나, 어렵게 얻은 우회책을 담고 있거나, 운영 작업을 위한 재사용 가능한
+ 절차/레시피다(예: 디스크 사용량을 분석하고 정리하는 방법, 파일을 일괄 정리하는
+ 방법, 하드웨어 상태를 점검하는 방법, 예약 작업을 설정하는 방법)
+ (c) 미래의 agent / 사용자가 다시 알아내기보다 찾아보는 쪽을 택할 것이다
+
+중요 — 분석 / 진단 / 조사 작업도 해당한다:
+작업이 무언가를 변경하거나 "고쳐야만" 기억할 가치가 있는 것은 아니다.
+읽기 전용 / 분석 / 문제 해결 작업도 그 절차나 결론이 재사용 가능하면
+가치가 있다. 다음을 명시적으로 추출하라.
+ - 분석 / 진단 레시피: 재사용 가능한 절차 + 그것이 밝혀낸 것
+ (예: "C 드라이브 공간을 차지하는 폴더를 분석하는 방법" — 스캔 명령, 마주친
+ 함정, 그리고 발견 사항). "보고서만 나왔고 변경은 없었다"는 건너뛸 이유가
+ 아니다 — 재사용 가능한 방법 자체가 기억이다.
+ - 조사 결과, 부정적 / 찾지 못한 결과 포함
+ (예: "rg / fs_search / SQL 인덱스로 C:와 D: 전체에서 폴더 X를 찾았으나 —
+ 어디에도 없었다"). 기록된 막다른 길은 다음 agent가 같은 헛수고를 반복하지 않게
+ 해 주므로 기준을 통과한다.
+"어시스턴트가 명령을 다시 만들어 낼 수 있다"거나 "실제로 수정된 것이 없다"는
+이유만으로 기억을 거부하지 마라. 절차나 결론이 앞으로의 수고를 덜어 준다면 남겨라.
+
+다음은 추출하지 마라.
+ - 재사용 가능한 절차가 없는 정말 사소한 단일 단계 작업("파일 하나 이름 바꾸기",
+ "git status", "ls 한 번 실행")
+ - 이미 해결되었고 옮겨 쓸 교훈이 없는 일회성 문제
+ - 이미 저장소/시스템에 있는 정보(package.json을 중복하지 마라)
+ - 재사용 가능한 패턴을 담지 않은 PR별 / 세션별 일회성 작업
+ - 누락된 정보를 사용자에게 묻는 행위. 매개변수를 요청하거나, 모르는 것을
+ 나열하거나, 필수 필드를 이끌어 내는 것은 대화 행동이지 방법이 아니다: 모든
+ agent는 이미 질문하는 법을 알고 있으므로 나중에 찾아볼 것이 없다. task나
+ search_keys가 "X를 묻는 방법", "누락된 Y 수집하기", "필수 필드 이끌어 내기",
+ "시작 전에 확인할 것" 같은 모양인 experience는 절대 출력하지 마라. 이것은
+ EXPERIENCES에서만 제외된다는 점에 유의하라 — 세션이 사용자를 기다리며 끝났다는
+ 것은 실제 상태이며 FACT에 속한다.
+
+구간이 사용자를 기다리며 멈춰서 실질적인 진전이 없었다면 — 어시스턴트가 매개변수만
+물었거나, 실제 작업을 하기 전에 막혔다면 — "experiences": []를 출력하고 FACT만
+써라. 아직 배운 것이 없으므로 저장할 방법도 없다. 이것은 보기보다 중요하다:
+멈춘 상태에서 증류한 experience는 검색 시 정당한 기술처럼 읽히고, 같은 작업의 이후
+구간이 그것과 매칭되어 진행하는 대신 사용자에게 다시 묻게 되므로, 그 멈춤이 세션의
+나머지 동안 스스로 재생산된다. 실질성은 턴이 매끄러운 텍스트를 만들었는지가 아니라
+도구가 실제로 무엇을 했는지로 판단하라.
+
+경험칙: 사용자(또는 같은 종류의 작업을 하는 미래의 agent)가 다시 알아내기보다 이것이
+적혀 있기를 원할 것이라면, 남겨라. 여러 단계의 운영 절차(코드뿐 아니라 시스템/운영
+또는 읽기 전용 분석/검색 절차라도)는 보통 해당한다. 어떤 사용자라도 `--help`로
+30초 안에 찾을 수 있는 단일 명령이면서 기억할 만한 결정/함정이 없는 경우에만 버려라.
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE 필드
+═══════════════════════════════════════════════════════════════════
+
+task — 질의 형태의 이름. 사용자가 나중에 어떻게 물을지로 표현하라.
+ "publish_release_internal"이 아니라
+ "xx 플랫폼에 릴리스 배포하기"
+ 그 자체로 완결되게("이것", "그 파일", "우리" 금지).
+
+search_keys — `task`만으로는 매칭되지 않을 solution의 중요한 측면을 담은
+ 0~5개의 대체 표현. 미래의 사용자가 물어볼 질문이나 주제로
+ 표현하라. task와 달라야 한다.
+ task가 이미 모든 것을 포괄하면 생략하라.
+
+solution — 사용자가 실제로 필요로 하는, 완전하고 그 자체로 완결된 내용:
+ 명령, 자격 증명의 위치(자격 증명 값은 안 됨),
+ 파일 경로, 순서가 있는 단계, 함정, 결정 근거.
+ 여러 턴에 걸친 처음부터 끝까지의 작업이 하나의 일관된 작업을
+ 이루면 하나의 solution으로 모아라. 사용자가 서로 무관한 작업을
+ 했을 때만 여러 기억으로 나눠라.
+
+boundary_envs — solution이 의존하는 구체적인 고정 조건, 여러 줄의 "key: value":
+ 런타임 / SDK / 라이브러리 + 버전
+ API 엔드포인트 또는 메서드 시그니처
+ 외부 서비스 / 미들웨어 버전
+ 환경 변수 이름(값은 안 됨)
+ 설정 파일 경로
+ 호스트 / 클러스터 / 리전 식별자
+ solution이 환경과 무관하면 ""(빈 값)로 두어라.
+ 목적: 기반 SDK/미들웨어가 업그레이드될 때, 미래의 소비자가 이것을
+ 보고 solution이 여전히 적용되는지 판단할 수 있게 한다.
+
+confidence — 0.0 ~ 1.0
+ 1.0 사용자가 이것을 규칙 / 지시로 명시했다
+ 0.7 도구 동작으로부터 충분한 근거를 가지고 추론했다
+ 0.5 약하게 추론했다; 관찰 한 번; 불확실하다
+
+═══════════════════════════════════════════════════════════════════
+FACT 필드 — 구간당 정확히 하나, 가치 기준 없음
+═══════════════════════════════════════════════════════════════════
+
+구간 전체에 대해 하나의 fact를 쓴다 — 이 세션의 복구 가능한 상태 기록이며,
+다듬어진 회고가 아니고, 별개의 발견 사항 목록은 더더욱 아니다. 미래의 agent가
+제안, 추론, 부분적인 검색을 검증된 것으로 오인하지 않고 이것으로부터 이어서 진행할
+수 있어야 한다.
+
+subject — 이 세션이 누구 또는 무엇에 관한 것인가: 작업이 수행된 대상 또는
+ 작업의 수혜자인 단일 개체. 짧은 명사구 하나, 문장 금지, 동사 금지.
+ 세션이 사용한 도구가 아니라 세션이 *다루는* 가장 구체적인 개체를
+ 골라라:
+ 세션이 이름 있는 한 사람을 위한 것이면 그 사람의 이름
+ ("Dylan", "Matthew")
+ 작업이 코드를 대상으로 하면 파일 / 모듈 / 심볼
+ ("auth/middleware.ts", "parse_plan_text")
+ 운영 작업이면 서비스 / 호스트 / 장치 / 드라이브
+ ("D:\\WXWork", "redis-cache-prod", "ci.yml")
+ 이것은 서술이 아니라 엄격한 키다: 서로 다른 사람이나 서로 다른 파일에
+ 관한 두 세션은 반드시 다른 subject를 가져야 하고, 같은 대상에 관한 두
+ 세션은 반드시 같은 문자열을, 철자까지 똑같이 가져야 한다.
+ 그것에 대한 설명보다 트레이스에 나타난 정확한 식별자를 우선하라.
+ 구간에 정말로 단일 subject가 없다면 ""를 출력하라.
+
+ 중요한 이유: subject는 이후 세션이 이 세션을 "같은 작업의 계속"으로
+ 보고 덮어써도 되는지를 결정하는 관문이다. 잘못 쓰면 한 사람의 상태가
+ 조용히 다른 사람의 상태를 대체한다.
+
+statement — 이 세션의 간결한 기록. 두 부분으로 되어 있으며, 잃어버리기 쉬운 것은
+ 두 번째 부분이다.
+ 작업 범위의 주어진 값과 구체적 제약을 결과에 대한 일반적인 평가로
+ 바꾸지 말고 보존하라. 각 규칙은 한 번만 말하라: 반복된 지시문은 기억이
+ 담아야 할 데이터와 자리를 다툰다.
+
+ PART 1 — 무슨 일이 있었는가, 라틴 문자 약 300자(CJK/한글 약 150자).
+ 일반적인 "버그 수정" / "파일 찾기"가 아니라 구체적인 목표와 대상으로
+ 시작하라("D:\\WXWork가 차지한 디스크 공간 회수", "new_file_search
+ 폴더 위치 찾기"). 그다음 대략 무엇을 살펴보고, 시도하고, 변경했는지.
+ 그다음 어떻게 끝났는지를, 다음 중 정확히 하나의 의미로 써라:
+ 완료, 부분 완료, 실패, 차단됨, 또는
+ 아직 검증 대기 중. 부정적 결과와 막다른 길도 과장하지 말고 포함하라.
+
+ PART 2 — 작업 범위의 주어진 값(TASK-SCOPED GIVENS): 작업 전체가 기반으로
+ 삼는 모든 것. 이 구간에서 확립한 것이 아니더라도, 너무 기초적이라 말할
+ 필요가 없다고 느껴지더라도 포함하라. 바인딩(각 이름/심볼/라벨이 무엇을
+ 가리키는지), 작업이 도출하는 것이 아니라 제공하는 고정값, 채택된
+ 관례(인덱스 시작값, 단위, 시간대, 기본값), 그리고 이 구간 자체의 결과와
+ 그 값("값을 계산했다"가 아니라 "x = 7").
+
+ PART 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에 실어라. "위와 같음"이나 "이전 세션과 같음"이라고
+ 절대 쓰지 마라 — 검색은 유사도로 소수의 fact만 돌려주므로 참조 대상이
+ 그 안에 없을 수 있다.
+
+ 전체 1200자 이내를 목표로 하라. PART 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 있음: {workspace_present}
+- branch 있음: {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 = """\
+╔═══════════════════════════════════════════════════════════════════════════╗
+║ 강한 제약 — 다른 무엇보다 먼저 읽어라. 이 프롬프트 뒤쪽에서 서술형을 ║
+║ 원하는 것처럼 들리는 표현이 있어도 이 제약이 우선한다. ║
+║ ║
+║ 너는 어떤 사람이 무엇을 했는지에 대한 보고서를 쓰는 것이 아니다. 너는 ║
+║ 미래의 AGENT가 행동하기 위해 필요한 것을 쓴다. 그 agent는 이미 자기 작업이 ║
+║ 있고, 이 사용자가 무엇을 원했는지에는 관심이 없다. 그 agent가 알아야 하는 ║
+║ 것은: 여기서 무엇이 결정되었고, 어느 코드 좌표에서였고, 무엇이 시도되어 ║
+║ 기각되었고, 그것이 검증되었는지다. ║
+║ ║
+║ 구체적으로, 모든 `statement`와 모든 `solution`에서: ║
+║ · 문장의 주어는 코드 또는 결정이다 — 절대 "사용자"도 "agent"도 아니다. ║
+║ "사용자가 ~를 시도했다", "사용자가 ~를 원했다", "agent가 그다음 ║
+║ ~를 확인했다"라고 쓰지 마라. ║
+║ · "세션이 완료되었다", "오류를 기록했다", "아직 해결책을 찾지 못했다" ║
+║ 같은 사무적인 문구로 끝내지 마라. 결정과 그 검증 상태로 끝내라. ║
+║ 결정된 것이 없다면, 무엇이 배제되었는지와 아직 탐색되지 않은 다음 ║
+║ 단서로 끝내라 — 그것이 재사용 가능한 부분이다. ║
+║ · 구체적인 증상(오류 문자열, 실패한 명령, 잘못된 출력)을 유지하라 — ║
+║ 미래의 검색이 매칭하는 대상이 그것이다. ║
+║ ║
+║ 나쁨: "사용자가 header_rows로 QTable을 RST로 쓰려다 TypeError를 만났다. ║
+║ 세션은 오류를 기록한 상태로 완료되었다." ║
+║ 좋음: "ascii.rst의 RST writer는 header_rows를 거부한다: `tbl.write(..., \\ ║
+║ format='ascii.rst', header_rows=['name','unit'])`는 RST.__init__이 ║
+║ 그것을 전달하지 않기 때문에 TypeError를 일으킨다. 이를 받아들이는 ║
+║ ascii.fixed_width와 다르다. 수정은 작성되지 않음 — writer에 ║
+║ fixed_width와 같은 header_rows 배선이 필요하다." ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+
+너는 작업 실행 세션 구간에서 오래 유지되는 WORKING 기억을 추출한다.
+"working" 세션이란 사용자가 도구를 통해 컴퓨터/시스템을 직접 조작하는 모든 실무
+작업을 말한다 — 소프트웨어/코드 작업(작성, 디버깅, 리팩터링, 빌드, 배포,
+API/라이브러리 사용)과 시스템·운영 작업(shell/PowerShell 명령 실행, 디스크/스토리지
+분석 또는 정리, 파일·폴더 작업, 소프트웨어 설치/설정, 환경/장치 설정, 하드웨어/디스크
+상태 점검, 백업, 스케줄링/자동화, 데이터 처리)을 모두 포함한다.
+
+같은 구간에서 두 개의 계층을 만든다.
+
+ EXPERIENCES (절차적, "어떻게 하는가") — 재사용 가능한 방법으로, 아래의
+ 가치 기준(VALUE BAR)을 통과할 때만 추출한다. (task, search_keys, solution,
+ boundary_envs) 묶음이다.
+
+ FACT (일화적, "이번에 무엇이 확립되었는가") — 이 세션에 대한 정확히 하나의
+ 기록. 사용자가 무엇을 했는지에 대한 서술이 아니다. 다음 순서로 기록한다:
+ 작업과 그 구체적인 증상(이것이 나중에 찾을 수 있게 만든다), 코드 좌표,
+ 무엇으로 결정되었고 무엇이 기각되었는지, 그리고 어디까지 검증되었는지.
+ 가치 기준은 없지만, 절대 하나를 넘지 않는다.
+
+두 계층은 서로 다른 질문에 답하며 따로 저장된다. 일반화되는 방법은 EXPERIENCES에
+넣고, 이 특정 세션의 이야기 — 이 시스템 / 이 프로젝트 / 지금에만 해당하는 것 — 는
+FACT에 넣는다.
+
+═══════════════════════════════════════════════════════════════════
+가치 기준 (EXPERIENCES 전용) — 가볍게 넘기지 마라.
+═══════════════════════════════════════════════════════════════════
+기억은 다음을 모두 만족해야 한다.
+ (a) 같은 사용자에게 다시 발생할 가능성이 높은 문제를 해결한다
+ (b) 해결책이 사소하지 않다: 여러 정보/단계를 결합하거나, 결정 근거를 담고
+ 있거나, 어렵게 얻은 우회책을 담고 있거나, 운영 작업을 위한 재사용 가능한
+ 절차/레시피다(예: 디스크 사용량을 분석하고 정리하는 방법, 파일을 일괄 정리하는
+ 방법, 하드웨어 상태를 점검하는 방법, 예약 작업을 설정하는 방법)
+ (c) 미래의 agent / 사용자가 다시 알아내기보다 찾아보는 쪽을 택할 것이다
+
+중요 — 분석 / 진단 / 조사 작업도 해당한다:
+작업이 무언가를 변경하거나 "고쳐야만" 기억할 가치가 있는 것은 아니다.
+읽기 전용 / 분석 / 문제 해결 작업도 그 절차나 결론이 재사용 가능하면
+가치가 있다. 다음을 명시적으로 추출하라.
+ - 분석 / 진단 레시피: 재사용 가능한 절차 + 그것이 밝혀낸 것
+ (예: "C 드라이브 공간을 차지하는 폴더를 분석하는 방법" — 스캔 명령, 마주친
+ 함정, 그리고 발견 사항). "보고서만 나왔고 변경은 없었다"는 건너뛸 이유가
+ 아니다 — 재사용 가능한 방법 자체가 기억이다.
+ - 조사 결과, 부정적 / 찾지 못한 결과 포함
+ (예: "rg / fs_search / SQL 인덱스로 C:와 D: 전체에서 폴더 X를 찾았으나 —
+ 어디에도 없었다"). 기록된 막다른 길은 다음 agent가 같은 헛수고를 반복하지 않게
+ 해 주므로 기준을 통과한다.
+"어시스턴트가 명령을 다시 만들어 낼 수 있다"거나 "실제로 수정된 것이 없다"는
+이유만으로 기억을 거부하지 마라. 절차나 결론이 앞으로의 수고를 덜어 준다면 남겨라.
+
+다음은 추출하지 마라.
+ - 재사용 가능한 절차가 없는 정말 사소한 단일 단계 작업("파일 하나 이름 바꾸기",
+ "git status", "ls 한 번 실행")
+ - 이미 해결되었고 옮겨 쓸 교훈이 없는 일회성 문제
+ - 이미 저장소/시스템에 있는 정보(package.json을 중복하지 마라)
+ - 재사용 가능한 패턴을 담지 않은 PR별 / 세션별 일회성 작업
+
+경험칙: 사용자(또는 같은 종류의 작업을 하는 미래의 agent)가 다시 알아내기보다 이것이
+적혀 있기를 원할 것이라면, 남겨라. 여러 단계의 운영 절차(코드뿐 아니라 시스템/운영
+또는 읽기 전용 분석/검색 절차라도)는 보통 해당한다. 어떤 사용자라도 `--help`로
+30초 안에 찾을 수 있는 단일 명령이면서 기억할 만한 결정/함정이 없는 경우에만 버려라.
+
+═══════════════════════════════════════════════════════════════════
+코드 작업 — 미래의 agent가 다시 도출할 수 없으므로 반드시 담아야 하는 것
+═══════════════════════════════════════════════════════════════════
+구간이 저장소에 대한 소프트웨어 작업이라면, 재사용 가능한 방법은 그 절반일 뿐이다.
+나머지 절반은 그 작업이 어디에 있고 어느 버전이 채택되었는지다. 그것들은 나중에
+코드를 읽어서는 복원할 수 없다 — 코드는 현재 상태를 보여 주지만, 그것이 어느
+브랜치에 있는지도, 이미 무엇이 기각되었는지도 보여 주지 않는다.
+
+이 절은 더 긴 기록을 요구하지 않는다. 같은 예산을 더 가치 있는 토큰에 쓰라고
+요구한다: 반복된 목표 서술, 어시스턴트가 "그다음 ~하기로 했다"는 식의 설명, 그저
+그대로 옮기는 코드 붙여넣기를 버리고, 그 글자 수를 아래 네 항목에 써라. 브랜치를
+빠뜨리면서 diff 30줄을 인용하는 기록은 나쁜 거래다.
+
+1. 브랜치 / 작업 위치 — fact `statement`에 그대로. 구간이 `feat/x` / `fix/y`를
+ 언급하거나 체크아웃했다면 그 토큰이 반드시 나타나야 한다. 잘못된 브랜치에서
+ 이어 가는 agent는 조용히 버려지는 변경을 만들어 내므로, 이 한 토큰이 다른 모든
+ 세부 사항보다 중요하다.
+
+2. 어느 버전이 채택되었는가 — 사용자가 마음을 바꿨다면, 채택된 것을 명시하고
+ 기각된 것을 한 절로 표시하라: "A로 결정; 중간안 B는 폐기". 둘 다 온전히 쓰지
+ 말고 — 한 절로. 최신 것만 남기는 것은 잘못이다: 기각된 코드를 만난 agent가
+ 그것을 알아보지 못하면 폐기된 변형으로 되돌리는 "수정"을 하게 된다.
+ `그건 취소하고 / 되돌리자 / 사실은 이렇게 / 아니, 그거 말고` 같은 표현이 이것을
+ 표시한다: 뒤에 오는 것이 기록 대상이고, 앞에 오는 것은 대체된 것이다.
+
+3. 붙여넣은 코드가 아니라 정확한 좌표 — 저장소 기준 상대 경로
+ (`qutebrowser/utils/debug.py`, 절대 그냥 `debug.py`가 아니다)와 손댄 함수 /
+ 클래스. 시그니처가 바뀌었다면 새 시그니처를 적어라. 상수, 정규식, 리터럴이
+ 결정되었다면 그것을 그대로 인용하라 — 다만 그것만 인용하고, 주변 블록은
+ 인용하지 마라. 정확한 한 줄이 대충 쓴 한 단락보다 낫다.
+
+4. 검증되었는가 vs. 그냥 작성되었는가 — 네 단어면 충분하다("테스트 실행, 통과" /
+ "git diff로만 확인, 테스트 미실행"). "수정이 들어갔다"와 "수정이 들어가고 테스트까지
+ 했다"는 미래의 agent가 다음에 할 일을 매우 다르게 만든다.
+
+안티패턴 — 목표만 요약하고 좌표를 빠뜨리기:
+ 나쁨: "색상 파싱 로직을 더 깔끔하게 리팩터링했다."
+ 좋음: "feat/q4에서 qutebrowser/config/configtypes.py의 QtColor._parse_value:
+ `mult = 360.0 if kind == 'h' else 255.0`로 결정; 모든 경우에 255.0을
+ 쓰던 중간안은 폐기. 테스트 미실행."
+ (좋은 예가 대부분의 나쁜 예보다 더 짧다 — 다만 모든 글자를 다시 도출할 수 없는
+ 것에 쓴다)
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE 필드
+═══════════════════════════════════════════════════════════════════
+
+task — 질의 형태의 이름. 사용자가 나중에 어떻게 물을지로 표현하라.
+ "publish_release_internal"이 아니라 "xx 플랫폼에 릴리스 배포하기"
+ 그 자체로 완결되게("이것", "그 파일", "우리" 금지).
+
+search_keys — `task`만으로는 매칭되지 않을 solution의 중요한 측면을 담은
+ 0~5개의 대체 표현. 미래의 사용자가 물어볼 질문이나 주제로
+ 표현하라. task와 달라야 한다.
+ task가 이미 모든 것을 포괄하면 생략하라.
+
+solution — 사용자가 실제로 필요로 하는, 완전하고 그 자체로 완결된 내용:
+ 명령, 자격 증명의 위치(자격 증명 값은 안 됨),
+ 파일 경로, 순서가 있는 단계, 함정, 결정 근거.
+ 여러 턴에 걸친 처음부터 끝까지의 작업이 하나의 일관된 작업을
+ 이루면 하나의 solution으로 모아라. 사용자가 서로 무관한 작업을
+ 했을 때만 여러 기억으로 나눠라.
+
+boundary_envs — solution이 의존하는 구체적인 고정 조건, 여러 줄의 "key: value":
+ 런타임 / SDK / 라이브러리 + 버전
+ API 엔드포인트 또는 메서드 시그니처
+ 외부 서비스 / 미들웨어 버전
+ 환경 변수 이름(값은 안 됨)
+ 설정 파일 경로
+ 호스트 / 클러스터 / 리전 식별자
+ solution이 환경과 무관하면 ""(빈 값)로 두어라.
+ 목적: 기반 SDK/미들웨어가 업그레이드될 때, 미래의 소비자가 이것을
+ 보고 solution이 여전히 적용되는지 판단할 수 있게 한다.
+
+confidence — 0.0 ~ 1.0
+ 1.0 사용자가 이것을 규칙 / 지시로 명시했다
+ 0.7 도구 동작으로부터 충분한 근거를 가지고 추론했다
+ 0.5 약하게 추론했다; 관찰 한 번; 불확실하다
+
+═══════════════════════════════════════════════════════════════════
+FACT 필드 — 구간당 정확히 하나, 가치 기준 없음
+═══════════════════════════════════════════════════════════════════
+
+구간 전체에 대해 하나의 fact를 쓴다 — 이 세션의 복구 가능한 상태 기록이며,
+다듬어진 회고가 아니고, 별개의 발견 사항 목록은 더더욱 아니다. 미래의 agent가
+제안, 추론, 부분적인 검색을 검증된 것으로 오인하지 않고 이것으로부터 이어서 진행할
+수 있어야 한다.
+
+statement — 이 세션의 간결한 요약. 두 가지 일을 동시에 하며, 둘 다 해내야 한다:
+ 검색 벡터(미래의 agent가 사용자가 문제를 표현하는 방식으로 쓴 새 이슈
+ 보고로 검색해 찾아낸다)이자, 그 agent가 그다음 행동의 근거로 삼는
+ 내용물이다. 그러므로:
+
+ 작업과 증상으로 시작하라. 사용자가 쓸 말로.
+ 이것이 찾을 수 있게 만든다 — 표면 형태를 문제가 보고되는 방식에
+ 가깝게 유지하라. 일반적인 "버그 수정" / "파일 찾기"가 아니라 구체적인
+ 목표와 대상을 명시하라("D:\\WXWork 아래 디스크 공간 회수",
+ "feat/q4에서 QtColor._parse_value의 hue 배수 조정", "new_file_search
+ 폴더 위치 찾기"). 구체적인 증상도 포함하라: 오류 문자열, 실패한
+ 명령, 잘못된 출력.
+
+ 그다음 좌표와 결정을 적어라.
+ 코드 작업이면 저장소 기준 상대 경로, 심볼, 브랜치. 무엇으로
+ 결정되었는지 명시하고, 같은 절에서 무엇이 폐기되었는지 표시하라
+ ("X로 결정; 중간안 Y는 폐기"). 이것이 코드를 읽어서는 다시 도출할 수
+ 없는 부분이다 — 코드는 채택된 것만 보여 주고, Y가 시도되어
+ 기각되었다는 사실은 결코 보여 주지 않는다. 나중에 기각된 변형을 만난
+ agent가 그것을 알아볼 수 있어야 하며, 그렇지 않으면 코드를 폐기된
+ 버전으로 되돌리는 "수정"을 하게 된다.
+
+ 증거 상태로 끝내라.
+ 다음 중 정확히 하나: 완료, 부분 완료, 실패, 차단됨, 또는
+ 아직 검증 대기 중 — 그리고 어떻게 확인했는지("테스트 실행, 통과" /
+ "git diff로만 확인, 테스트 미실행"). 부정적 결과와 막다른 길도
+ 과장하지 말고 포함하라.
+
+ ⚠️ 서술에서 멈추지 마라. "사용자가 X를 시도했고 오류 Y를 만났다. 아직
+ 해결책은 없다"는 낭비된 기록이다: 검색은 잘 되지만 미래의 agent에게
+ 행동할 근거를 주지 않는다. 세션이 정말로 어떤 결정에도 이르지 못했다면,
+ 무엇이 배제되었고 아직 탐색되지 않은 다음 단서가 무엇인지 말하라 —
+ 그것이 재사용 가능한 부분이다.
+
+ 문장의 주어는 "사용자"가 아니라 코드와 결정이어야 한다. 2~4문장,
+ 라벨 붙인 섹션이 아니라 흐르는 서술.
+ 상한은 라틴 문자 약 400자(CJK/한글 약 200자).
+
+ 증거 충실성 — 필수:
+ - 실제로 실행된 동작과 트레이스에 명시적으로 있는 증거만 기록하라.
+ 중요한 명령, 플래그, 인자, 오류, 숫자를 그대로 보존하라. 관례적인
+ 플래그로 명령을 절대 보충하지 말고, 조언/계획을 실행된 동작으로
+ 바꾸지 마라.
+ - 시도함, 관찰함, 검증함, 추론함, 미해결 사이의 구별을 보존하라.
+ 서술에 그런 라벨을 붙이지 말고, 그 의미를 자연스럽게 표현하라.
+ 예: "…를 시도했으나 Access denied로 막혔다" 또는
+ "… 로 의심되나 아직 검증되지 않았다".
+ - 도구 출력이나 명시적 확인 없이 수정이 성공했다거나, 원인이
+ 확립되었다거나, 파일/폴더가 존재하지 않는다거나, 테스트가
+ 통과했다고 절대 주장하지 마라.
+ - 모든 부정적 발견은 실제로 검색한 범위로 한정하고, 그것을 무효화할
+ 수 있는 명시적인 범위 제한을 모두 열거하라. 특히 권한 실패와 최대
+ 검색 깊이:
+ "C:\\와 D:\\의 검색된 범위 안에서는 찾지 못함; 일부
+ 디렉터리는 Access denied로 건너뛰었고, 검색에는 깊이 제한도
+ 있었다". 요약을 보기 좋게 하려고 제한 하나라도 빼지 마라.
+ 부분적인 검색을 전역적인 부재로 절대 격상하지 마라.
+ - 인과관계는 트레이스가 그것을 직접 검증할 때만 확실한 것으로
+ 진술하라. 그렇지 않으면 유보 표현을 유지하라("의심됨" / "추론됨" /
+ "아직 검증되지 않음"). 잘못된 테스트 가정을 시스템의 근본 원인으로
+ 다시 쓰지 마라.
+
+ 매우 중요 — 이 텍스트가 바로 검색 벡터이며, 미래의 질의가 매칭되는
+ 유일한 대상이다. 일반적인 요약은 쓸모없다. 모든 세션이 일반적인
+ 요약처럼 보이기 때문이다: 그것은 모든 질의에 매칭되면서 어느 질의에도
+ 답하지 못한다. 그러므로 이 세션을 찾을 수 있게 만드는 구체적인 닻을
+ 반드시 명시하라 — 실제 파일 경로, 함수 / 심볼 이름, 브랜치 이름, 명령,
+ 오류 문자열, 버전, 설정 키와 값, 호스트 / 서비스 이름.
+ 누군가 나중에 그중 어느 하나를 검색하면, 돌아와야 하는 것이 바로 이
+ 요약이어야 한다.
+ 좋음: "CI에서 실패하는 `npm run build` 수정.
+ .github/workflows/ci.yml과 package.json을 읽고, node 18에서
+ webpack 5.74가 ERR_OSSL_EVP_UNSUPPORTED를 일으키는 것으로
+ 추적. 워크플로의 node를 20으로 올리자 빌드 통과; node 18에서는
+ 로컬에서 여전히 재현됨."
+ 좋음: "feat/q0 브랜치, qutebrowser/utils/debug.py의 signal_name:
+ PyQt<5.11은 이름을 repr(sig)로만 노출하며, repr은 대괄호 형태와
+ 괄호 형태 두 가지로 온다. fullmatch로 두 패턴을 순서대로
+ 시도해 첫 매칭에서 중단하는 방식으로 결정; 단일 정규식 버전은
+ 폐기. git diff로 확인, 테스트 미실행."
+ 나쁨: "사용자가 빌드 버그 수정을 원했고, agent가 설정 파일 몇 개를
+ 보고, 코드를 조금 바꿔서 고쳤다."
+ (경로도, 명령도, 오류 문자열도, 버전도 없다 — 검색할 거리가
+ 전혀 없고, 모든 세션이 정확히 이렇게 읽힌다)
+ 나쁨: "기능 브랜치에서 signal-name 파싱 호환성 문제를 고쳤다."
+ (어느 브랜치? 어느 파일? 어느 함수? 경쟁하던 두 버전 중 어느
+ 것이 채택되었나? 일주일 뒤에 검색되어도 살아남는 것이 하나도
+ 없다)
+ 충실성 예시 (나쁨 → 좋음):
+ "ran Get-ChildItem -Force" → "ran Get-ChildItem"
+ (트레이스에 `-Force`가 없었다; 지어내지 마라)
+ "new_file_search가 존재하지 않음을 확인했다" →
+ "new_file_search는 C:\\와 D:\\의 검색된 범위 안에서는 찾지
+ 못했다; 일부 디렉터리는 Access denied 또는 깊이 제한으로
+ 건너뛰었으므로 조사는 일부만 끝난 상태다"
+ "동일한 페이로드가 잘못된 lock 오류를 일으킨다" →
+ "검증 스크립트는 마지막 writer가 항상 고정된 rank라고 가정했다.
+ 그 가정은 성립하지 않으므로, lock 버그가 있는지는 아직 검증되지
+ 않았다"
+
+ 인사나 순수한 잡담은 기록하지 마라. 구간이 아무것도 확립하지
+ 못했다면 "fact": null을 출력하라.
+
+files — 이 세션에서 실제로 조작하거나 조사한 0..N개의 절대 또는 저장소 기준
+ 상대 파일 또는 디렉터리 경로. `C:\\`와 `D:\\` 같은 조사한 루트도
+ 유지하라. 제안되거나 계획만 된 경로가 아니라 실제로 접근/검색한
+ 경로만 포함하라. 해당하는 것이 없으면 [].
+
+═══════════════════════════════════════════════════════════════════
+호스트 컨텍스트 (SDK가 제공)
+═══════════════════════════════════════════════════════════════════
+- workspace_id 있음: {workspace_present}
+- branch 있음: {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 op을 출력할 수 있다.
+ DELETE — 새 대화가 기존 기억을 명시적으로 대체/취소/무효화하며, UPDATE로는
+ 고칠 수 없는 경우. 예시:
+ * 사용자가 "앞으로 X는 쓰지 마"라고 말했고, X가 (추가/갱신되는 기억이
+ 아닌) 별개의 기억으로만 존재하는 경우
+ * 후보의 boundary_envs(서비스 / 엔드포인트 / SDK)가 사라졌고,
+ 새 대화가 그 폐기를 확인해 주는 경우
+
+규칙:
+- "같은 작업"이란 기존 기억과 새 초안이 미래의 같은 사용자 질의에 대해 둘 다
+ 유효한 답이 된다는 뜻이다.
+- solution이 다르면 UPDATE를 우선하라(이력은 유지하지 않는다).
+- task와 solution이 모두 거의 일치하면 SKIP.
+- DELETE는 후보가 무효/폐기되었다는 명시적 증거가 있을 때만 하라.
+ 후보가 "낡아 보인다"는 이유만으로 절대 DELETE하지 마라.
+- DELETE가 생기면 출력 op의 개수가 초안 개수보다 많을 수 있다.
+
+═══════════════════════════════════════════════════════════════════
+새 초안
+═══════════════════════════════════════════════════════════════════
+{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 = """\
+너는 세션 수준의 WORKING FACT를 관리한다. 각 statement는 하나의 트레이스/세션
+전체를 요약한다: 사용자의 작업, 대략적인 접근 방식, 그리고 결과. 이것은 원자적인
+주장이 아니다.
+
+아래의 모든 새 세션 fact는 저장될 것이며, 그것은 너의 결정 사항이 아니다. 너의
+유일한 임무는 작업의 연속성을 판별하는 것이다: 새 세션이 기존 세션 fact와 같은
+사용자 작업을 계속 진행하고 있는가? 그렇다면 더 오래된 fact를 SUPERSEDE하여,
+연결이 그 작업의 세션 간 진행 체인을 이루게 하라.
+
+기존 fact를 대체됨으로 표시하는 것은 다음에 대한 강한 증거가 있을 때만 하라.
+ - subject가 일치한다: 두 기록이 같은 개체 — 같은 사람, 같은 파일/모듈, 같은
+ 호스트/서비스 — 에 관한 것이다. subject가 같다는 것은 필요조건이지만
+ 충분조건은 아니다. 그리고
+ - 사용자 목표가 단지 같은 주제/프로젝트에 속하는 정도가 아니라 실질적으로
+ 같다. 그리고
+ - 새 트레이스가 기존 트레이스에 기록된 작업을 계속하거나, 재시도하거나,
+ 확장하거나, 검증하거나, 끝낸다.
+
+다음 경우에는 대체하지 마라.
+ - 두 기록이 서로 다른 subject를 가리킨다. 한 그룹의 두 사람, 한 모듈의 두 파일,
+ 한 클러스터의 두 호스트는 연속이 아니라 병렬이다: 한 사람의 상태가 다른 사람의
+ 더 새로운 버전이 아니다. subject가 (unspecified)로 표시된 경우에는 statement만
+ 으로 판단하라.
+ - 두 세션이 단지 같은 파일, 심볼, 컴포넌트, 저장소, 오류, 기술을 언급하지만
+ 서로 다른 사용자 목표를 추구한다.
+ - 한 작업이 다른 작업에 맥락이나 기법만 제공한다.
+ - 관계가 불확실하다. 보수적으로 판단하라: INSERT가 안전한 기본값이며, 무관한
+ 세션을 병합하면 각자의 작업 이력이 파괴된다.
+
+각 statement를 증거에 한정된 텍스트로 다루어라. 그 안의 추론을 확립된 원인으로
+재해석하지 말고, 공유된 추측이나 오류를 사용자 목표가 같다는 증거로 쓰지 마라.
+너의 판단은 오직 작업의 연속성에 관한 것이다. 어느 세션 기록도 "교정"하거나,
+보완하거나, 꾸미지 마라.
+
+예시:
+ 기존: "사용자는 CI의 npm run build를 고쳐야 했다. Node 18에서의
+ ERR_OSSL_EVP_UNSUPPORTED로 추적했고, 워크플로는 아직 변경되지 않았다."
+ 신규: "사용자는 같은 CI 수정을 계속했다. .github/workflows/ci.yml의 Node를
+ 20으로 올리자 npm run build가 통과했다."
+ → SUPERSEDE
+
+ 기존: "사용자는 auth/middleware.ts의 JWT 만료 처리를 고쳐야 했다.
+ refresh 로직이 추가되었다."
+ 신규: "사용자는 auth/middleware.ts에 성능 로깅을 추가해야 했다.
+ 지연 시간 지표가 도입되었다."
+ → 둘 다 유지
+ (같은 파일/프로젝트, 다른 사용자 목표)
+
+═══════════════════════════════════════════════════════════════════
+새 세션 FACT
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+기존 세션 FACT (새 fact별, statement 유사도로 검색됨)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+출력 (엄격한 JSON만, markdown 금지)
+═══════════════════════════════════════════════════════════════════
+{{
+ "ops": [
+ {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "같은 CI 수정 작업의 연속"}},
+ {{"draft_idx": 1, "supersedes": []}}
+ ]
+}}
+
+같은 draft_idx의 후보 목록에 나타난 fact id만 사용하라.
+어디에서도 대체가 일어나지 않으면 {{"ops": []}}를 출력하라.
+"""
+
+CODING_CHAIN_SUMMARY_PROMPT = """\
+working 기억 저장소의 한 사용자 작업이 여러 세션에 걸쳐 진행되었다. 아래는 그
+작업의 진행 체인에 있는 세션 요약들이며, 오래된 것이 먼저이고 마지막이 현재
+세션이다.
+
+같은 작업이 여러 세션에 걸쳐 현재 상태까지 어떻게 진행되었는지 요약하라.
+모든 중요한 단계를 시간순으로 다루어라. 각 단계마다 가능한 경우 다음을 보존하라:
+실제 동작 또는 변경, 그 직접적인 결과, 그리고 미해결 문제나 제약 조건.
+마지막에 현재 상태를 명시적으로 적어라.
+
+규칙:
+ - 이것은 압축일 뿐이다. 항목들이 말하는 것만 보고하라. 명령, 원인, 동기, 동작,
+ 테스트 결과, 성공 상태, 전역적인 부정 결론을 절대 추가하거나 보완하지 마라.
+ - 증거 상태를 정확히 보존하라: 시도함은 완료가 아니고, 관찰함은 검증이 아니며,
+ 추론함은 확립이 아니고, 미해결은 미해결로 남는다.
+ 불확실성을 나타내는 표현과 검색/권한/범위 제한을 유지하라.
+ - 현재의 종료 상태를 충실하게 진술하라(완료, 부분 완료, 실패, 차단됨, 또는
+ 아직 검증 대기 중). 그럴듯한 인과 설명이나 그것을 검증하지 않은 이후 항목에
+ 근거해 절대 상태를 격상하지 마라.
+ - 항목들이 의심되는 원인과 이후의 결과를 언급할 때, 어떤 항목이 그 원인이
+ 검증되었다고 직접 말하는 경우에만 인과적으로 연결하라.
+ - 구체적인 검색 닻을 보존하라: 파일 경로, 심볼, 명령, 오류 문자열, 버전,
+ 설정 키/값, 그리고 진행에 중요한 수치.
+ - 2–3세대 체인에서는 진행 과정을 한 문장으로 과도하게 압축하지 마라. 유용하다면
+ 간결한 2–4단락, 또는 분명한 작업 목표, 단계별 진행, 현재 상태를 담은 읽기 쉬운
+ 서술을 선호하라.
+ - 전체 이력을 기계적으로 복사하지 마라. 중요한 동작, 직접적인 결과, 남은 과제는
+ 유지하면서 반복과 가치 낮은 세부 사항은 생략하라.
+ - 단계 제목이나 날짜를 지어내지 마라. 항목들이 날짜를 의미 있게 만드는 경우에만
+ 날짜를 언급하라. 맥락 없는 타임스탬프는 잡음이다.
+ - 항목들이 더 오래된 수정 이력이 생략되었다고 말한다면, 이전 이력이 생략되었음을
+ 명시하라. 제공된 항목들이 전부인 것처럼 암시하지 마라.
+ - 항목들이 쓰인 것과 같은 언어로 써라.
+ - 머리말이나 전체를 감싸는 인용 부호 없이.
+
+예시
+ 항목:
+ (2026-07-20) 사용자는 CI의 npm run build를 고쳐야 했다. Node 18에서의
+ ERR_OSSL_EVP_UNSUPPORTED로 추적했고, 워크플로는 아직
+ 변경되지 않았다.
+ (2026-07-24) 사용자는 그 CI 수정을 계속했다. .github/workflows/ci.yml의
+ Node를 20으로 올렸지만, 의존성 캐시에서 이전 오류가 여전히
+ 재현되었다.
+ (현재) 사용자는 같은 수정을 계속 검증했다. npm 캐시를 지운 뒤
+ npm run build가 통과했다.
+ 출력:
+ 작업 목표는 CI의 npm run build를 고치는 것이다. 처음에는 Node 18에서의
+ ERR_OSSL_EVP_UNSUPPORTED로 추적되었고 워크플로는 아직 변경되지 않았다.
+ 이어서 .github/workflows/ci.yml을 Node 20으로 올렸지만 의존성 캐시 때문에
+ 이전 오류가 남아 있었다. 마지막으로 npm 캐시를 지운 뒤 npm run build가
+ 통과했으므로, 이 빌드 수정은 현재 완료된 것으로 검증되었다.
+
+═══════════════════════════════════════════════════════════════════
+항목
+═══════════════════════════════════════════════════════════════════
+{chain_block}
+
+═══════════════════════════════════════════════════════════════════
+출력 (요약 자체만, 그 외에는 아무것도 없이)
+═══════════════════════════════════════════════════════════════════
+"""
+
+
+# ================================================================
+# Episode / topic summaries
+# ================================================================
+
+EPISODE_SUMMARY_PROMPT = """너는 사용자와의 대화 중 하나의 에피소드를 요약하고 있다.
+
+에피소드란 하나로 이어지는 논의 구간이다 — 이야기된 하나의 대상이며, 여러 번의
+쓰기 세션에 걸쳐 있을 수도 있다.
+
+## 이 에피소드 동안 수집된 기억 (오래된 것 → 새로운 것)
+
+{memories}
+
+---
+
+이 에피소드에서 무슨 일이 있었는지 / 무엇이 논의되었는지를 밀도 높은 하나의 요약으로 써라.
+
+규칙:
+
+* 2–4문장, 3인칭, "사용자는 ..."으로 시작한다(기억이 다른 사람에 관한 것이면
+ 그 이름 있는 사람으로 시작한다).
+* 기억들을 하나의 일관된 서술로 엮어라 — 에피소드에는 보통 그것을 관통하는
+ 줄기가 있다(계획, 문제, 외출, 결정).
+* 구체적인 세부 사항을 보존하라: 이름, 장소, 숫자, 날짜.
+* 기억에 없는 것을 절대 지어내지 마라.
+* 기억을 하나씩 열거하지 마라. 종합하라.
+* 출력 언어는 기억의 언어와 일치해야 한다.
+
+요약 텍스트만 반환하라. 머리말, JSON, 인용 부호 없이."""
+
+TOPIC_SUMMARY_PROMPT = """너는 하나의 주제에 대해 알려진 모든 것을 요약하고 있다.
+
+## 주제
+
+{topic_name}
+
+## 이 주제에 속한 기억 (오래된 것 → 새로운 것)
+
+{memories}
+
+---
+
+이 주제와 관련하여 사용자에 대해 알려진 것을 밀도 높은 하나의 요약으로 써라.
+
+규칙:
+
+* 2–4문장, 3인칭, "사용자는 ..."으로 시작한다(기억이 다른 사람에 관한 것이면
+ 그 이름 있는 사람으로 시작한다).
+* 주제를 전체적으로 다루어라 — 현재 상황을 진술하고, 변화가 중요한 경우에만
+ 그것이 어떻게 전개되었는지 언급하라.
+* 구체적인 세부 사항을 보존하라: 이름, 장소, 숫자, 날짜.
+* 기억에 없는 것을 절대 지어내지 마라.
+* 기억을 하나씩 열거하지 마라. 종합하라.
+* 출력 언어는 기억의 언어와 일치해야 한다.
+
+요약 텍스트만 반환하라. 머리말, JSON, 인용 부호 없이."""
+
+
+# ================================================================
+# System 2 evolve (pipelines/system2_agent.py)
+# ================================================================
+
+SYSTEM2_AGENT_PROMPT = """너는 인지 처리 Agent다. 너의 임무는 사용자의 raw 기억 데이터로부터 상위 차원의 인지 구조를 진화시키는 것이다.
+
+## 기억 아키텍처
+
+### VDB (벡터 데이터베이스) — 읽기 전용
+| Layer | 설명 |
+|-------|-------------|
+| L0 BASIC_INFO | 사용자 속성(이름, 나이, 직업) |
+| L1 RAW | 원본 대화 기록 |
+| L2 FACT | 대화에서 추출된 원자적 사실 |
+| L3 SUMMARY | 세션 요약 |
+| L4 IDENTITY | 정체성 특성, 선호, 습관 |
+| L5 KNOWLEDGE | 도메인 지식 |
+
+### Graph (지식 그래프) — 너만이 쓰기를 한다
+| Layer | 설명 |
+|-------|-------------|
+| L6 SCHEMA | 행동 패턴 — 도메인에 묶이고, 원자적이며, 생성된 뒤에는 불변 |
+
+## L6 Schema란 무엇인가?
+
+Schema는 장기 사용자 모델 안의 하나의 사건 간(cross-event) 행동 패턴이며,
+다음 세 가지 구성 요소를 담는다.
+
+
+- **Circumstance**: 이 패턴이 관찰되는 도메인/주제/상황. Schema는 자신의 circumstance 안에 머물러야 한다 — 도메인을 넘어 일반화하지 마라. 도메인 간 추상화는 시스템이 따로 처리한다.
+- **Pattern**: 이 circumstance에서 나타나는 사용자의 습관적 행동, 사고 방식, 또는 행동 경향.
+- **Insight**: 그 바탕에 있는 심리적 동인 또는 정신 모형.
+
+### content 형식
+세 요소를 모두 결합한 한 문장을 사용하라.
+"[circumstance]일 때, 사용자는 [pattern] — 이는 [insight]를 반영한다."
+
+오래 지속되는 감정, 치료(therapy), 스트레스, 상실, 트라우마 관련 패턴에서는
+구체적인 자기 서사적 배경을 일반적인 성격 라벨로 지워 버리지 마라.
+다음을 보존하는 닻이 있는 구조를 선호하라.
+"Trigger/배경 -> 반복되는 감정 반응 -> 관찰된 coping resource."
+user-owned 증거에 존재하는 trigger, 반응, coping resource만 포함하라.
+어시스턴트의 조언은 관찰된 사용자 coping resource가 아니다.
+
+### 규칙
+- **원자적**: Schema 하나에 패턴 하나. 서로 다른 두 패턴 → 두 개의 Schema.
+- **불변**: 한 번 생성되면 content는 절대 바뀌지 않는다.
+- **증거만**: 기존 표현을 단지 뒷받침하는 새 사실 →
+ `add_evidence`를 호출하라. 새 증거가 현재의 지속적 상태를 실질적으로 바꾸거나,
+ 교정하거나, 좁힌다면 `revise_schema`를 사용해 이전 버전이 감사용으로는 남되
+ 활성 검색에서는 제거되게 하라.
+- **도메인 한정**: 관찰된 도메인 안에 머물러라. 도메인 간 추상화는 별도의 시스템 프로세스가 처리한다.
+- **사실과 패턴을 구분**: 하나의 명시적인 정체성, 건강 상태, 장비 사용,
+ 소속, 프로젝트, 또는 선호는 L6이 아니라 L2 상태 기억에 속한다.
+ L6에는 적어도 두 개의 독립된 raw 쓰기 또는 session을 대표하는 user-owned
+ 증거가 필요하다. 병합된 하나의 L2 사실이 여러 쓰기를 대표할 수 있으므로,
+ fact 노드 수를 세지 말고 그 source_raw_memory_ids를 살펴보라.
+- **주체 안전성**: 같은 source chunk를 공유하는 사실들은 다른 사람이나
+ 예시를 기술할 수 있다. 자료가 그 패턴을 사용자에게 명시적으로 귀속시킬 때만
+ 사용자 Schema를 생성하라. 그렇지 않으면 그 자료에 대해서는 아무 연산도 출력하지 마라.
+- **후보 커버리지**: source-context 검토에서는 나열된 모든 후보 사실을 처리하라.
+ `create_schema`/`add_evidence`의 증거로 쓰거나, `skip_fact`를 출력하라.
+ raw context는 그 주체를 확인하거나 누락된 세부 사항을 복원할 수 있지만,
+ 무관한 Schema의 씨앗이 되어서는 안 된다.
+- **증거 기준**: L6 생성에는 적어도 두 개의 독립된 raw 쓰기 또는 session을
+ 대표하는 하나 이상의 user-owned 증거 사실이 필요하다.
+ 어시스턴트의 조언만으로는 사용자 패턴이 확립되지 않는다.
+
+### 좋은 예 vs 나쁜 예
+✅ "요리할 때, 사용자는 레시피 단계를 엄격히 따르고 재료를 정확히 계량한다 — 이는 불확실성을 다루기 위해 외부 구조가 필요하다는 점을 반영한다."
+✅ "게임할 때, 사용자는 100% 달성을 위해 항상 공략을 확인한다 — 미완성에 대한 낮은 내성에서 비롯된다."
+✅ "예기치 않게 멘토를 잃은 뒤, 죽음을 떠올리게 하는 계기가 슬픔을 갑작스럽게 되살릴 수 있다. 사용자는 멈춰 서서 돌아보고 조용히 산책하며 안정을 되찾는다."
+❌ "사용자는 음악을 창의적 종합과 문화적 가교의 매체로 다루며, 다양한 음악 전통을 일관되게 섞는다..." (여러 패턴이 섞였고 너무 넓다)
+❌ "사용자는 많은 것에 열정적이며 품질을 중시한다." (circumstance가 없고 너무 모호하다)
+❌ "사용자는 의미 지향적이고 회복력이 있다." (지속적인 trigger와 관찰된 coping 증거를 지워 버린다)
+
+## 작업 흐름
+
+입력 자료(적어도 하나의 cluster가 있을 때만 호출된다):
+- **Cluster Results**: 주 입력 — 의미 유사도로 묶인 사실들
+- **Unclustered Facts (보충)**: 어떤 cluster에도 속하지 않은 사실들. cluster 결과보다 우선순위가 낮다
+
+각 사실 그룹(clustered 또는 unclustered)에 대해:
+1. **기존 Schema 검색**: 기존 Schema가 이미 이 패턴을 담고 있다면 `add_evidence`를 호출하라. 새 증거를 추가한 뒤 이전 표현이 실질적으로 불완전해지거나 오해를 낳게 될 때만 `revise_schema`를 사용하라.
+2. **새 Schema 생성**: 이 패턴을 포괄하는 기존 Schema가 없을 때만. 한 문장, 세 구성 요소.
+3. **관계 구축**: 두 Schema가 주제적으로 관련되어 있다면 `add_edge`(RELATED_TO)를 사용하라.
+
+## 원칙
+
+- 모든 Graph 연산은 반드시 tools를 통해야 한다
+- Schema content는 불변이다 — 이미 존재하는 것을 절대 다시 만들지 마라
+- 중복을 만드는 것보다 `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, so their prompts stay exactly as before.
+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 = (
+ (
+ "모든 memory와 intention에는 그것이 어느 기억 저장소에 속하는지를 나타내는 `owner`가 반드시 있어야 한다.",
+ "모든 memory에는 그것이 어느 기억 저장소에 속하는지를 나타내는 `owner`가 반드시 있어야 한다.",
+ ),
+)
+
+INTENTION_DISABLED_NOTE = (
+ "\n\n---\n\n# INTENTION 비활성화\n"
+ "intention 추출이 비활성화되어 있다. 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 = """
+
+## 출력 형식
+
+tools를 호출하지 마라. 연산들의 JSON 배열을 ```json 코드 블록으로 감싸 직접 출력하라.
+
+사용 가능한 연산:
+
+1. **create_schema** — 새 L6 행동 Schema 생성
+ ```{"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에 증거 추가 (content는 불변으로 유지)
+ ```{"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
+ 검토에서 `[]`는 그 검토의 모든 후보를 살펴보았고 지속적인 Schema를 뒷받침하는
+ 것이 하나도 없다는 뜻이다.
+3. 코드 블록 밖에는 아무 텍스트도 없어야 한다.
+4. evidence_list의 ID는 자료에 제공된 fact node_id에서 와야 한다.
+5. add_evidence / revise_schema의 node_id는 기존 Graph 노드 ID에서 와야 한다.
+6. source-context 검토에서는 모든 후보 사실이 evidence_list 또는 skip_fact에 나타나야 한다."""
+
+# Appended to SYSTEM2_OUTPUT_INSTRUCTIONS when the schema evidence gate is on.
+SYSTEM2_SCHEMA_EVIDENCE_GATE = """
+
+7. L6은 사건 간 행동 패턴만 표현한다. create_schema는 적어도 두 개의 독립된 raw 쓰기 또는 session을 대표하는 user-owned 증거를 사용해야 한다. source_raw_memory_ids가 여러 개의 독립된 쓰기를 담고 있다면 병합된 하나의 사실도 기준을 충족할 수 있다.
+8. 하나의 명시적인 정체성, 건강 상태, 장비 사용, 소속, 프로젝트, 또는 선호에 대해서는 L6을 만들지 마라. 그런 사실은 canonical 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
+# (or be harmless if it does not).
+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_excluded={evidenced})\n"
+ "- 발견된 cluster 수: {clusters}\n"
+ "- cluster 내 사실: {clustered}, unclustered 보충: {unclustered}\n"
+ "- Graph Schema 총수: {graph_total} (recalled={recalled})"
+ ),
+ "graph_status_empty": "- Graph 상태: **비어 있음** (첫 인지 처리 실행)\n",
+ "clusters_header": "### Cluster 결과\n",
+ "label_holistic": "{n}개의 세션 간 사용자 사실. 증거로 뒷받침되는 지속적 감정/치료 패턴만",
+ "label_source_context": "{n}개의 후보 사실. raw 쓰기는 주체/세부 사항 검증에만 사용",
+ "label_topic": "{n}개 사실, 주제",
+ "raw_label": "후보별 관련 raw 발췌",
+ "holistic_note": (
+ "이것은 경계가 정해진 한 번의 야간 전체 통합 처리다. anchored therapy Schema를 "
+ "최대 {max_schemas}개까지 생성하라. "
+ "서로 다른 raw 쓰기/session에 걸쳐 지속적인 trigger/배경, 반복되는 감정 반응, "
+ "그리고 관찰된 coping resource 또는 결정 제약을 결합하는 쪽을 선호하라. "
+ "create_schema 전에 해당 증거 ID들의 raw_sources를 합집합으로 모아 서로 다른 raw source ID가 "
+ "적어도 두 개인지 확인하라. 하나의 raw 쓰기에서 나온 두 사실은 하나의 사건이다. "
+ "증거가 부족하면 []를 출력하라.\n"
+ ),
+ "companion_header": "**독립 출처 companion 힌트 (결론이 아니라 후보일 뿐):**",
+ "unclustered_header": "### Unclustered 사실 (보충)\n",
+ "unclustered_hint": "아래 사실들은 위의 어떤 cluster에도 묶이지 않았다. cluster 주제를 처리한 뒤 살펴보라. cluster 결과보다 우선순위가 낮다.\n",
+ "forward_header": "### 관련 Graph 노드 (cluster centroid 검색으로 검색됨, {count}건)\n",
+ "graph_empty": "### 기존 Graph 노드\n현재 Graph는 비어 있으며, 이번이 첫 인지 처리 실행이다. Graph를 검색하지 마라(아무것도 반환되지 않는다). 곧바로 cluster 결과로부터 Schema 생성으로 진행하라.\n",
+ "graph_no_recall": (
+ "### 기존 Graph 노드\n"
+ "Graph에는 {graph_total}개의 Schema가 있지만, "
+ "centroid 기반 벡터 검색에서 일치하는 것이 없었다. cluster 결과에 근거해 새 Schema가 필요한지 판단하라.\n"
+ ),
+ "reverse_header": "### Graph 역참조 (기존 Schema가 참조하는 VDB 사실)\n",
+ "tags_header": "### 기존 태그 (동의어를 새로 만들기보다 이 중에서 재사용하는 쪽을 우선하라)\n",
+ "closing": (
+ "위 자료를 분석하여 연산들의 JSON 배열을 출력하라. "
+ "새 Schema를 생성할지, 기존 Schema에 증거를 추가할지 판단하라. "
+ "데이터가 신뢰할 만한 결론을 내기에 부족하면 빈 배열 `[]`를 출력하라. "
+ "태그를 붙일 때는 위의 기존 태그 목록에 있는 태그를 재사용하는 쪽을 우선하라."
+ ),
+}
diff --git a/hy_memory/prompts/pt.py b/hy_memory/prompts/pt.py
new file mode 100644
index 0000000..373aff0
--- /dev/null
+++ b/hy_memory/prompts/pt.py
@@ -0,0 +1,2314 @@
+# -*- coding: utf-8 -*-
+"""Portuguese prompts (``pt``). Translated from en.py; native-speaker review recommended.
+
+Brazilian Portuguese (``pt-BR`` is an accepted alias), avoiding heavy
+regionalisms; the model is addressed as "você" throughout.
+"""
+
+
+# ================================================================
+# Chat extraction (agent/extractor.py)
+# ================================================================
+
+EXTRACT_SYSTEM_PROMPT = """# PAPEL
+
+Você é um Extrator de Memórias (Memory Extractor).
+
+Extraia memórias duradouras e de alto valor das conversas e converta-as em afirmações estruturadas e autocontidas.
+
+Extraia apenas informações que provavelmente serão importantes em conversas futuras.
+
+---
+
+# ENTRADAS
+
+Você receberá:
+
+* Últimas k mensagens (Last k Messages)
+* Novas mensagens (New Messages)
+* Memory Date
+* Current Date
+
+Use:
+
+* as Últimas k mensagens apenas para resolução de correferência
+* a Memory Date como a ÚNICA âncora temporal
+* a Current Date apenas como metadado, nunca para resolver tempo relativo
+
+---
+
+# O QUE EXTRAIR
+
+Extraia SOMENTE informações genuinamente novas introduzidas nas NOVAS mensagens do usuário.
+
+Boas memórias incluem:
+
+* preferências
+* projetos de longo prazo
+* hábitos
+* objetivos
+* atividades recorrentes
+* opiniões
+* relacionamentos
+* experiências importantes
+* traços estáveis
+* planos futuros
+* decisões
+* restrições
+* recomendações aceitas
+
+NÃO extraia:
+
+* conversa fiada
+* agradecimentos e confirmações
+* emoções genéricas
+* contexto conversacional temporário
+* lembretes do assistente sobre memórias antigas
+* informações já implícitas no contexto anterior
+* julgamentos vagos de personalidade
+
+---
+
+# SUJEITO
+
+Toda memória deve ser autocontida, escrita em terceira pessoa, com um sujeito
+explícito. O sujeito a usar é decidido por **quem falou**:
+
+| Falante | Sujeito a escrever | Exemplo |
+| --- | --- | --- |
+| `role: "user"` | o usuário | "O usuário ..." |
+| qualquer falante com um `name` diferente do usuário (ex.: `name: "John"`) | essa pessoa, pelo nome | "John ..." |
+| `role: "assistant"` SEM `name` | o assistente de IA | "O assistente ..." |
+
+As duas seções de entrada expressam o falante de formas diferentes:
+
+* **Novas mensagens** é um array JSON — leia `role` e o campo opcional `name`.
+* **Últimas k mensagens** é texto renderizado — o falante é o rótulo entre colchetes,
+ `[user]:` / `[John]:` / `[assistant]:`, opcionalmente precedido por uma linha
+ "The user's name is Tim" / "O nome do usuário é Tim".
+
+Regras:
+
+* O usuário é a pessoa a quem estas memórias pertencem. Mesmo quando o próprio nome
+ do usuário é conhecido (pelo `name` na mensagem dele ou pela linha inicial com o nome),
+ continue escrevendo "O usuário ...", NUNCA "Tim ...".
+* **`role: "assistant"` COM um `name` é outra pessoa real, não a IA.**
+ Escreva as memórias dessa pessoa com o nome dela como sujeito: "John ...".
+* Somente um `role: "assistant"` sem nome é o assistente de IA.
+* Nunca invente um nome para o assistente de IA; ele não tem nome.
+
+---
+
+# REGRAS DE IDIOMA
+
+* O idioma de saída deve ser o mesmo da entrada.
+* Preserve exatamente as escritas originais e os termos técnicos.
+* Nunca translitere nomes, marcas ou equações.
+
+---
+
+# DOIS TIPOS DE MEMÓRIA
+
+Você extrai dois tipos de memória: **memory** e **intentions**.
+
+## memory
+
+Tudo o que é duradouro e vale a pena lembrar sobre o usuário — e sobre qualquer
+outra pessoa nomeada na conversa — vai aqui:
+
+* preferências, opiniões, valores, atitudes
+* eventos, ações, experiências
+* hábitos, padrões de comportamento
+* relacionamentos, traços
+* fatos objetivos, decisões, restrições
+* atividades em andamento
+
+Preferências implícitas DEVEM ser inferidas quando fortemente sugeridas
+(ex.: retomar uma atividade → interesse positivo; evitar algo →
+preferência negativa; esforço voluntário repetido → interesse contínuo).
+
+NÃO separe "que tipo de pessoa o usuário é" de "o que aconteceu".
+Ambos vão para `memory`.
+
+## intentions
+
+Algo voltado ao futuro que o usuário **planeja ou pretende fazer no futuro**,
+sobre o qual se pode agir e que deixa de ser relevante depois de feito ou passado.
+
+Exemplos:
+
+* "O usuário tem uma entrevista de emprego na próxima terça-feira."
+* "O usuário planeja se mudar de apartamento no fim do mês."
+* "O usuário pretende terminar o relatório antes de sexta-feira."
+
+NÃO são intentions (estes vão em `memory`):
+
+* preferências / traços estáveis ("O usuário gosta de basquete")
+* eventos passados já concluídos ("O usuário se mudou para Pequim no ano passado")
+* objetivos gerais sem nenhum passo futuro acionável
+
+### valid_until
+
+Para cada intention, forneça `valid_until`: a data após a qual a
+intention deixa de importar (o prazo / data-alvo), resolvida
+com base na **Memory Date** (ex.: "próxima terça-feira" → essa data absoluta).
+Se nenhum prazo puder ser determinado, defina `valid_until` como `null`.
+
+---
+
+# OWNER
+
+Toda memory e toda intention DEVEM ter um `owner` indicando a qual repositório de
+memória pertencem. Existem exatamente dois valores:
+
+* `"user"` — tudo o que pertence ao repositório de memória do próprio usuário. Isso
+ inclui fatos/preferências/traços sobre o próprio usuário E fatos sobre outras
+ pessoas reais nomeadas na conversa, porque essas ainda são coisas que a memória
+ do usuário deve guardar.
+* `"agent"` — informações que o assistente de IA (um `role: "assistant"` sem nome)
+ fornece (recomendações, confirmações, coisas que ele pesquisou), ou uma ação futura
+ que o usuário quer que o **assistente** execute ("me lembre daqui a 8 horas").
+
+Uma pessoa nomeada NUNCA é `owner: "agent"` — ela é uma pessoa real, não a IA,
+mesmo que suas mensagens tenham `role: "assistant"`. As memórias dela são
+`owner: "user"`, com o nome dela como sujeito do conteúdo.
+
+Decida o `owner` item por item. Na dúvida, use `"user"` como padrão.
+
+---
+
+# REGRAS TEMPORAIS
+
+Resolva tempo relativo usando a Memory Date.
+
+Exemplos:
+
+* "semana que vem"
+* "mês passado"
+* "amanhã"
+
+Se o tempo não puder ser resolvido com segurança:
+
+* remova a expressão relativa
+* mantenha a memória atemporal
+
+Não invente cronologia.
+
+**Eventos que acabaram de acontecer são eventos — mantenha-os.** Quando o usuário relata
+algo como recém-concluído ("acabei de voltar", "acabei de terminar", "hoje de manhã",
+"ontem"), a data de conclusão é a Memory Date. Registre o **próprio evento** com essa
+data; não o dissolva em uma afirmação de contexto geral.
+
+* "Acabei de voltar de uma viagem com a minha família"
+ → "O usuário voltou de uma viagem em família em <Memory Date>."
+ NÃO → "O usuário faz viagens em família." (a data de volta é a resposta para "quando
+ ele voltou", e descartá-la torna a pergunta impossível de responder)
+
+Quando um evento tem um início e um fim que a conversa informa separadamente,
+registre ambos em vez de condensá-los em um único intervalo.
+
+---
+
+# REGRAS DE QUALIDADE
+
+Cada memória deve ser:
+
+* autocontida
+* contextualmente completa
+* fácil de recuperar
+* densa em informação
+
+Retenha detalhes importantes:
+
+* nomes
+* produtos
+* locais
+* números
+* equações
+* restrições
+
+Nunca generalize algo específico em uma categoria. Escreva o que foi realmente dito.
+
+* "Banff" → mantenha "Banff", NÃO "as Montanhas Rochosas"
+* "uma border collie de 3 anos chamada Luna" → mantenha a raça, a idade e o nome
+
+**Detalhes fornecidos pelo outro falante também contam.** Um fato costuma ser construído
+ao longo de vários turnos: o outro falante nomeia a coisa, o usuário confirma. As regras
+de sujeito decidem *de quem* é a memória — elas não autorizam descartar detalhes.
+
+* [Sam]: "Você aproveitou as oportunidades de esqui em Banff?"
+ [user]: "Sim, foi ótimo para esquiar!"
+ → "O usuário esquiou em Banff e achou a neve incrível."
+ NÃO → "O usuário gosta de esportes de inverno." (tanto o lugar quanto a atividade foram
+ estabelecidos, um por cada falante)
+
+Evite memórias fragmentadas e sem contexto.
+
+Escolha o menor número de memórias que ainda preserve necessidades distintas de
+recuperação futura.
+
+* Compressão significa combinar, não omitir. Toda proposição duradoura explícita
+ nas novas mensagens deve aparecer exatamente uma vez na saída.
+* Combine detalhes quando compartilharem o mesmo sujeito e o mesmo evento, estado,
+ preferência, plano ou decisão do mundo real. Um evento coerente pode usar 1–3 frases.
+* Não produza ao mesmo tempo uma afirmação ampla e reformulações mais restritas da mesma evidência.
+* Separe somente quando o sujeito for diferente, os eventos tiverem acontecido de forma
+ independente ou as memórias descreverem estados diferentes.
+* Mantenha uma causa, recomendação ou consequência junto ao fato que ela explica quando
+ separá-las faria perder a relação.
+* Nunca junte ocorrências datadas distintas só porque compartilham um tema.
+* Preserve a precisão temporal da fonte. Não transforme expressões vagas como "no último
+ fim de semana" ou "no verão passado" em datas exatas de calendário, a menos que a data
+ seja explícita ou determinada de forma única; "o fim de semana anterior a <Memory Date>" é aceitável.
+
+---
+
+# TAGS
+
+Cada memória deve incluir 1–3 tags concisas.
+- Palavras-chave temáticas ficam em minúsculas e em inglês (travel, health, work).
+- Nomes próprios mantêm as maiúsculas (Jasper, Canada, Banff, Prius).
+
+Exemplos:
+
+* work
+* travel
+* Jasper
+* Canada
+* health
+
+---
+"""
+
+STRUCTURE_METADATA_PROMPT = """
+
+---
+
+# ORGANIZAÇÃO ESTRUTURAL
+
+Para cada `memory`, produza também:
+
+* `topic_paths`: uma lista retrocompatível de zero a três caminhos semânticos,
+ do mais amplo ao mais específico.
+* `event_facet`: um objeto apenas com `subject`, `participants`, `action`,
+ `objects`, `locations` e `state`; state é `planned`, `ongoing`,
+ `completed` ou `unknown`.
+* `topic_assignments`: de zero a seis associações específicas de um sujeito. Cada item é
+ `{subject, role, path}`, onde `path` é uma lista de segmentos `{name, type}` e
+ `type` é um de `topic`, `facet`, `series` ou `episode`. Use `topic` para um
+ domínio amplo, `facet` para uma atividade/aspecto semântico concreto, `series` apenas
+ para ocorrências repetidas da mesma linha concreta de atividade/estado, e
+ `episode` apenas para uma única ocorrência delimitada do mundo real. Um evento
+ compartilhado pode ter uma associação por participante explícito, mantendo uma
+ única memória canônica. Os tipos seguem `topic -> facet -> series -> episode`;
+ níveis podem ser pulados, mas tipos não podem se repetir nem voltar para trás.
+
+Este extrator vê apenas a escrita atual e, portanto, não deve produzir um
+segmento `series`. Produza aqui Topic/Facet/Episode. O Reconcile pode depois
+estabelecer uma Series após comparar ocorrências armazenadas independentes.
+
+Esta é uma organização no momento da escrita. Não infira Series/Episode pela
+profundidade do caminho, não fabrique hierarquia a partir de um nome próprio ou de
+uma tag ampla, e não atribua uma pessoa apenas porque ela aparece junto em um
+contexto não relacionado. Pare no nível mais específico que tenha suporte e use
+valores vazios quando houver incerteza. Nunca codifique formas de pergunta como
+"quando", "quantos", "quem", pluralidade ou expressões ordinais.
+"""
+
+EXTRACT_FEW_SHOT = """
+---
+
+# EXEMPLOS
+
+## Exemplo 1 — Limite: o contexto antigo serve só para resolução, nunca é extraído de novo
+
+Últimas k mensagens:
+[{"role": "user", "content": "Tenho olhado cachorros para adoção no abrigo do centro."},
+ {"role": "assistant", "content": "Que legal — encontrou algum de que gostou?"}]
+Novas mensagens:
+[{"role": "user", "content": "Sim, busquei ela ontem — uma border collie de 3 anos chamada Luna."}]
+Memory Date: 2025-04-10
+
+Saída:
+```json
+{
+ "memory": [
+ {"content": "O usuário adotou uma border collie de 3 anos chamada Luna em um abrigo do centro em 2025-04-09.", "tags": ["pets", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+As mensagens antigas apenas resolvem "ela" e fornecem contexto ("abrigo do centro"). NÃO produza uma memória desatualizada como "o usuário está pensando em adotar um cachorro" — apenas o fato genuinamente novo (a adoção concluída) é extraído, com "ontem" resolvido com base na Memory Date.
+
+## Exemplo 2 — Condense uma resposta longa do assistente
+
+Novas mensagens:
+[{"role": "user", "content": "Escreva um texto curto sobre por que o trabalho remoto aumenta a produtividade."},
+ {"role": "assistant", "content": "Claro — abertura: 'O trabalho remoto transformou a forma como as equipes funcionam...' [~2000 palavras do corpo omitidas] ...conclusão: 'Em resumo, autonomia e menos interrupções geram mais produção.'"}]
+Memory Date: 2025-03-22
+
+Saída:
+```json
+{
+ "memory": [
+ {"content": "O assistente redigiu para o usuário um texto curto defendendo que o trabalho remoto aumenta a produtividade porque autonomia e menos interrupções geram mais produção.", "tags": ["writing", "remote-work"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+A resposta do assistente é longa. Nunca armazene o texto literal — destile-o em tema + tese. O owner é "agent" porque foi o assistente que o produziu. Conteúdo literal inchado torna a memória inutilizável.
+
+## Exemplo 3 — Extração composta: basic_info + intention + plano do agente condensado
+
+Novas mensagens:
+[{"role": "user", "content": "Oi, eu sou o Kenji. Estou planejando uma viagem ao Japão no mês que vem — você pode montar um roteiro de 7 dias?"},
+ {"role": "assistant", "content": "# Rota Dourada Clássica do Japão em 7 Dias (Tóquio → Kyoto → Nara → Osaka)\\nChegada por Tóquio, Shinkansen para o sul até Kyoto, bate-volta a Nara, partida por Osaka (Kansai).\\n\\n## Dia 1: Chegada em Tóquio\\n- Pouso em Haneda/Narita, deixar as malas no hotel perto da Estação de Tóquio.\\n- Fim da tarde: Templo Sensoji (Asakusa), passear pela Rua Nakamise, provar taiyaki.\\n- Noite: Cruzamento de Shibuya + terraço do Shibuya Sky para o pôr do sol; jantar em izakaya (yakitori, saquê).\\n\\n## Dia 2: Mercados e pontos turísticos de Tóquio — [omitido]\\n## Dia 3: Shinkansen até Kyoto, Fushimi Inari, Gion — [omitido]\\n## Dia 4: Templos de Kyoto (Kiyomizu-dera, Kinkaku-ji, Ginkaku-ji) — [omitido]\\n## Dia 5: Bate-volta a Nara (cervos do Parque de Nara, Todai-ji) — [omitido]\\n## Dia 6: Osaka (Castelo de Osaka, comida de rua em Dotonbori) — [omitido]\\n## Dia 7: Passeios em Osaka + partida pelo Aeroporto de Kansai — [omitido]\\n\\nDica: compre um JR Pass de 7 dias antes de chegar. Quer que eu ajuste algo?"}]
+Memory Date: 2025-09-15
+
+Saída:
+```json
+{
+ "memory": [
+ {"content": "O assistente criou para o usuário um roteiro de 7 dias pelo Japão seguindo a clássica rota dourada: Tóquio (Asakusa, Shibuya), Shinkansen até Kyoto (Fushimi Inari, Kiyomizu-dera, Kinkaku-ji, Gion), um bate-volta a Nara (parque dos cervos, Todai-ji) e depois Osaka (Castelo de Osaka, Dotonbori), com partida pelo Aeroporto de Kansai.", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
+ ],
+ "intentions": [
+ {"content": "O usuário planeja fazer uma viagem de 7 dias ao Japão em outubro de 2025.", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
+ ],
+ "basic_info": {"name": "Kenji"}
+}
+```
+Um único turno produz três saídas em compartimentos diferentes: o nome vai para basic_info, a viagem é uma intention voltada ao futuro com prazo, e o longo roteiro do assistente, com várias seções, é condensado em UMA memória densa do agente — a rota e as principais paradas por cidade, NÃO os tópicos de cada dia, as dicas ou as listas de comida. Armazenar a resposta inteira literalmente incharia a memória; armazenar o esqueleto a mantém consultável.
+
+## Exemplo 4 — Uma mensagem posterior que confirma/adota uma recomendação anterior é, ela própria, um fato
+
+Novas mensagens:
+[{"role": "user", "content": "Meu filho de 6 anos não come nenhum legume. Alguma ideia?"},
+ {"role": "assistant", "content": "Tente bater espinafre ou cenoura no molho do macarrão — a cor e o sabor quase desaparecem, e muitas crianças aceitam sem perceber."},
+ {"role": "user", "content": "Ah, legal, vamos testar hoje à noite. Aliás, qual é um bom horário para dormir nessa idade?"},
+ {"role": "assistant", "content": "Para uma criança de 6 anos, o ideal é entre 19h e 21h, com cerca de 10–11 horas de sono."}]
+Memory Date: 2025-06-20
+
+Saída:
+```json
+{
+ "memory": [
+ {"content": "O usuário tem um filho de 6 anos que se recusa a comer legumes e aceitou a sugestão do assistente de bater espinafre ou cenoura no molho do macarrão para disfarçá-los.", "tags": ["parenting", "food"], "owner": "user"},
+ {"content": "O assistente orientou o usuário de que uma criança de 6 anos deve dormir entre 19h e 21h, com cerca de 10–11 horas de sono.", "tags": ["parenting", "sleep"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Na terceira mensagem o usuário disse "vamos testar hoje à noite" — adotando explicitamente a sugestão anterior. Essa aceitação é valiosa e deve ser registrada ("aceitou a sugestão do assistente de ..."), não descartada como conversa fiada. O conselho sobre a hora de dormir acabou de ser dado e ainda não foi adotado, então é registrado como conselho (owner "agent").
+
+## Exemplo 5 — Contexto RAG/injetado: nunca armazene o texto injetado
+
+Novas mensagens:
+[{"role": "user", "content": "[Contexto recuperado: A Torre Eiffel tem 330 m de altura e foi concluída em 1889.] Considerando isso, vou pedir minha namorada em casamento no topo da Torre Eiffel neste verão."}]
+Memory Date: 2025-05-02
+
+Saída:
+```json
+{
+ "memory": [],
+ "intentions": [
+ {"content": "O usuário planeja pedir a namorada em casamento no topo da Torre Eiffel no verão de 2025.", "tags": ["relationship", "travel"], "valid_until": "2025-08-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+O contexto recuperado entre colchetes (a altura e o ano da torre) é material de referência injetado por RAG, NÃO algo que o usuário nos contou sobre si mesmo — NÃO o armazene. Apenas o plano do próprio usuário voltado ao futuro é extraído. Texto injetado pelo sistema/RAG é contexto para o modelo, nunca uma memória.
+
+## Exemplo 6 — Material de referência compartilhado: extraia o conteúdo, não o ato de compartilhar
+
+Novas mensagens:
+[{"role": "user", "content": "Guarde a receita de guioza da minha avó para eu não perder. Recheio: 500 g de carne de porco moída, 300 g de acelga chinesa, 2 colheres de sopa de shoyu, 1 colher de sopa de óleo de gergelim, um pedaço de gengibre do tamanho de um polegar, picado. A acelga fica 15 min no sal e depois é espremida até secar. Cozinhe os guiozas em água fervente, acrescente água fria duas vezes, estão prontos quando boiarem."},
+ {"role": "assistant", "content": "Entendido, salvo!"}]
+Memory Date: 2025-07-01
+
+Saída:
+```json
+{
+ "memory": [
+ {"content": "Receita de guioza da avó do usuário: recheio com 500 g de carne de porco moída, 300 g de acelga chinesa (15 minutos no sal e depois espremida até secar), 2 colheres de sopa de shoyu, 1 colher de sopa de óleo de gergelim e um pedaço de gengibre picado do tamanho de um polegar; cozinhe os guiozas em água fervente, acrescente água fria duas vezes, e estão prontos quando boiarem.", "tags": ["food", "recipe", "family"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Extraia o conteúdo factual real (ingredientes, quantidades, a etapa de salgar e espremer, o método de cozimento) — NÃO "o usuário compartilhou uma receita" nem "o usuário pediu para lembrar a receita". O ato de compartilhar não tem valor; o conteúdo é o que pode ser consultado.
+
+## Exemplo 7 — Números e atributos estruturados preservados exatamente
+
+Novas mensagens:
+[{"role": "user", "content": "Registrando meus recordes na academia de casa neste ciclo: Agachamento 140kg x 3, Supino 100kg x 5, Levantamento terra 180kg x 2, Desenvolvimento 60kg x 6. Peso corporal 78kg, 3 séries por exercício, 3 min de descanso."},
+ {"role": "assistant", "content": "Registrado — números fortes!"}]
+Memory Date: 2026-01-20
+
+Saída:
+```json
+{
+ "memory": [
+ {"content": "Os recordes atuais de levantamento do usuário são Agachamento 140kg x 3, Supino 100kg x 5, Levantamento terra 180kg x 2 e Desenvolvimento 60kg x 6, com peso corporal de 78kg.", "tags": ["fitness", "strength"], "owner": "user"},
+ {"content": "O usuário treina com 3 séries por exercício e 3 minutos de descanso entre as séries.", "tags": ["fitness", "training"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+Todo número e unidade (kg, repetições, séries, tempo de descanso) é preservado exatamente — descartá-los destruiria a informação mais consultável. Divida em dois temas limpos (recordes vs. protocolo de treino), mas nunca arredonde nem omita os detalhes.
+
+## Exemplo 8 — Conversa longa com vários temas: não pare depois do primeiro tema
+
+Novas mensagens:
+[{"role": "user", "content": "Semana intensa — finalmente defendi minha tese de doutorado na terça!"},
+ {"role": "assistant", "content": "Parabéns! Como você está se sentindo?"},
+ {"role": "user", "content": "Aliviado! Também assinei o contrato de aluguel de um apartamento em Berlim e me mudo no mês que vem. E comecei a aprender alemão no Duolingo — 30 dias seguidos. Minha parceira Sofia vai ficar em Madri por enquanto, o que é difícil."}]
+Memory Date: 2025-11-08
+
+Saída:
+```json
+{
+ "memory": [
+ {"content": "O usuário defendeu a tese de doutorado em 2025-11-04.", "tags": ["education", "milestone"], "owner": "user"},
+ {"content": "O usuário assinou o contrato de aluguel de um apartamento em Berlim.", "tags": ["housing"], "owner": "user"},
+ {"content": "O usuário está aprendendo alemão no Duolingo e tem uma sequência de 30 dias.", "tags": ["language", "learning"], "owner": "user"},
+ {"content": "A parceira do usuário, Sofia, vai ficar em Madri por enquanto, o que o usuário acha difícil.", "tags": ["relationship"], "owner": "user"}
+ ],
+ "intentions": [
+ {"content": "O usuário planeja se mudar para Berlim no mês que vem (por volta de dezembro de 2025).", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+Quatro ou mais temas — a defesa da tese, o apartamento em Berlim, o aprendizado de alemão e a parceira em Madri. Não pare depois do primeiro tema. Note que um turno se dividiu em um fato concluído (contrato assinado) E uma intention (a mudança que vem aí), e o detalhe emocional, mas substancial, sobre Sofia é mantido porque carrega um contexto duradouro do relacionamento.
+
+## Exemplo 9 — Duas pessoas reais: `name` em uma mensagem de assistant significa uma pessoa real
+
+Novas mensagens:
+[{"role": "user", "name": "Tim", "content": "Acabei de voltar da academia de escalada, terceira vez nesta semana. Finalmente mandei aquela via negativa."},
+ {"role": "assistant", "name": "John", "content": "Boa! Eu tenho nadado em vez disso — meu ombro ainda dói desde o mês passado."}]
+Memory Date: 2025-08-14
+
+Saída:
+```json
+{
+ "memory": [
+ {"content": "O usuário tem escalado três vezes por semana e recentemente completou uma via negativa difícil.", "tags": ["fitness", "climbing"], "owner": "user"},
+ {"content": "John tem nadado em vez de fazer outros exercícios porque o ombro dele ainda doía depois de uma lesão por volta de julho de 2025.", "tags": ["fitness", "health"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {"name": "Tim"}
+}
+```
+John tem `role: "assistant"`, mas tem um `name`, então é outra pessoa real, NÃO a IA: a memória dele usa "John ..." como sujeito e continua sendo `owner: "user"` (pertence ao repositório de memória do usuário). A memória do próprio usuário continua "O usuário ...", mesmo sabendo que o nome é Tim — nunca "Tim tem escalado". `basic_info.name` vem de `name: "Tim"` na mensagem do usuário, que é fonte autorizada mesmo que Tim nunca tenha dito o próprio nome em voz alta.
+
+## Exemplo 10 — Contraexemplo: atributos de outra pessoa nunca vão para basic_info
+
+Novas mensagens:
+[{"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
+
+Saída:
+```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"}
+}
+```
+A profissão e o local são atributos **DELE** (de John), então vão para `memory` com "John" como sujeito. Eles NUNCA devem parar em `basic_info.occupation` / `basic_info.location` — `basic_info` é exclusivamente o perfil do próprio usuário. Somente `name` (Tim, vindo do campo `name` da mensagem do usuário) pertence a ele. Note que o idioma de saída acompanha o idioma de entrada (este exemplo está em inglês).
+
+## Exemplo 11 — Contraexemplo: conversa fiada não tem basic_info
+
+Novas mensagens:
+[{"role": "user", "content": "Oi"},
+ {"role": "assistant", "content": "Olá! O nome do usuário é O usuário. Como posso ajudar?"}]
+Memory Date: 2025-09-03
+
+Saída:
+```json
+{
+ "memory": [],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+O usuário não declarou nada sobre si mesmo. A fala do assistente não é um turno do usuário, e "O usuário" é um marcador de posição, não um nome. Produza `{}` — nunca `{"name": "O usuário"}` nem `{"name": "usuário"}`.
+
+---
+"""
+
+EXTRACT_PROMPT = """## Últimas k mensagens
+
+{last_messages}
+
+---
+
+## Novas mensagens
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Formato de saída
+
+Retorne SOMENTE um objeto JSON dentro de um bloco cercado ```json.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "intentions": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "valid_until": "YYYY-MM-DD",
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Regras:
+
+* `memory` = informações duradouras que vale a pena lembrar: preferências, opiniões, atitudes,
+ traços, eventos, planos, experiências, hábitos, decisões — sobre o usuário ou
+ sobre qualquer outra pessoa real nomeada, com o sujeito escrito conforme "# SUJEITO"
+* `intentions` = coisas voltadas ao futuro que o usuário (ou outra pessoa nomeada) planeja /
+ pretende fazer no futuro, com `valid_until` = o prazo/data-alvo
+ (resolvido com base na Memory Date) ou `null` se não houver
+* `owner` (obrigatório em toda memory e intention) = `"user"` ou `"agent"`
+ (veja "# OWNER" acima; na dúvida, use `"user"` como padrão)
+* `basic_info` = **somente o perfil do próprio usuário**. Inclua campos estáveis de
+ perfil (ex.: nome, idade, local, profissão, empregador) **declarados explicitamente**
+ nas NOVAS mensagens do usuário. Nunca infira, nunca invente. Se nenhum campo for
+ declarado explicitamente, produza `{{}}`.
+ * REGRA RÍGIDA: preencha um campo SOMENTE se o usuário o declarou em um turno `user`.
+ Qualquer coisa dita apenas pelo assistente (incluindo o assistente citando uma
+ memória anterior como "The user's name is X" / "O nome do usuário é X") NÃO conta.
+ Se nada se qualificar, produza `"basic_info": {{}}`.
+ * NUNCA escreva o próprio nome do campo ou um marcador de posição como valor ("user",
+ "The user", "usuário", "O usuário", "用户", "name", "N/A", "unknown", "none", "-").
+ Omita o campo.
+ * Exemplo negativo: conversa fiada como `[user]: Oi` / `[assistant]: Como posso
+ ajudar?`, ou `[user]: Responda exatamente: PONG` → `"basic_info": {{}}`.
+ * Exceção para `name`: o campo `name` na própria mensagem do usuário, ou uma linha
+ inicial "The user's name is X" / "O nome do usuário é X" / "用户名叫X", é fonte
+ autorizada para `name` — mesmo que o usuário nunca o tenha dito em voz alta.
+ * NUNCA coloque aqui atributos de outra pessoa real. Se John (uma mensagem com papel
+ de assistant que tem `name`) diz "Sou enfermeiro em Berlim", isso é uma `memory`
+ ("John é enfermeiro em Berlim."), NÃO `basic_info.occupation` / `.location`.
+* Nenhuma informação duplicada entre as seções
+* As tags devem conter 1–3 palavras-chave concisas em minúsculas
+* Use arrays vazios `[]` ou `{{}}` quando nada for extraído
+* Retorne somente JSON válido
+
+Produza o JSON agora."""
+
+EXTRACT_PROMPT_NO_INTENTION = """## Últimas k mensagens
+
+{last_messages}
+
+---
+
+## Novas mensagens
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+# Formato de saída
+
+Retorne SOMENTE um objeto JSON dentro de um bloco cercado ```json.
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+Regras:
+
+* `memory` = informações duradouras que vale a pena lembrar: preferências, opiniões, atitudes,
+ traços, eventos, experiências, hábitos, decisões **e planos futuros / ações
+ próximas** — sobre o usuário ou sobre qualquer outra pessoa real nomeada, com o
+ sujeito escrito conforme "# SUJEITO". **Não** invente um compartimento separado de intentions.
+* `owner` (obrigatório em toda memory) = `"user"` ou `"agent"`
+ (veja "# OWNER" acima; na dúvida, use `"user"` como padrão)
+* `basic_info` = **somente o perfil do próprio usuário**. Inclua campos estáveis de
+ perfil (ex.: nome, idade, local, profissão, empregador) **declarados explicitamente**
+ nas NOVAS mensagens do usuário. Nunca infira, nunca invente. Se nenhum campo for
+ declarado explicitamente, produza `{{}}`.
+ * REGRA RÍGIDA: preencha um campo SOMENTE se o usuário o declarou em um turno `user`.
+ Qualquer coisa dita apenas pelo assistente (incluindo o assistente citando uma
+ memória anterior como "The user's name is X" / "O nome do usuário é X") NÃO conta.
+ Se nada se qualificar, produza `"basic_info": {{}}`.
+ * NUNCA escreva o próprio nome do campo ou um marcador de posição como valor ("user",
+ "The user", "usuário", "O usuário", "用户", "name", "N/A", "unknown", "none", "-").
+ Omita o campo.
+ * Exemplo negativo: conversa fiada como `[user]: Oi` / `[assistant]: Como posso
+ ajudar?`, ou `[user]: Responda exatamente: PONG` → `"basic_info": {{}}`.
+ * Exceção para `name`: o campo `name` na própria mensagem do usuário, ou uma linha
+ inicial "The user's name is X" / "O nome do usuário é X" / "用户名叫X", é fonte
+ autorizada para `name` — mesmo que o usuário nunca o tenha dito em voz alta.
+ * NUNCA coloque aqui atributos de outra pessoa real. Se John (uma mensagem com papel
+ de assistant que tem `name`) diz "Sou enfermeiro em Berlim", isso é uma `memory`
+ ("John é enfermeiro em Berlim."), NÃO `basic_info.occupation` / `.location`.
+* Nenhuma informação duplicada entre as seções
+* Tags: 1–3 palavras-chave concisas; tags temáticas em minúsculas; nomes próprios mantêm as maiúsculas
+* Use arrays vazios `[]` ou `{{}}` quando nada for extraído
+* Retorne somente JSON válido — **nunca** inclua uma chave `intentions`
+
+Produza o JSON agora."""
+
+
+
+# ================================================================
+# Chat reconcile (agent/reconciler.py)
+# ================================================================
+
+SEARCH_QUERY_PROMPT = """Você é um gerador de consultas de busca. Dada uma lista de memórias recém-extraídas, gere um conjunto de consultas de busca curtas que possam ser usadas para encontrar memórias existentes relacionadas em um banco de dados vetorial.
+
+O objetivo é maximizar o recall — encontrar memórias existentes semanticamente relacionadas às novas memórias, mesmo que a redação seja muito diferente.
+
+## Novas memórias:
+{new_memories}
+
+## Instruções
+
+Gere consultas de busca que cubram:
+- Os principais temas, entidades e assuntos mencionados nas memórias
+- Versões reformuladas ou abstraídas dos conceitos centrais
+- Conceitos relacionados que possam existir no repositório de memória do usuário
+
+Produza um array JSON de strings de consulta (5-15 consultas, curtas e focadas):
+
+["consulta1", "consulta2", "consulta3", ...]
+
+Produza somente o array JSON, sem nenhum outro texto."""
+
+RECONCILE_PROMPT = """Você é um sistema de gerenciamento de memória.
+
+Sua tarefa é mesclar novas memórias a uma base de memória existente, mantendo-a:
+
+* sem perdas
+* sem contradições
+* compacta
+* altamente recuperável
+
+---
+
+# Operações
+
+## ADD
+
+Use quando a informação for totalmente nova.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## UPDATE
+
+Use quando:
+
+* a nova memória for compatível com uma existente
+* ambas descreverem o mesmo tema
+* a mesclagem melhorar a completude ou a recuperabilidade
+
+Regras:
+
+* mescle sem perdas
+* preserve todas as informações úteis
+* NÃO crie duplicatas
+* se as duas divergirem em um valor, mantenha o valor da memória com o `memory_at`
+ mais recente; nunca deixe uma memória mais antiga sobrescrever um valor mais novo
+
+### Mesma ocorrência vs. outra ocorrência
+
+Use **UPDATE** somente quando a nova memória acrescentar detalhes à mesma
+ocorrência do mundo real ou ao mesmo fato duradouro já registrado.
+
+Se a mesma pessoa fizer o mesmo tipo de atividade/evento de novo em outro momento
+(outra viagem, jogo, lesão, compra, susto de saúde etc.), mantenha a ocorrência
+como um **ADD** separado. Preserve a data e os detalhes dela. Quando uma memória
+existente for claramente outra ocorrência dessa mesma série concreta, vincule-a com
+`related: [{{"memory_id":"...","relation":"same_series"}}]`.
+
+Não mescle ocorrências datadas distintas em uma única memória longa de contagem/linha do tempo.
+A camada de recuperação monta as linhas do tempo a partir das memórias L2 vinculadas.
+
+```json
+{{
+ "op": "UPDATE",
+ "memory_id": "...",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## SUPERSEDE
+
+Use SOMENTE quando:
+
+* a nova memória contradisser uma memória existente
+* ambas não puderem ser verdadeiras ao mesmo tempo
+* a memória antiga passaria a dar a resposta errada sobre o estado atual
+* o `memory_at` da nova memória for igual ou POSTERIOR ao `memory_at` da memória existente
+
+Exemplos:
+
+* mudança de cidade
+* mudança de empregador
+* mudança de status de relacionamento
+
+NÃO use para:
+
+* detalhes adicionais
+* preferências compatíveis
+* diferenças de redação
+* equivalência semântica
+* uma nova memória cujo `memory_at` seja ANTERIOR ao da memória existente — ela é um
+ estado mais antigo e nunca deve substituir um mais novo (veja "Ordem temporal")
+
+Regras:
+
+* content deve conter SOMENTE o novo estado
+* NÃO copie informações inalteradas
+* o sistema mantém o nó antigo e o vincula automaticamente à cadeia de evolução; você não precisa lidar com o histórico
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_id": "...",
+ "content": "...",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+### Agrupando várias memórias existentes em uma única cadeia
+
+Se DUAS OU MAIS memórias existentes acompanharem a MESMA dimensão e a nova memória
+for a mudança mais recente nessa dimensão — seu `memory_at` é posterior ao
+`memory_at` de todas as memórias agrupadas — você pode agrupá-las em uma única cadeia
+de evolução. Use `memory_ids` (uma lista ordenada, da MAIS ANTIGA → MAIS NOVA) em vez de um único
+`memory_id`:
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_ids": ["<oldest_id>", "<newer_id>"],
+ "content": "<somente o estado mais novo>",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+As memórias listadas são encadeadas da mais antiga → mais nova, e a nova memória se torna a
+cabeça da cadeia. `content` continua descrevendo SOMENTE o estado mais novo — nunca copie
+o texto das memórias mais antigas para ele; elas continuam consultáveis no histórico da cadeia.
+
+---
+
+# Regras
+
+* Preserve todas as informações significativas.
+* Ignore duplicatas exatas.
+* Prefira mesclar fragmentos relacionados.
+* Ocorrências datadas distintas continuam sendo ADDs separados; use `same_series` apenas para o
+ mesmo sujeito e o mesmo tipo concreto de atividade/evento.
+* Mantenha cada memória focada em um único tema coerente.
+* Siga a "Ordem temporal" abaixo.
+* **NUNCA mescle nem substitua entre sujeitos diferentes.** O sujeito é aquele sobre quem
+ o conteúdo fala: "O usuário ..." vs "John ..." vs "Mary ...". Memórias sobre
+ pessoas diferentes são fatos independentes, mesmo que a frase seja idêntica no
+ restante — "O usuário gosta de café" e "John gosta de café" são duas memórias
+ separadas, nunca um UPDATE ou um SUPERSEDE uma da outra.
+* `owner` (`user`/`agent`): copie-o da memória que está sendo escrita. NUNCA mescle nem substitua entre owners diferentes — um fato do usuário e um fato do assistente são distintos, mesmo sobre o mesmo tema.
+* Um SUPERSEDE ou tem como alvo UMA memória (`memory_id`) ou agrupa várias memórias da mesma dimensão em uma única cadeia (`memory_ids`, da mais antiga→mais nova). Um UPDATE tem como alvo exatamente UMA memória.
+* Nunca mexa na mesma memória existente a partir de mais de uma op.
+* O idioma de saída deve ser o mesmo das memórias de entrada.
+
+---
+
+# Ordem temporal
+
+Toda memória, nova ou existente, tem `memory_at`: quando aconteceu. As memórias
+NEM sempre são escritas na ordem em que aconteceram — o histórico pode ser importado
+tarde, e uma memória pode ser adicionada enquanto um histórico mais antigo ainda está sendo
+processado. Portanto, uma nova memória pode ser MAIS ANTIGA do que uma existente.
+
+* Decida qual memória é mais nova SOMENTE pelo `memory_at`. "Novas memórias" significa
+ "sendo escritas agora", não "mais recentes".
+* Uma memória mais antiga nunca deve substituir uma mais nova: nada de SUPERSEDE de uma
+ memória mais nova, e nada de UPDATE que sobrescreva um valor mais novo com um mais antigo.
+* Se uma nova memória for mais antiga do que uma memória existente com a qual conflita, mantenha a
+ memória existente como o estado atual. Faça ADD da nova como um estado passado, redigida
+ no passado com a respectiva data (por exemplo, "Em 2023 o usuário morava em Xangai"),
+ ou não produza nada se ela não acrescentar informação.
+* `memory_at: null` significa tempo desconhecido. Desconhecido NÃO é mais novo: nunca faça SUPERSEDE de uma
+ memória que tenha um `memory_at` conhecido com uma cujo `memory_at` seja null.
+* Não invente cronologia.
+
+---
+
+# Opcional: `related`
+
+Em qualquer op você PODE adicionar um array `related` registrando como a memória que está
+sendo escrita se relaciona com uma memória EXISTENTE. Isso não altera o que é armazenado — apenas
+registra um vínculo.
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."],
+ "related": [{{"memory_id": "<existing_id>", "relation": "causes"}}]
+}}
+```
+
+Somente estas quatro relações são permitidas:
+
+* `causes` — as duas memórias estão em uma relação de causa/efeito
+ (ex.: "começou a correr todos os dias" → "o joelho começou a doer")
+* `elaborates` — acrescenta detalhes à memória existente ou é um desdobramento posterior dela
+* `contrasts` — estão em tensão, mas AMBAS continuam verdadeiras (se uma torna a outra
+ falsa, isso é um SUPERSEDE, não um vínculo `contrasts`)
+* `same_series` — ocorrências datadas distintas do mesmo tipo concreto de atividade ou
+ evento para o mesmo sujeito (por exemplo, duas viagens de esqui diferentes)
+
+Regras:
+
+* Vincule somente a memórias que aparecem em "Memórias existentes" — nunca invente um id.
+* Produza um vínculo somente quando a relação for **explícita e específica**. Duas memórias
+ que apenas tratam do mesmo tema amplo NÃO são uma relação — deixe `related` de fora.
+* `same_series` exige o mesmo sujeito e uma ação/evento concreto repetido;
+ tags amplas compartilhadas como health, travel, sport, food ou work são insuficientes.
+* Omita o campo por completo quando não houver nada a vincular. Zero vínculos é o caso normal.
+* Nunca use `related` como substituto de UPDATE / SUPERSEDE.
+
+---
+{few_shot_section}
+###################
+Dados de entrada
+###################
+
+Data atual: {current_date}
+
+## Memórias existentes
+
+{existing_memories}
+
+## Novas memórias
+
+{new_memories}
+
+---
+
+# Saída
+
+Retorne SOMENTE um array JSON dentro de um bloco de código cercado ```json.
+
+Se nenhuma alteração for necessária:
+
+```json
+[]
+```
+
+Agora produza o array JSON."""
+
+RECONCILE_STRUCTURE_METADATA_PROMPT = """
+
+Contrato adicional de saída estrutural:
+
+Para todo resultado ADD, UPDATE ou SUPERSEDE, preserve ou refine `topic_paths`,
+`event_facet` e `topic_assignments`. `event_facet` contém apenas `subject`,
+`participants`, `action`, `objects`, `locations` e `state`.
+`topic_assignments` contém entradas `{subject, role, path}` específicas de um sujeito;
+cada segmento de path é `{name, type}` e type é `topic|facet|series|episode`.
+Os tipos seguem `topic -> facet -> series -> episode`; níveis podem ser pulados, mas
+tipos não podem se repetir nem voltar para trás.
+Use Series apenas para ocorrências repetidas de uma linha concreta de atividade/estado e
+Episode apenas para uma única ocorrência delimitada do mundo real. Nunca infira esses tipos pela
+profundidade, por uma tag ampla compartilhada ou por coocorrência não relacionada. Quando uma memória
+existente já tiver um caminho semanticamente equivalente e específico do sujeito, reutilize exatamente
+os nomes e tipos de nó dela em vez de criar uma bifurcação sinônima. Para pedir reutilização exata, produza
+`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
+"through":"topic|facet|series|episode"}]`. O ID referenciado deve aparecer em
+Memórias existentes. `through` significa copiar o prefixo desse caminho existente até o
+tipo estrutural indicado; um sufixo mais profundo escrito explicitamente continua sendo novo. A reutilização
+é proibida quando o sujeito, a linha concreta de atividade/estado ou o limite do Episode
+for diferente. Esses campos descrevem a memória, nunca uma forma de pergunta futura como
+"quando", "quantos" ou "quem".
+
+Series é uma relação estabelecida no reconcile: estabeleça-a somente quando a nova memória e
+pelo menos uma memória existente independente forem ocorrências distintas da mesma
+linha concreta de atividade/estado. Várias proposições da escrita atual não
+provam repetição.
+"""
+
+RECONCILE_FEW_SHOT = """
+###################
+Exemplos
+###################
+
+## Exemplo 1 — Uma nova memória: parte conflita com uma cadeia existente, parte não tem relação
+
+Memórias existentes:
+[
+ {"memory_id": "m1", "content": "O usuário trabalha como gerente de produto na Stripe.", "owner": "user", "history_versions": [{"content": "O usuário trabalha como gerente de produto em uma startup de fintech."}]}
+]
+Novas memórias:
+[
+ {"content": "O usuário saiu da Stripe e agora é líder de produto na Notion, e recentemente começou a fazer cerâmica nos fins de semana.", "owner": "user"}
+]
+
+Saída:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "m1", "content": "O usuário trabalha como líder de produto na Notion.", "supersede_reason": "o empregador mudou da Stripe para a Notion", "owner": "user", "tags": ["work"]},
+ {"op": "ADD", "content": "O usuário começou recentemente a fazer cerâmica nos fins de semana.", "owner": "user", "tags": ["hobby"]}
+]
+```
+UMA ÚNICA nova memória traz duas coisas: a mudança de emprego (mesma dimensão da cadeia de emprego existente m1, que já tem histórico → SUPERSEDE, torna-se a nova cabeça da cadeia) e um detalhe sem relação (cerâmica → ADD). Divida a memória única na op certa para cada parte — a nova cabeça descreve SOMENTE o estado do emprego, nunca a cerâmica.
+
+## Exemplo 2 — Agrupe duas memórias existentes não vinculadas + a nova mudança em uma cadeia de 3 nós
+
+Memórias existentes:
+[
+ {"memory_id": "a1", "content": "O usuário está aprendendo a tocar violão.", "owner": "user", "memory_at": "2024-02-10 09:00"},
+ {"memory_id": "a2", "content": "O usuário já consegue tocar algumas músicas inteiras no violão.", "owner": "user", "memory_at": "2024-09-05 09:00"}
+]
+Novas memórias:
+[
+ {"content": "O usuário agora se apresenta tocando violão em noites de microfone aberto locais.", "owner": "user"}
+]
+
+Saída:
+```json
+[
+ {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "O usuário se apresenta tocando violão em noites de microfone aberto locais.", "supersede_reason": "a habilidade no violão progrediu: aprendendo → tocando músicas → se apresentando ao vivo", "owner": "user", "tags": ["music", "hobby"]}
+]
+```
+a1 e a2 nunca foram vinculadas, mas acompanham a mesma dimensão (progresso no violão) e a nova memória é o passo mais recente. Agrupe-as com `memory_ids` em ordem da mais antiga→mais nova; elas se tornam uma cadeia de 3 nós (a1 ← a2 ← nova cabeça). O `content` da cabeça descreve SOMENTE o estado atual — não repete "aprendendo" nem "algumas músicas".
+
+## Exemplo 3 — A nova cabeça NÃO deve copiar o conteúdo da memória antiga
+
+Memórias existentes:
+[
+ {"memory_id": "c1", "content": "O usuário mora em um apartamento alugado de um quarto em Shibuya, Tóquio, paga ¥180.000/mês, adora a caminhada de 5 minutos até a estação, mas reclama que o lugar é barulhento à noite e não tem vaga de garagem.", "owner": "user"}
+]
+Novas memórias:
+[
+ {"content": "O usuário acabou de comprar e se mudar para uma casa de três quartos no subúrbio de Yokohama, com jardim e garagem para dois carros.", "owner": "user"}
+]
+
+Saída:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "c1", "content": "O usuário comprou e se mudou para uma casa de três quartos no subúrbio de Yokohama, com jardim e garagem para dois carros.", "supersede_reason": "a residência mudou de um apartamento alugado em Shibuya para uma casa própria em Yokohama", "owner": "user", "tags": ["housing"]}
+]
+```
+A nova memória faz SUPERSEDE de c1 e se torna a cabeça da cadeia. O `content` da cabeça descreve SOMENTE a nova casa em Yokohama. NÃO arraste os detalhes característicos do apartamento antigo (Shibuya, aluguel de ¥180.000, a caminhada até a estação, as reclamações de barulho/garagem) para o novo nó — eles claramente pertencem à residência antiga, não à nova. Eles ficam no histórico da cadeia e continuam recuperáveis; copiá-los tornaria a cabeça contraditória (alugando em Shibuya E sendo dono de uma casa em Yokohama ao mesmo tempo).
+
+## Exemplo 4 — Sujeitos diferentes nunca são mesclados, por mais parecida que seja a redação
+
+Memórias existentes:
+[
+ {"memory_id": "d1", "content": "O usuário toma café preto todas as manhãs.", "owner": "user"}
+]
+Novas memórias:
+[
+ {"content": "John toma café preto todas as manhãs.", "owner": "user"},
+ {"content": "O usuário agora toma café preto duas vezes por dia, de manhã e depois do almoço.", "owner": "user"}
+]
+
+Saída:
+```json
+[
+ {"op": "ADD", "content": "John toma café preto todas as manhãs.", "owner": "user", "tags": ["food"]},
+ {"op": "UPDATE", "memory_id": "d1", "content": "O usuário toma café preto duas vezes por dia, de manhã e depois do almoço.", "owner": "user", "tags": ["food"]}
+]
+```
+As duas novas memórias têm redação quase idêntica, mas sujeitos DIFERENTES. "John ..." é sobre outra pessoa, então é um ADD simples — nunca um UPDATE ou SUPERSEDE de d1, embora d1 diga quase a mesma coisa sobre o usuário. Somente a memória cujo sujeito também é "O usuário" pode ser mesclada com d1.
+
+## Exemplo 5 — Evento recorrente: atualize a contagem e mantenha uma linha do tempo (UPDATE, não ADD)
+
+Memórias existentes:
+[
+ {"memory_id": "i1", "content": "John machucou o tornozelo na temporada passada e precisou de afastamento e fisioterapia.", "owner": "user", "memory_at": "2023-05-21 19:48"}
+]
+Novas memórias:
+[
+ {"content": "John torceu o tornozelo de novo durante um jogo recente.", "owner": "user", "memory_at": "2023-10-13 13:50"}
+]
+
+Saída:
+```json
+[
+ {"op": "UPDATE", "memory_id": "i1", "content": "John machucou o tornozelo duas vezes: a primeira na temporada passada (por volta da temporada 2022–2023), precisando de afastamento e fisioterapia; a segunda durante um jogo por volta de 2023-10-13.", "owner": "user", "tags": ["health", "basketball", "injury"]}
+]
+```
+O mesmo tipo de evento acontecendo de novo → faça UPDATE da memória antiga. Informe a **contagem** e liste as ocorrências com as datas, quando conhecidas. NÃO faça ADD de um segundo fato "John machucou o tornozelo", e NÃO faça SUPERSEDE (a primeira lesão não deixou de ser verdadeira).
+"""
+
+
+
+# ================================================================
+# Working / coding memory (coding/)
+# ================================================================
+
+CODING_EXTRACT_PROMPT = """\
+Você extrai memórias de TRABALHO (WORKING) duradouras de um segmento de sessão de execução de tarefas.
+Uma sessão de "trabalho" é qualquer tarefa prática em que o usuário opera um computador /
+sistema por meio de ferramentas — isso abrange TANTO trabalho de software/código (escrever, depurar,
+refatorar, compilar, implantar, uso de API/biblioteca) QUANTO trabalho de sistema e operações
+(executar comandos shell/PowerShell, análise ou limpeza de disco/armazenamento, operações com
+arquivos e pastas, instalar/configurar software, configuração de ambiente/dispositivo,
+inspeção de saúde de hardware/disco, backup, agendamento/automação, processamento de dados).
+
+Você produz DUAS camadas a partir do MESMO segmento:
+
+ EXPERIENCES (procedural, "como fazer") — método reutilizável, extraído somente
+ quando ultrapassa a VALUE BAR abaixo. Um pacote (task, search_keys, solution,
+ boundary_envs).
+
+ FACT (episódico, "o que aconteceu desta vez") — EXATAMENTE UM registro DESTA
+ sessão: o que o usuário queria, como se procedeu, qual foi o resultado. Sem
+ value bar, mas nunca há mais de um.
+
+As duas camadas respondem a perguntas diferentes e são armazenadas separadamente. Um método
+que se generaliza vai em EXPERIENCES; a história desta sessão em particular —
+verdadeira apenas para este sistema / este projeto / agora — vai no FACT.
+
+═══════════════════════════════════════════════════════════════════
+VALUE BAR (SOMENTE EXPERIENCES) — NÃO ultrapasse este limite levianamente.
+═══════════════════════════════════════════════════════════════════
+Uma memória DEVE satisfazer TODOS os critérios:
+ (a) Resolve um problema que provavelmente se repetirá para o mesmo usuário
+ (b) A solução não é trivial: combina várias informações / etapas, OU
+ traz uma justificativa de decisão, OU registra uma solução alternativa conquistada
+ a duras penas, OU é um procedimento/receita reutilizável para uma tarefa operacional
+ (ex.: como analisar e limpar o uso de disco, como organizar arquivos em lote, como
+ inspecionar a saúde do hardware, como configurar um job agendado)
+ (c) Um futuro agente / usuário preferiria consultá-la a redescobri-la
+
+IMPORTANTE — tarefas de análise / diagnóstico / investigação CONTAM:
+Uma tarefa NÃO precisa fazer uma alteração nem "consertar" algo para valer a pena ser lembrada.
+Trabalho somente leitura / analítico / de solução de problemas é valioso quando seu PROCEDIMENTO ou
+CONCLUSÃO é reutilizável. Extraia explicitamente:
+ - Receitas de análise / diagnóstico: o procedimento reutilizável + o que ele revelou
+ (ex.: "como analisar quais pastas ocupam espaço no drive C" — os comandos de varredura,
+ as armadilhas encontradas e a descoberta). "Só produziu um relatório, nenhuma alteração"
+ NÃO é motivo para pular — o MÉTODO reutilizável é a memória.
+ - Resultados de investigação, INCLUINDO resultados negativos / não encontrados
+ (ex.: "procurou a pasta X em C: e D: com rg / fs_search / índice SQL —
+ não encontrada em lugar nenhum"). Um beco sem saída registrado poupa o próximo agente de
+ repetir a mesma busca infrutífera, então ultrapassa o limite.
+NÃO rejeite uma memória apenas porque "o assistente poderia regenerar os
+comandos" ou "nada foi de fato modificado". Se o procedimento ou a conclusão
+pouparia esforço futuro, mantenha-a.
+
+NÃO extraia:
+ - Operações de uma única etapa realmente triviais, sem procedimento reutilizável ("renomear um arquivo",
+ "git status", "rodar ls uma vez")
+ - Problemas pontuais já resolvidos, sem lição transferível
+ - Informações que já estão no repositório/sistema (não duplique o package.json)
+ - Tarefas descartáveis por PR / por sessão, a menos que codifiquem um padrão reutilizável
+ - O ato de PERGUNTAR AO USUÁRIO por informações faltantes. Pedir um parâmetro,
+ listar o que é desconhecido ou solicitar campos obrigatórios é comportamento
+ conversacional, não um método: todo agente já sabe fazer uma pergunta, então
+ não há nada a consultar depois. Nunca produza uma experience cuja task ou
+ search_keys tenham o formato "como pedir X", "reunir o Y que falta",
+ "solicitar campos obrigatórios", "o que esclarecer antes de começar". Note que isso
+ fica de fora apenas de EXPERIENCES — o fato de a sessão ter terminado esperando o usuário
+ é um estado real e pertence ao FACT.
+
+Se o segmento não fez nenhum progresso substancial porque travou esperando o
+usuário — o assistente apenas pediu parâmetros, ou foi bloqueado antes de fazer qualquer
+trabalho real — produza "experiences": [] e escreva apenas o FACT. Nada foi
+aprendido ainda, então não há método a armazenar. Isso importa mais do que parece:
+uma experience destilada de um travamento parece uma habilidade legítima na recuperação,
+e um segmento posterior da mesma tarefa vai corresponder a ela e perguntar ao usuário de novo
+em vez de prosseguir, de modo que o travamento se reproduz pelo resto da
+sessão. Julgue a substância pelo que as ferramentas realmente fizeram, não por o
+turno ter produzido um texto fluente.
+
+Heurística: se o usuário (ou um futuro agente fazendo o mesmo tipo de tarefa) gostaria
+de ter isso anotado em vez de descobrir de novo, mantenha. Um procedimento
+operacional de várias etapas (mesmo de sistema/ops ou de análise/busca somente leitura, não
+só código) geralmente se qualifica. Descarte-o somente se for um único comando que qualquer usuário
+encontraria via `--help` em 30 segundos E não trouxer nenhuma decisão/armadilha que valha a pena
+lembrar.
+
+═══════════════════════════════════════════════════════════════════
+CAMPOS DE EXPERIENCE
+═══════════════════════════════════════════════════════════════════
+
+task — Nome em formato de consulta; formule como o usuário PERGUNTARIA depois.
+ "publicar uma release na plataforma xx", não
+ "publish_release_internal"
+ Autocontido (sem "isto", "o arquivo", "nós").
+
+search_keys — 0 a 5 formulações alternativas que capturam aspectos importantes da
+ solution que `task` sozinho não cobriria. Formule como perguntas
+ ou temas SOBRE OS QUAIS futuros usuários PERGUNTARIAM. Diferentes de task.
+ Omita se task já cobre tudo.
+
+solution — Conteúdo completo e autocontido de que o usuário realmente precisa:
+ comandos, locais de credenciais (NÃO os VALORES das credenciais),
+ caminhos de arquivos, etapas ordenadas, armadilhas, justificativa das decisões.
+ Agregue trabalho de ponta a ponta em vários turnos em UMA solution se ele
+ formar uma tarefa coerente; divida em várias memórias somente quando
+ o usuário fez tarefas não relacionadas.
+
+boundary_envs — Fixação concreta da qual a solution depende, em várias linhas "chave: valor":
+ runtime / SDK / biblioteca + versão
+ endpoint de API ou assinatura de método
+ serviço externo / versão de middleware
+ NOME da variável de ambiente (não o valor)
+ caminho do arquivo de configuração
+ identificador de host / cluster / região
+ Se a solution não depender do ambiente, deixe "" (vazio).
+ Propósito: quando o SDK/middleware subjacente for atualizado, futuros
+ consumidores podem inspecionar isto para decidir se a solution ainda se aplica.
+
+confidence — 0.0 a 1.0
+ 1.0 o usuário declarou isto explicitamente como regra / instrução
+ 0.7 inferido com boa evidência a partir das ações das ferramentas
+ 0.5 inferido fracamente; uma única observação; incerto
+
+═══════════════════════════════════════════════════════════════════
+CAMPO FACT — EXATAMENTE UM por segmento, sem value bar
+═══════════════════════════════════════════════════════════════════
+
+Você escreve UM fact para o segmento inteiro — um registro de estado recuperável desta
+sessão, não uma retrospectiva polida e nunca uma lista de descobertas separadas. Um
+futuro agente deve conseguir retomar a partir dele sem confundir uma sugestão,
+inferência ou busca parcial com algo verificado.
+
+subject — QUEM ou O QUÊ é o assunto desta sessão: a única entidade sobre a qual ou
+ para a qual o trabalho foi feito. Um sintagma nominal curto, sem frase, sem verbo.
+ Escolha a entidade mais específica de que a sessão *trata*, não a
+ ferramenta que ela usou:
+ o nome de uma pessoa quando a sessão atende uma pessoa nomeada
+ ("Dylan", "Matthew")
+ o arquivo / módulo / símbolo quando o trabalho tem como alvo código
+ ("auth/middleware.ts", "parse_plan_text")
+ o serviço / host / dispositivo / drive para trabalho de ops
+ ("D:\\WXWork", "redis-cache-prod", "ci.yml")
+ Isto é uma CHAVE RÍGIDA, não prosa: duas sessões sobre pessoas diferentes
+ ou arquivos diferentes DEVEM ter subjects diferentes, e duas sessões
+ sobre o mesmo DEVEM ter a mesma string, escrita de forma idêntica.
+ Prefira o identificador exato como aparece no trace a uma
+ descrição dele. Se o segmento genuinamente não tiver um único subject,
+ produza "".
+
+ Por que importa: subject é a porta que decide se uma sessão posterior
+ pode sobrescrever esta como "a mesma tarefa,
+ continuada". Erre isso e o estado de uma pessoa substitui silenciosamente
+ o de outra.
+
+statement — Um registro compacto DESTA sessão. Duas partes, e a segunda é a
+ que se perde.
+ Preserve os dados de base da tarefa e as restrições concretas em vez de
+ substituí-los por uma avaliação genérica do resultado. Declare
+ cada regra uma vez: texto de instrução repetido compete com os dados
+ que a memória precisa reter.
+
+ PARTE 1 — o que aconteceu, cerca de 300 caracteres latinos (~150 CJK).
+ Comece com o objetivo e o objeto específicos ("recuperar espaço em disco ocupado
+ por D:\\WXWork", "localizar a pasta new_file_search"), não um genérico
+ "corrigir um bug" / "encontrar um arquivo". Depois, aproximadamente o que foi inspecionado,
+ tentado ou alterado. Depois, como terminou, com a semântica de exatamente um de:
+ concluído, parcialmente concluído, falhou, bloqueado ou
+ ainda aguardando verificação. Inclua resultados negativos e becos sem saída
+ sem exagerá-los.
+
+ PARTE 2 — os DADOS DE BASE DA TAREFA: tudo aquilo sobre o qual a tarefa INTEIRA se apoia,
+ mesmo quando este segmento não o estabeleceu e mesmo quando parece
+ elementar demais para ser dito. Vinculações (o que cada nome/símbolo/rótulo
+ representa), valores fixos que a tarefa fornece em vez de derivar,
+ convenções adotadas (base de indexação, unidades, fuso horário, padrões) e
+ o próprio resultado deste segmento COM o seu valor ("x = 7", não "o valor
+ foi calculado").
+
+ Escreva a PARTE 2 como dados, um item por linha, com os valores como foram dados:
+ orçamento de tentativas = 5; timeout 30s; índice começa em 0
+ entrada da etapa 3: n=64, tolerância 1e-6
+ slot B: tipo=privado, custo 688.7-721.3 por unidade
+ Uma linha deve ser quase inteiramente valores. Mantenha a notação do trace —
+ símbolos, unidades, números, grafias — e descarte as frases dele: remova
+ as expressões que anunciam um dado em vez de serem o dado ("eu
+ preferiria", "deve ficar em algum ponto entre … e …"). Elas se repetem uma vez
+ por item, então uma lista de 15 itens paga por elas 15 vezes.
+ Leve-os em TODO fact; nunca escreva "como acima" ou "igual à
+ sessão anterior" — a recuperação retorna alguns facts por
+ similaridade e o referente pode não estar entre eles.
+
+ Mire em menos de 1200 caracteres no total. Se a PARTE 2 não couber, corrija a
+ notação, nunca a cobertura: statement é o vetor de recuperação E
+ o único campo que um segmento posterior consegue ler (details não é
+ incorporado ao vetor nem injetado), então tudo o que for cortado dele se perde. Comprima a redação
+ em torno de um dado; nunca o dado.
+
+ O teste: se o próximo segmento não puder ver o material original, ele consegue
+ continuar apenas a partir deste registro? Só um sim conta. Uma vinculação ausente
+ não falha de forma ruidosa — o nome ainda parece significativo, então
+ é lido com o seu sentido de uso geral e a resposta que
+ segue é fluente e trata de outra pergunta.
+
+ IDIOMA — o mesmo idioma do trace da sessão: statement é o
+ vetor de recuperação e as consultas chegam no idioma de trabalho do usuário,
+ então outro idioma paga uma penalidade interlinguística em cada busca.
+
+ FIDELIDADE À EVIDÊNCIA — registre apenas ações realmente executadas e
+ evidências explicitamente presentes no trace. Preserve literalmente
+ comandos, flags, argumentos, erros e números relevantes.
+ NUNCA complete um comando com flags habituais, e nunca transforme
+ conselhos ou planos em ações:
+ "executou Get-ChildItem -Force" → "executou Get-ChildItem"
+ (o trace não continha `-Force`; não o invente)
+ Restrinja todo achado negativo ao que foi realmente pesquisado e
+ enumere TODOS os limites explícitos de cobertura que possam invalidá-lo,
+ especialmente falhas de permissão e limites de profundidade: mantenha as raízes,
+ os filtros e a profundidade que estavam em vigor ("não encontrado em C:\\ e
+ D:\\ com profundidade 3; alguns diretórios não foram cobertos por Access
+ denied"), nunca amplie para "não existe". Não omita nenhum limite
+ para deixar o registro mais bonito.
+ Nunca promova uma busca parcial a ausência global.
+ Uma tentativa bloqueada mantém o seu bloqueio.
+ Preserve a distinção entre tentado, observado, verificado,
+ inferido e não resolvido — expresse-a de forma natural ("tentou … mas foi
+ bloqueado por Access denied", "suspeita-se de …, ainda não verificado"), não como
+ rótulos. Sem saída de ferramenta ou confirmação explícita, NUNCA afirme que uma
+ correção deu certo, que uma causa foi estabelecida ou que um caminho não existe.
+
+ NÃO registre cumprimentos nem conversa pura — esse é o único caso que
+ recebe "fact": null. Um segmento que apenas declarou requisitos, ou
+ travou antes de fazer trabalho, ainda assim estabeleceu algo.
+
+details — A SAÍDA concreta da sessão, copiada literalmente. `statement` é
+ um resumo, e um resumo necessariamente descarta os valores individuais; uma
+ consulta posterior quase sempre quer um valor específico, não a ideia geral.
+ Então, qualquer resultado endereçável que esta sessão tenha produzido, reproduza-o
+ aqui em sua forma e estrutura originais:
+ um plano / cronograma / roteiro → mantenha cada linha, cada dia, cada
+ horário e cada preço exatamente como escritos
+ um bloco de configuração ou de código → mantenha o bloco
+ a saída relevante de um comando → mantenha as linhas que trazem as
+ descobertas (tamanhos, contagens, versões, texto de erro)
+ um resultado estruturado (tabela, lista de registros) → mantenha as linhas
+ Preserve o layout original — quebras de linha, prefixos `Day 1:` / chave: valor,
+ unidades, símbolos de moeda, ids. Não resuma de novo, não
+ reordene, não arredonde números, não traduza.
+
+ Copie SOMENTE o que está presente no trace. Nunca preencha uma lacuna: se um horário
+ ficou sem preencher, deixe-o sem preencher ou diga isso — um valor inventado
+ é pior do que um ausente, porque será recuperado e usado.
+ Limite de cerca de 4000 caracteres; se a saída for maior, mantenha as partes
+ que trazem valores concretos e descarte a prosa decorativa, anotando o que foi
+ descartado.
+
+ "" quando a sessão não produziu nenhum artefato desse tipo (investigação pura
+ ainda sem descobertas, ou um travamento esperando o usuário).
+
+ Este campo NÃO faz parte do vetor de recuperação — `statement` e
+ `subject` fazem a busca, `details` fornece o valor depois de encontrado.
+ Então não escreva iscas de recuperação aqui e não duplique o
+ resumo; escreva a coisa bruta.
+
+files — 0..N caminhos de ARQUIVO OU DIRETÓRIO, absolutos ou relativos ao repositório,
+ realmente manipulados ou investigados durante esta sessão. Mantenha raízes
+ investigadas como `C:\\` e `D:\\`. Inclua apenas caminhos que foram
+ realmente acessados/pesquisados, não caminhos apenas sugeridos ou planejados;
+ [] se nenhum se aplicar.
+═══════════════════════════════════════════════════════════════════
+CONTEXTO DO HOST (fornecido pelo SDK)
+═══════════════════════════════════════════════════════════════════
+- workspace_id presente: {workspace_present}
+- branch presente: {branch_present}
+
+Quando não há workspace_id, a solution não pode depender de contexto local do
+projeto que não foi declarado — explicite qualquer repositório / caminho / serviço de que ela precise dentro de
+`solution` ou `boundary_envs`, para que a memória continue utilizável por si só.
+
+═══════════════════════════════════════════════════════════════════
+CONVERSA
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+SAÍDA (somente JSON estrito, sem markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "subject": "...",
+ "statement": "...",
+ "files": ["..."],
+ "details": "..."
+ }}
+}}
+
+O PADRÃO É EXTRAIR. Quando o segmento fez trabalho real, você DEVE produzir pelo menos
+uma experience — mesmo que a tarefa pareça simples ou tenha sido um sucesso de primeira, ainda
+capture a essência reutilizável do que foi feito (o método / comando / como fazer).
+Quando a sessão for rala, a única experience mais valiosa é suficiente.
+
+A ÚNICA exceção é o caso de travamento acima: se o segmento não fez trabalho real
+porque ficou bloqueado pedindo ao usuário informações faltantes, produza
+"experiences": [] e escreva apenas o fact. Não fabrique uma experience para
+satisfazer esta instrução — uma experience fabricada ("como pedir a cidade de
+partida") é pior do que nenhuma, porque depois é recuperada e seguida. Vazio é
+permitido SOMENTE por esse motivo, nunca como atalho quando houve trabalho de fato.
+
+"fact" é um ÚNICO objeto, nunca uma lista — um registro por sessão.
+
+SEMPRE escreva o fact. O critério para o fact não é "isto foi valioso", mas "aconteceu
+alguma coisa", e um segmento que chega até você já passou nesse critério.
+Isso inclui segmentos que parecem preparação em vez de trabalho: uma única
+mensagem do usuário declarando requisitos, parâmetros ou um estado inicial, sem
+nenhuma ferramenta executada, é exatamente o material que uma sessão posterior não consegue reconstruir sozinha
+— escreva os requisitos, parâmetros e o estado inicial, junto com a situação, em `statement` (notação compacta,
+sem copiar as frases originais da conversa), e não os empurre para `details` (`details` não entra no vetor de
+recuperação e o lado de leitura também não o injeta). Use
+"fact": null SOMENTE para cumprimentos e conversa pura sem nenhum conteúdo.
+Na dúvida, escreva o fact: um registro desnecessário custa uma linha, enquanto um descartado
+custa todas as sessões posteriores que precisavam dele e não têm como saber que ele existiu.
+"""
+
+CODING_EXTRACT_PROMPT_CODING = """\
+╔═══════════════════════════════════════════════════════════════════════════╗
+║ RESTRIÇÃO RÍGIDA — leia isto antes de qualquer outra coisa; ela ║
+║ prevalece sobre qualquer formulação posterior neste prompt que pareça ║
+║ pedir uma narrativa. ║
+║ ║
+║ Você NÃO está escrevendo um relatório do que uma pessoa fez. Você está ║
+║ escrevendo o que um AGENTE FUTURO precisa para agir. Esse agente já tem a ║
+║ própria tarefa; não se importa com o que este usuário queria. Ele precisa ║
+║ saber: o que foi decidido aqui, em quais coordenadas de código, o que foi ║
+║ tentado e rejeitado, e se foi verificado. ║
+║ ║
+║ Concretamente, em todo `statement` e toda `solution`: ║
+║ · O sujeito gramatical é o CÓDIGO ou A DECISÃO — nunca "o usuário" e ║
+║ nunca "o agente". Não escreva "O usuário tentou…", ║
+║ "O usuário queria…", "O agente então verificou…". ║
+║ · Nunca termine com uma frase burocrática como "a sessão foi concluída",║
+║ "o erro foi anotado", "nenhuma solução foi encontrada ainda". Termine ║
+║ com a decisão e o seu status de verificação. Se nada foi decidido, ║
+║ termine com o que foi DESCARTADO e a próxima pista inexplorada — essa ║
+║ é a parte reutilizável. ║
+║ · Mantenha o sintoma concreto (string de erro, comando que falha, saída ║
+║ errada) — é nisso que uma busca futura vai bater. ║
+║ ║
+║ ruim: "O usuário tentou gravar uma QTable em RST com header_rows e ║
+║ recebeu um TypeError. A sessão foi concluída com o erro anotado." ║
+║ bom: "o writer RST de ascii.rst rejeita header_rows: ║
+║ `tbl.write(..., format='ascii.rst', header_rows=['name','unit'])` ║
+║ levanta TypeError porque RST.__init__ não o repassa, ao contrário ║
+║ de ascii.fixed_width, que o aceita. Nenhuma correção escrita — o ║
+║ writer precisa do mesmo encaminhamento de header_rows que ║
+║ fixed_width." ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+
+Você extrai memórias de TRABALHO (WORKING) duradouras de um segmento de sessão de execução de tarefas.
+Uma sessão de "trabalho" é qualquer tarefa prática em que o usuário opera um computador /
+sistema por meio de ferramentas — isso abrange TANTO trabalho de software/código (escrever, depurar,
+refatorar, compilar, implantar, uso de API/biblioteca) QUANTO trabalho de sistema e operações
+(executar comandos shell/PowerShell, análise ou limpeza de disco/armazenamento, operações com
+arquivos e pastas, instalar/configurar software, configuração de ambiente/dispositivo,
+inspeção de saúde de hardware/disco, backup, agendamento/automação, processamento de dados).
+
+Você produz DUAS camadas a partir do MESMO segmento:
+
+ EXPERIENCES (procedural, "como fazer") — método reutilizável, extraído somente
+ quando ultrapassa a VALUE BAR abaixo. Um pacote (task, search_keys, solution,
+ boundary_envs).
+
+ FACT (episódico, "o que ficou estabelecido desta vez") — EXATAMENTE UM registro DESTA
+ sessão. NÃO é uma narrativa do que o usuário fez. Ele registra, nesta ordem:
+ a tarefa e o seu sintoma concreto (é isso que a torna encontrável depois), as
+ coordenadas de código, O QUE FOI ADOTADO e o que foi rejeitado, e até onde isso foi
+ verificado. Sem value bar, mas nunca há mais de um.
+
+As duas camadas respondem a perguntas diferentes e são armazenadas separadamente. Um método
+que se generaliza vai em EXPERIENCES; a história desta sessão em particular —
+verdadeira apenas para este sistema / este projeto / agora — vai no FACT.
+
+═══════════════════════════════════════════════════════════════════
+VALUE BAR (SOMENTE EXPERIENCES) — NÃO ultrapasse este limite levianamente.
+═══════════════════════════════════════════════════════════════════
+Uma memória DEVE satisfazer TODOS os critérios:
+ (a) Resolve um problema que provavelmente se repetirá para o mesmo usuário
+ (b) A solução não é trivial: combina várias informações / etapas, OU
+ traz uma justificativa de decisão, OU registra uma solução alternativa conquistada
+ a duras penas, OU é um procedimento/receita reutilizável para uma tarefa operacional
+ (ex.: como analisar e limpar o uso de disco, como organizar arquivos em lote, como
+ inspecionar a saúde do hardware, como configurar um job agendado)
+ (c) Um futuro agente / usuário preferiria consultá-la a redescobri-la
+
+IMPORTANTE — tarefas de análise / diagnóstico / investigação CONTAM:
+Uma tarefa NÃO precisa fazer uma alteração nem "consertar" algo para valer a pena ser lembrada.
+Trabalho somente leitura / analítico / de solução de problemas é valioso quando seu PROCEDIMENTO ou
+CONCLUSÃO é reutilizável. Extraia explicitamente:
+ - Receitas de análise / diagnóstico: o procedimento reutilizável + o que ele revelou
+ (ex.: "como analisar quais pastas ocupam espaço no drive C" — os comandos de varredura,
+ as armadilhas encontradas e a descoberta). "Só produziu um relatório, nenhuma alteração"
+ NÃO é motivo para pular — o MÉTODO reutilizável é a memória.
+ - Resultados de investigação, INCLUINDO resultados negativos / não encontrados
+ (ex.: "procurou a pasta X em C: e D: com rg / fs_search / índice SQL —
+ não encontrada em lugar nenhum"). Um beco sem saída registrado poupa o próximo agente de
+ repetir a mesma busca infrutífera, então ultrapassa o limite.
+NÃO rejeite uma memória apenas porque "o assistente poderia regenerar os
+comandos" ou "nada foi de fato modificado". Se o procedimento ou a conclusão
+pouparia esforço futuro, mantenha-a.
+
+NÃO extraia:
+ - Operações de uma única etapa realmente triviais, sem procedimento reutilizável ("renomear um arquivo",
+ "git status", "rodar ls uma vez")
+ - Problemas pontuais já resolvidos, sem lição transferível
+ - Informações que já estão no repositório/sistema (não duplique o package.json)
+ - Tarefas descartáveis por PR / por sessão, a menos que codifiquem um padrão reutilizável
+
+Heurística: se o usuário (ou um futuro agente fazendo o mesmo tipo de tarefa) gostaria
+de ter isso anotado em vez de descobrir de novo, mantenha. Um procedimento
+operacional de várias etapas (mesmo de sistema/ops ou de análise/busca somente leitura, não
+só código) geralmente se qualifica. Descarte-o somente se for um único comando que qualquer usuário
+encontraria via `--help` em 30 segundos E não trouxer nenhuma decisão/armadilha que valha a pena
+lembrar.
+
+═══════════════════════════════════════════════════════════════════
+TRABALHO COM CÓDIGO — o que um agente futuro não consegue derivar de novo, então DEVE ser registrado
+═══════════════════════════════════════════════════════════════════
+Quando o segmento é trabalho de software em um repositório, o método reutilizável é apenas
+metade. A outra metade é ONDE o trabalho está e QUAL VERSÃO venceu. Isso
+não pode ser recuperado lendo o código depois — o código mostra o estado atual,
+não em qual branch ele está, nem o que já foi rejeitado.
+
+Esta seção NÃO pede um registro mais longo. Ela pede que você GASTE O MESMO
+ORÇAMENTO em tokens de maior valor: descarte objetivos repetidos, a narração do que o
+assistente "então decidiu", e código colado que você está apenas ecoando; gaste esses
+caracteres nos quatro itens abaixo. Um registro que omite a branch mas
+cita 30 linhas de diff é uma troca ruim.
+
+1. BRANCH / LOCAL DE TRABALHO — literalmente, no `statement` do fact. Se o segmento
+ menciona ou faz checkout de `feat/x` / `fix/y`, esse token DEVE aparecer. Um agente
+ que retoma na branch errada produz alterações que são descartadas silenciosamente,
+ então esse único token supera qualquer outro detalhe.
+
+2. QUAL VERSÃO VENCEU — quando o usuário mudou de ideia, nomeie a vencedora e marque
+ a perdedora em uma única oração: "adotou-se A; a versão intermediária B foi descartada". Não ambas
+ por extenso — uma oração. Manter só a mais recente é errado: um agente que encontra o
+ código rejeitado precisa reconhecê-lo, senão vai "consertar" as coisas de volta para a
+ variante descartada. Expressões como `esquece isso / volta para / na verdade, vamos / não, isso não`
+ (`scratch that / go back to / actually, let's / no, not that`) marcam isso: o que vem
+ depois é o que vale, o que vem antes foi substituído.
+
+3. COORDENADAS EXATAS, NÃO CÓDIGO COLADO — caminho relativo ao repositório
+ (`qutebrowser/utils/debug.py`, nunca só `debug.py`) mais a função /
+ classe alterada. Se uma assinatura mudou, dê a nova assinatura. Se uma constante,
+ regex ou literal foi decidido, cite ISSO literalmente — mas cite só isso, não o
+ bloco ao redor. Uma linha precisa vale mais que um parágrafo de aproximação.
+
+4. VERIFICADO vs APENAS ESCRITO — quatro palavras bastam ("testes executados e passando" /
+ "confirmado só pelo git diff, testes não executados"). "a edição está feita" e "a edição está feita
+ e testada" levam um agente futuro a fazer coisas bem diferentes em seguida.
+
+Antipadrão — resumir o objetivo e descartar as coordenadas:
+ ruim: "refatorou a lógica de parsing de cores para ficar mais limpa."
+ bom: "em feat/q4, em qutebrowser/config/configtypes.py QtColor._parse_value:
+ adotou-se `mult = 360.0 if kind == 'h' else 255.0`; a versão intermediária que
+ usava 255.0 para tudo foi descartada. Testes não executados."
+ (o bom é MAIS CURTO do que a maioria dos ruins — ele só gasta cada caractere
+ em algo que não pode ser derivado de novo)
+
+═══════════════════════════════════════════════════════════════════
+CAMPOS DE EXPERIENCE
+═══════════════════════════════════════════════════════════════════
+
+task — Nome em formato de consulta; formule como o usuário PERGUNTARIA depois.
+ "publicar uma release na plataforma xx", não "publish_release_internal"
+ Autocontido (sem "isto", "o arquivo", "nós").
+
+search_keys — 0 a 5 formulações alternativas que capturam aspectos importantes da
+ solution que `task` sozinho não cobriria. Formule como perguntas
+ ou temas SOBRE OS QUAIS futuros usuários PERGUNTARIAM. Diferentes de task.
+ Omita se task já cobre tudo.
+
+solution — Conteúdo completo e autocontido de que o usuário realmente precisa:
+ comandos, locais de credenciais (NÃO os VALORES das credenciais),
+ caminhos de arquivos, etapas ordenadas, armadilhas, justificativa das decisões.
+ Agregue trabalho de ponta a ponta em vários turnos em UMA solution se ele
+ formar uma tarefa coerente; divida em várias memórias somente quando
+ o usuário fez tarefas não relacionadas.
+
+boundary_envs — Fixação concreta da qual a solution depende, em várias linhas "chave: valor":
+ runtime / SDK / biblioteca + versão
+ endpoint de API ou assinatura de método
+ serviço externo / versão de middleware
+ NOME da variável de ambiente (não o valor)
+ caminho do arquivo de configuração
+ identificador de host / cluster / região
+ Se a solution não depender do ambiente, deixe "" (vazio).
+ Propósito: quando o SDK/middleware subjacente for atualizado, futuros
+ consumidores podem inspecionar isto para decidir se a solution ainda se aplica.
+
+confidence — 0.0 a 1.0
+ 1.0 o usuário declarou isto explicitamente como regra / instrução
+ 0.7 inferido com boa evidência a partir das ações das ferramentas
+ 0.5 inferido fracamente; uma única observação; incerto
+
+═══════════════════════════════════════════════════════════════════
+CAMPO FACT — EXATAMENTE UM por segmento, sem value bar
+═══════════════════════════════════════════════════════════════════
+
+Você escreve UM fact para o segmento inteiro — um registro de estado recuperável desta
+sessão, não uma retrospectiva polida e nunca uma lista de descobertas separadas. Um
+futuro agente deve conseguir retomar a partir dele sem confundir uma sugestão,
+inferência ou busca parcial com algo verificado.
+
+statement — Um resumo compacto DESTA sessão. Ele tem duas funções ao mesmo tempo e
+ deve cumprir AMBAS: é o vetor de recuperação (um agente futuro o encontra
+ buscando com um novo relato de problema, formulado do jeito que um usuário
+ descreve um problema), e é o conteúdo sobre o qual esse agente vai agir. Então:
+
+ ABRA com a tarefa e o sintoma, nas palavras que um usuário usaria.
+ É isso que o torna encontrável — mantenha a forma superficial próxima de como
+ o problema seria relatado. Nomeie o objetivo e o objeto específicos
+ ("recuperar espaço em disco em D:\\WXWork", "ajustar o multiplicador de matiz
+ em QtColor._parse_value em feat/q4", "localizar a pasta
+ new_file_search"), nunca um genérico "corrigir um bug" / "procurar um arquivo". Inclua
+ o sintoma concreto: a string de erro, o comando que falha, a
+ saída errada.
+
+ DEPOIS dê as coordenadas e a decisão.
+ caminho relativo ao repositório, símbolo e branch para trabalho com código. Diga o que foi
+ ADOTADO e, na mesma oração, marque o que foi descartado
+ ("adotou-se X; a versão intermediária Y foi descartada"). Esta é a parte que
+ não pode ser derivada de novo lendo o código — o código só mostra a
+ vencedora, nunca que Y foi tentada e rejeitada. Um agente que encontrar a
+ variante rejeitada depois precisa conseguir reconhecê-la, senão vai
+ "consertar" o código de volta para a versão descartada.
+
+ FECHE com o status da evidência.
+ Exatamente um de: concluído, parcialmente concluído, falhou, bloqueado ou
+ ainda aguardando verificação — mais como foi verificado ("testes executados e
+ passando" / "confirmado só pelo git diff, testes não executados"). Inclua
+ resultados negativos e becos sem saída sem exagerá-los.
+
+ ⚠️ Nunca pare na narrativa. "O usuário tentou X e recebeu o erro Y; nenhuma
+ solução encontrada ainda" é um registro desperdiçado: ele é recuperado sem problema, mas não dá a um
+ agente futuro nada sobre o que agir. Se a sessão genuinamente não chegou a nenhuma
+ decisão, diga o que foi descartado e qual é a próxima pista inexplorada —
+ essa é a parte reutilizável.
+
+ O sujeito das frases deve ser o código e a decisão, não
+ "o usuário". De 2 a 4 frases, prosa corrida, sem seções rotuladas.
+ Teto rígido de ~400 caracteres latinos (~200 caracteres CJK).
+
+ FIDELIDADE À EVIDÊNCIA — obrigatória:
+ - Registre apenas ações realmente executadas e evidências explicitamente
+ presentes no trace. Preserve literalmente comandos, flags,
+ argumentos, erros e números relevantes. NUNCA complete um
+ comando com flags habituais nem transforme conselhos/planos em ações.
+ - Preserve a distinção entre tentado, observado, verificado,
+ inferido e não resolvido. Não acrescente esses rótulos à prosa;
+ expresse o seu sentido de forma natural, ex.: "tentou … mas foi bloqueado por
+ Access denied" ou "suspeita-se de … , ainda não verificado".
+ - Sem saída de ferramenta ou confirmação explícita, NUNCA afirme que uma correção
+ deu certo, que uma causa foi estabelecida, que um arquivo/pasta não
+ existe ou que os testes passaram.
+ - Restrinja todo achado negativo ao que foi realmente pesquisado e
+ enumere TODOS os limites explícitos de cobertura que possam invalidá-lo,
+ especialmente falhas de permissão e a profundidade máxima de busca:
+ "não encontrado nas partes pesquisadas de C:\\ e D:\\; alguns
+ diretórios foram pulados por Access denied, e a busca também tinha
+ limite de profundidade". Não omita nenhum limite para deixar o
+ resumo mais bonito. Nunca promova uma busca parcial a ausência
+ global.
+ - Afirme causalidade como certa somente quando o trace a verificar
+ diretamente. Caso contrário, mantenha a ressalva ("suspeita-se" / "inferido" / "ainda não
+ verificado"); não reescreva uma
+ suposição de teste incorreta como a causa raiz do sistema.
+
+ CRÍTICO — este texto É o vetor de recuperação, e é a única
+ coisa com a qual uma consulta futura é comparada. Um resumo genérico não
+ vale nada, porque TODA sessão parece um resumo genérico: ele
+ corresponderia a todas as consultas e não responderia a nenhuma. Então você DEVE nomear
+ as âncoras concretas que tornam ESTA sessão encontrável — caminhos reais de
+ arquivos, nomes de funções / símbolos, nomes de branches, comandos, strings de
+ erro, versões, chaves e valores de configuração, nomes de hosts / serviços.
+ Se alguém depois buscar qualquer um desses detalhes específicos, este
+ resumo tem de ser o que volta.
+ bom: "corrigindo um `npm run build` que falha no CI. Leu
+ .github/workflows/ci.yml e package.json; rastreou até o webpack
+ 5.74 batendo em ERR_OSSL_EVP_UNSUPPORTED no node 18. Subir o
+ node do workflow para 20 fez o build passar; o node 18 ainda
+ reproduz localmente."
+ bom: "na branch feat/q0, em qutebrowser/utils/debug.py signal_name:
+ PyQt<5.11 só expõe o nome via repr(sig), e o repr vem em
+ uma forma com colchetes e outra com parênteses. Adotaram-se dois padrões
+ tentados em ordem com fullmatch, parando no primeiro acerto; a
+ versão com uma única regex foi descartada. Confirmado pelo git diff, testes não
+ executados."
+ ruim: "o usuário queria um bug de build corrigido, o agente olhou alguns arquivos
+ de configuração, mudou algum código e corrigiu."
+ (sem caminho, sem comando, sem string de erro, sem versão — nada
+ para recuperar; toda sessão fica exatamente assim)
+ ruim: "corrigiu o problema de compatibilidade no parsing de nomes de sinais em uma
+ branch de feature."
+ (qual branch? qual arquivo? qual função? qual das duas
+ versões concorrentes venceu? nada aqui sobrevive a ser
+ recuperado uma semana depois)
+ Exemplos de fidelidade (ruim → bom):
+ "executou Get-ChildItem -Force" → "executou Get-ChildItem"
+ (o trace não continha `-Force`; não o invente)
+ "confirmou que new_file_search não existe" →
+ "new_file_search não foi encontrada nas partes pesquisadas de C:\\ e
+ D:\\; alguns diretórios foram pulados por Access denied ou pelo limite
+ de profundidade, então a investigação está só parcialmente feita"
+ "payloads idênticos causam um erro de lock espúrio" →
+ "o script de verificação supunha que o último escritor é sempre um rank
+ fixo; essa suposição não se sustenta, então ainda não foi verificado se há
+ um bug de lock"
+
+ NÃO registre cumprimentos nem conversa pura. Se o segmento não
+ estabeleceu absolutamente nada, produza "fact": null.
+
+files — 0..N caminhos de ARQUIVO OU DIRETÓRIO, absolutos ou relativos ao repositório,
+ realmente manipulados ou investigados durante esta sessão. Mantenha raízes
+ investigadas como `C:\\` e `D:\\`. Inclua apenas caminhos que foram
+ realmente acessados/pesquisados, não caminhos apenas sugeridos ou planejados;
+ [] se nenhum se aplicar.
+
+═══════════════════════════════════════════════════════════════════
+CONTEXTO DO HOST (fornecido pelo SDK)
+═══════════════════════════════════════════════════════════════════
+- workspace_id presente: {workspace_present}
+- branch presente: {branch_present}
+
+Quando não há workspace_id, a solution não pode depender de contexto local do
+projeto que não foi declarado — explicite qualquer repositório / caminho / serviço de que ela precise dentro de
+`solution` ou `boundary_envs`, para que a memória continue utilizável por si só.
+
+═══════════════════════════════════════════════════════════════════
+CONVERSA
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+SAÍDA (somente JSON estrito, sem markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "statement": "...",
+ "files": ["..."]
+ }}
+}}
+
+OBRIGATÓRIO: Você DEVE produzir pelo menos UMA experience. NÃO retorne uma lista vazia.
+Mesmo que a tarefa pareça simples ou tenha sido um sucesso de primeira, ainda capture a
+essência reutilizável do que foi feito (o método / comando / como fazer). Apenas a
+única experience mais valiosa é exigida quando a sessão for rala — mas nunca
+produza um array "experiences" vazio.
+
+"fact" é um ÚNICO objeto, nunca uma lista — um registro por sessão. Use
+"fact": null somente quando o segmento for pura conversa que não estabeleceu nada.
+"""
+
+CODING_RECONCILE_PROMPT = """\
+Você decide como mesclar novos rascunhos de memória de código com as memórias existentes do usuário.
+
+Para cada novo rascunho, decida um de:
+ ADD — nenhuma memória existente descreve a mesma tarefa/aspecto
+ UPDATE — uma memória existente descreve a mesma tarefa; o novo rascunho a substitui
+ (a solution pode ter mudado, o ambiente pode ter sido atualizado etc.)
+ SKIP — duplicata de uma existente; nada de novo
+
+Além disso, você pode emitir ops DELETE sobre candidatos existentes quando o novo
+conteúdo os tornar obsoletos ou inválidos:
+ DELETE — a nova conversa EXPLICITAMENTE substitui/cancela/invalida uma
+ memória existente que não pode ser corrigida via UPDATE. Exemplos:
+ * o usuário diz "não use mais X" e X só está presente como uma
+ memória separada (não a que está sendo adicionada/atualizada)
+ * o boundary_envs do candidato (serviço / endpoint / SDK) deixou de existir
+ e a nova conversa confirma a descontinuação
+
+Regras:
+- "Mesma tarefa" significa que a memória existente e o novo rascunho seriam ambos respostas
+ válidas para a mesma consulta futura do usuário.
+- Se a solution for diferente, prefira UPDATE (não mantemos histórico).
+- Se tanto a task quanto a solution corresponderem de perto, SKIP.
+- DELETE somente quando houver evidência EXPLÍCITA de que o candidato é inválido/obsoleto.
+ Nunca faça DELETE só porque um candidato parece "velho".
+- As ops de saída podem ser mais numerosas que os rascunhos quando houver DELETEs.
+
+═══════════════════════════════════════════════════════════════════
+NOVOS RASCUNHOS
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+CANDIDATOS EXISTENTES (por rascunho, recuperados por similaridade de task)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+SAÍDA (somente JSON estrito, sem 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": "o usuário descontinuou Y explicitamente"}},
+ {{"draft_idx": 2, "action": "SKIP", "reason": "duplicata"}}
+ ]
+}}
+
+Se não houver rascunhos, produza {{"ops": []}}.
+"""
+
+CODING_FACT_RECONCILE_PROMPT = """\
+Você mantém WORKING FACTS no nível de sessão. Cada statement resume um
+trace/sessão inteiro: a tarefa do usuário, a abordagem geral e o resultado. Não é uma
+afirmação atômica.
+
+Todo novo fact de sessão abaixo SERÁ armazenado; essa decisão não é sua. Sua única
+função é detectar continuação de tarefa: a nova sessão está dando continuidade à
+MESMA tarefa do usuário que um fact de sessão existente? Se sim, faça SUPERSEDE do fact mais antigo para
+que os vínculos formem uma cadeia de progresso entre sessões para essa tarefa.
+
+Marque um fact existente como substituído SOMENTE quando houver evidência forte de que:
+ - Os subjects coincidem: ambos os registros tratam da MESMA entidade — a mesma
+ pessoa, o mesmo arquivo/módulo, o mesmo host/serviço. Um subject compartilhado é
+ necessário, mas não suficiente; E
+ - O objetivo do usuário é materialmente o MESMO, não apenas do mesmo tema/projeto;
+ E
+ - O novo trace continua, tenta de novo, estende, verifica ou conclui o trabalho
+ registrado pelo trace existente.
+
+NÃO faça supersede quando:
+ - Os dois registros nomeiam subjects diferentes. Duas pessoas de um grupo, dois arquivos
+ de um módulo, dois hosts de um cluster são PARALELOS, não sucessivos: o estado de uma
+ pessoa não é uma versão mais nova do de outra. Quando um subject aparecer
+ como (unspecified), recorra a julgar apenas pelo statement.
+ - As sessões apenas mencionam o mesmo arquivo, símbolo, componente, repositório,
+ erro ou tecnologia, mas buscam objetivos de usuário diferentes.
+ - Uma tarefa apenas fornece contexto ou uma técnica para outra tarefa.
+ - A relação é incerta. Seja conservador: INSERT é o padrão seguro;
+ mesclar sessões não relacionadas destrói o histórico separado de cada tarefa.
+
+Trate cada statement como texto limitado pela evidência. Não reinterprete uma inferência
+contida nele como causa estabelecida nem use uma conjectura/erro compartilhado como prova de que
+os objetivos do usuário são os mesmos. Sua decisão diz respeito apenas à continuação da tarefa; não
+"corrija", complete nem enfeite nenhum dos registros de sessão.
+
+Exemplos:
+ existente: "O usuário precisava corrigir o npm run build do CI; rastreou até
+ ERR_OSSL_EVP_UNSUPPORTED no Node 18, workflow ainda não alterado."
+ novo: "O usuário continuou corrigindo o mesmo build do CI; subiu o Node em
+ .github/workflows/ci.yml para 20 e o npm run build passou."
+ → SUPERSEDE
+
+ existente: "O usuário precisava corrigir o tratamento de expiração de JWT em
+ auth/middleware.ts; a lógica de refresh foi adicionada."
+ novo: "O usuário precisava adicionar logs de desempenho a
+ auth/middleware.ts; foi introduzida uma métrica de latência."
+ → manter ambos
+ (mesmo arquivo/projeto, objetivo do usuário diferente)
+
+═══════════════════════════════════════════════════════════════════
+NOVOS FACTS DE SESSÃO
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+FACTS DE SESSÃO EXISTENTES (por novo fact, recuperados por similaridade de statement)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+SAÍDA (somente JSON estrito, sem markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "ops": [
+ {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "continua a mesma tarefa de correção do CI"}},
+ {{"draft_idx": 1, "supersedes": []}}
+ ]
+}}
+
+Use somente ids de fact que aparecem na lista de candidatos daquele mesmo draft_idx.
+Se nada for substituído em lugar nenhum, produza {{"ops": []}}.
+"""
+
+CODING_CHAIN_SUMMARY_PROMPT = """\
+Uma tarefa do usuário em um repositório de memória de trabalho progrediu ao longo de várias sessões. Abaixo estão
+os resumos de sessão na cadeia de progresso dessa tarefa, do mais antigo ao mais novo, terminando com
+a sessão atual.
+
+Resuma como a MESMA tarefa progrediu ao longo das sessões até o seu estado atual.
+Cubra cada etapa importante em ordem cronológica. Para cada etapa, preserve,
+quando disponíveis: a ação ou alteração real, o seu resultado direto e qualquer
+problema não resolvido ou condição limitante. Termine com um status atual explícito.
+
+Regras:
+ - Isto é apenas compressão. Relate SOMENTE o que as entradas dizem; nunca acrescente nem
+ complete um comando, causa, motivo, ação, resultado de teste, estado de sucesso ou
+ conclusão negativa global.
+ - Preserve exatamente o status da evidência: tentado não é concluído, observado não é
+ verificado, inferido não é estabelecido, e não resolvido continua não resolvido.
+ Mantenha as palavras de incerteza e os limites de busca/permissão/cobertura.
+ - Declare fielmente o status final atual (concluído, parcialmente concluído,
+ falhou, bloqueado ou ainda aguardando verificação). Nunca o promova com base em
+ uma história causal plausível ou em uma entrada posterior que não o verificou.
+ - Quando as entradas mencionarem uma causa suspeita e um resultado posterior, conecte-os
+ causalmente somente se alguma entrada disser diretamente que essa causa foi verificada.
+ - Preserve âncoras concretas de recuperação: caminhos de arquivos, símbolos, comandos, strings
+ de erro, versões, chaves/valores de configuração e valores numéricos importantes que
+ importam para o progresso.
+ - Para cadeias de 2-3 gerações, não comprima demais a progressão em uma só
+ frase. Prefira 2-4 parágrafos compactos quando útil, ou prosa legível com
+ um objetivo de tarefa claro, a progressão etapa por etapa e o status atual.
+ - Não copie mecanicamente o histórico completo. Omita repetições e detalhes de baixo valor,
+ mantendo as ações importantes, os resultados diretos e as pendências.
+ - Não invente títulos de etapa nem datas. Mencione uma data somente quando as entradas
+ a tornarem significativa; timestamps soltos são ruído.
+ - Se as entradas disserem que revisões mais antigas foram omitidas, declare explicitamente que
+ o histórico anterior foi omitido; não dê a entender que as entradas fornecidas estão completas.
+ - Escreva no mesmo idioma em que as entradas estão escritas.
+ - Sem preâmbulo e sem aspas em volta.
+
+Exemplo
+ entradas:
+ (2026-07-20) O usuário precisava corrigir o npm run build do CI; rastreou até
+ ERR_OSSL_EVP_UNSUPPORTED no Node 18, workflow ainda não
+ alterado.
+ (2026-07-24) O usuário continuou essa correção do CI; subiu o Node em
+ .github/workflows/ci.yml para 20, mas o cache de dependências
+ ainda reproduzia o erro antigo.
+ (now) O usuário continuou verificando a mesma correção; depois de limpar o
+ cache do npm, o npm run build passou.
+ saída:
+ O objetivo da tarefa é corrigir o npm run build do CI. Primeiro, o problema foi rastreado até
+ ERR_OSSL_EVP_UNSUPPORTED no Node 18, com o workflow ainda não alterado;
+ depois, .github/workflows/ci.yml foi atualizado para o Node 20, mas o cache de
+ dependências manteve o erro antigo. Por fim, depois de limpar o cache do npm,
+ o npm run build passou, então esta correção do build está atualmente verificada como concluída.
+
+═══════════════════════════════════════════════════════════════════
+ENTRADAS
+═══════════════════════════════════════════════════════════════════
+{chain_block}
+
+═══════════════════════════════════════════════════════════════════
+SAÍDA (apenas o próprio resumo, nada mais)
+═══════════════════════════════════════════════════════════════════
+"""
+
+
+# ================================================================
+# Episode / topic summaries
+# ================================================================
+
+EPISODE_SUMMARY_PROMPT = """Você está resumindo UM episódio de conversa com o usuário.
+
+Um episódio é um único trecho de discussão — um assunto sobre o qual se conversou,
+possivelmente ao longo de várias sessões de escrita.
+
+## Memórias registradas durante este episódio (da mais antiga → mais nova)
+
+{memories}
+
+---
+
+Escreva um único resumo denso do que aconteceu / do que foi discutido neste episódio.
+
+Regras:
+
+* 2–4 frases, em terceira pessoa, começando com "O usuário ..." (ou com a pessoa nomeada,
+ se as memórias forem sobre outra pessoa).
+* Amarre as memórias em um relato coerente — um episódio geralmente tem um
+ fio condutor (um plano, um problema, um passeio, uma decisão).
+* Preserve detalhes concretos: nomes, lugares, números, datas.
+* NÃO invente nada que não esteja nas memórias.
+* NÃO enumere as memórias uma a uma; sintetize-as.
+* O idioma de saída deve ser o mesmo das memórias.
+
+Retorne SOMENTE o texto do resumo, sem preâmbulo, sem JSON, sem aspas."""
+
+TOPIC_SUMMARY_PROMPT = """Você está resumindo tudo o que se sabe sobre UM tema.
+
+## Tema
+
+{topic_name}
+
+## Memórias sob este tema (da mais antiga → mais nova)
+
+{memories}
+
+---
+
+Escreva um único resumo denso do que se sabe sobre o usuário em relação a este
+tema.
+
+Regras:
+
+* 2–4 frases, em terceira pessoa, começando com "O usuário ..." (ou com a pessoa nomeada,
+ se as memórias forem sobre outra pessoa).
+* Cubra o tema como um todo — descreva a situação atual e mencione como ela
+ se desenvolveu somente quando a mudança importar.
+* Preserve detalhes concretos: nomes, lugares, números, datas.
+* NÃO invente nada que não esteja nas memórias.
+* NÃO enumere as memórias uma a uma; sintetize-as.
+* O idioma de saída deve ser o mesmo das memórias.
+
+Retorne SOMENTE o texto do resumo, sem preâmbulo, sem JSON, sem aspas."""
+
+
+# ================================================================
+# System 2 evolve (pipelines/system2_agent.py)
+# ================================================================
+
+SYSTEM2_AGENT_PROMPT = """Você é um Agente de processamento cognitivo. Sua função é evoluir estruturas cognitivas de ordem superior a partir dos dados de memória brutos de um usuário.
+
+## Arquitetura de memória
+
+### VDB (Banco de Dados Vetorial) — somente leitura
+| Camada | Descrição |
+|-------|-------------|
+| L0 BASIC_INFO | Atributos do usuário (nome, idade, profissão) |
+| L1 RAW | Transcrições originais das conversas |
+| L2 FACT | Fatos atômicos extraídos das conversas |
+| L3 SUMMARY | Resumos de sessão |
+| L4 IDENTITY | Traços de identidade, preferências, hábitos |
+| L5 KNOWLEDGE | Conhecimento de domínio |
+
+### Graph (Grafo de Conhecimento) — você é o único escritor
+| Camada | Descrição |
+|-------|-------------|
+| L6 SCHEMA | Padrões de comportamento — ligados a um domínio, atômicos, imutáveis depois de criados |
+
+## O que é um Schema L6?
+
+Um Schema é um padrão de comportamento que atravessa vários eventos no modelo de longo prazo do usuário e
+contém os três componentes a seguir:
+
+
+- **Circunstância**: O domínio/tema/situação em que esse padrão é observado. Um Schema DEVE permanecer dentro de sua circunstância — NÃO generalize entre domínios. A abstração entre domínios é tratada separadamente pelo sistema.
+- **Padrão**: O comportamento habitual, o estilo de pensamento ou a tendência de ação do usuário nessa circunstância.
+- **Insight**: O motor psicológico subjacente ou o modelo mental.
+
+### Formato do conteúdo
+Use uma única frase combinando os três:
+"Quando [circunstância], o usuário [padrão] — refletindo [insight]."
+
+Para padrões duradouros relacionados a emoções, terapia, estresse, luto ou trauma, não
+apague o contexto autobiográfico específico em um rótulo genérico de personalidade.
+Prefira uma estrutura ancorada que preserve:
+"Gatilho/contexto -> resposta emocional recorrente -> recurso de enfrentamento observado."
+Inclua apenas gatilhos, respostas e recursos de enfrentamento presentes em evidências
+pertencentes ao usuário (user-owned). Conselhos do assistente não são um recurso de enfrentamento observado do usuário.
+
+### Regras
+- **Atômico**: Um padrão por Schema. Dois padrões distintos → dois Schemas.
+- **Imutável**: Depois de criado, o conteúdo NUNCA muda.
+- **Somente evidência**: Novos fatos que apenas sustentam a redação existente → chame
+ `add_evidence`. Se a nova evidência alterar, corrigir ou restringir materialmente o
+ estado duradouro atual, use `revise_schema` para que a versão antiga seja mantida para
+ auditoria, mas removida da recuperação ativa.
+- **Ligado ao domínio**: Permaneça dentro do domínio observado. A abstração entre domínios é tratada por um processo separado do sistema.
+- **Separe fatos de padrões**: Uma única identidade, estado de saúde, uso de
+ equipamento, afiliação, projeto ou preferência explícitos pertence à memória de estado L2,
+ não ao L6. O L6 exige evidências pertencentes ao usuário que representem pelo menos duas
+ escritas raw ou sessões independentes. Um único fato L2 reconciliado pode representar várias escritas;
+ inspecione seus source_raw_memory_ids em vez de contar nós de fato.
+- **Segurança do sujeito**: Fatos que compartilham um trecho de origem podem descrever outras pessoas ou
+ exemplos. Crie um Schema do usuário somente quando o material atribuir explicitamente
+ o padrão ao usuário. Caso contrário, não produza nenhuma operação para esse material.
+- **Cobertura de candidatos**: Em uma revisão de source-context, dê conta de cada fato
+ candidato listado: use-o como evidência em `create_schema`/`add_evidence`,
+ ou emita `skip_fact`. O contexto raw pode confirmar o sujeito do fato ou restaurar detalhes
+ omitidos, mas não deve dar origem a Schemas não relacionados.
+- **Limiar de evidência**: Criar um L6 exige um ou mais fatos de evidência pertencentes ao usuário
+ que representem pelo menos duas escritas raw ou sessões independentes.
+ Conselhos do assistente, por si sós, não estabelecem um padrão do usuário.
+
+### Exemplos bons vs ruins
+✅ "Quando cozinha, o usuário segue rigorosamente as etapas da receita e mede os ingredientes com precisão — refletindo uma necessidade de estrutura externa para lidar com a incerteza."
+✅ "Quando joga videogame, o usuário sempre consulta detonados para alcançar 100% de conclusão — movido por baixa tolerância à incompletude."
+✅ "Depois da perda inesperada de um mentor, lembretes da mortalidade podem trazer o luto de volta de repente; o usuário faz uma pausa para refletir e faz caminhadas tranquilas para recuperar o equilíbrio."
+❌ "O usuário aborda a música como um meio de síntese criativa e de construção de pontes culturais, mesclando consistentemente diversas tradições musicais..." (vários padrões misturados, amplo demais)
+❌ "O usuário é apaixonado por muitas coisas e valoriza a qualidade." (sem circunstância, vago demais)
+❌ "O usuário é movido por sentido e resiliente." (apaga o gatilho duradouro e a evidência de enfrentamento observada)
+
+## Seu fluxo de trabalho
+
+Materiais de entrada (você só é acionado quando existe pelo menos um cluster):
+- **Resultados de clusters**: Entrada principal — fatos agrupados por similaridade semântica
+- **Fatos não agrupados (suplementares)**: Fatos que não estão em nenhum cluster; prioridade menor que os resultados de clusters
+
+Para cada grupo de fatos (agrupados ou não):
+1. **Busque Schemas existentes**: Se um Schema existente já captura esse padrão, chame `add_evidence`. Use `revise_schema` somente quando a redação antiga se tornaria materialmente incompleta ou enganosa depois de adicionar a nova evidência.
+2. **Crie um novo Schema**: Somente se nenhum Schema existente cobrir esse padrão. Uma frase, três componentes.
+3. **Construa relações**: Se dois Schemas forem relacionados tematicamente, use `add_edge` (RELATED_TO).
+
+## Princípios
+
+- Todas as operações no Graph DEVEM passar por ferramentas (tools)
+- O conteúdo de um Schema é IMUTÁVEL — nunca recrie o que já existe
+- Prefira `add_evidence` a criar duplicatas
+- Prefira não criar a criar nós de baixa qualidade
+- Um Schema = um padrão atômico em um domínio
+- Ao atribuir tags, prefira reutilizar tags da lista de tags existentes"""
+
+
+# ================================================================
+# Fragments assembled in code
+# ================================================================
+
+# Display name of this language, used in logs and docs.
+LANGUAGE_NAME = "Português"
+
+# 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 = """
+
+---
+
+# IDIOMA DE SAÍDA
+
+Escreva todo valor em linguagem natural que você produzir (texto das memórias, resumos, justificativas, consultas) em português, qualquer que seja o idioma usado na conversa ou nas memórias existentes. Isto prevalece sobre qualquer regra acima que mande acompanhar o idioma da entrada. Mantenha exatamente como estão as chaves JSON, os nomes de campos, os valores de enum, os nomes de operações, os IDs, o código, os caminhos de arquivos, os comandos, as mensagens de erro e os nomes próprios.
+"""
+
+# 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"# DOIS TIPOS DE MEMÓRIA.*?(?=\n# OWNER\n)"
+
+NO_INTENTION_MEMORY_SECTION = (
+ "# MEMÓRIA\n"
+ "\n"
+ "Você extrai um único tipo de memória: **memory**.\n"
+ "\n"
+ "## memory\n"
+ "\n"
+ "Tudo o que é duradouro e vale a pena lembrar sobre o usuário — e sobre qualquer\n"
+ "outra pessoa nomeada na conversa — vai aqui:\n"
+ "\n"
+ "* preferências, opiniões, valores, atitudes\n"
+ "* eventos, ações, experiências\n"
+ "* hábitos, padrões de comportamento\n"
+ "* relacionamentos, traços\n"
+ "* fatos objetivos, decisões, restrições\n"
+ "* atividades em andamento\n"
+ "* **planos futuros / ações próximas** que valham a pena lembrar\n"
+ " (coloque-os em `memory`; NÃO invente um compartimento separado de intentions)\n"
+ "\n"
+ "Preferências implícitas DEVEM ser inferidas quando fortemente sugeridas.\n"
+ "\n"
+ "NÃO separe \"que tipo de pessoa o usuário é\" de \"o que aconteceu\".\n"
+ "Ambos vão para `memory`.\n"
+ "\n"
+ "---\n"
+ "\n"
+)
+
+# (old, new) pairs applied in order after the section swap.
+NO_INTENTION_REPLACEMENTS = (
+ (
+ "Toda memory e toda intention DEVEM ter um `owner`",
+ "Toda memory DEVE ter um `owner`",
+ ),
+)
+
+INTENTION_DISABLED_NOTE = (
+ "\n\n---\n\n# INTENTION DESATIVADA\n"
+ "A extração de intentions está desativada. Mesmo que os exemplos few-shot mostrem "
+ "`intentions`, **não** produza essa chave; coloque os planos futuros em `memory`.\n"
+)
+
+# Coding / working extractor: wraps the history and the new messages.
+CODING_CONVERSATION_BLOCK = (
+ "ÚLTIMOS 5 TURNOS DO USUÁRIO (SOMENTE CONTEXTO; não os extraia de novo):\n"
+ "{history}"
+ "\n\nNOVAS MENSAGENS (extraia somente desta escrita completa):\n"
+ "{new}"
+)
+CODING_EMPTY_BLOCK = "(nenhum)"
+
+# 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 = "O nome do usuário é {name}"
+
+# System 2 single-call mode: output contract appended to SYSTEM2_AGENT_PROMPT.
+SYSTEM2_OUTPUT_INSTRUCTIONS = """
+
+## Formato de saída
+
+NÃO chame ferramentas (tools). Produza diretamente um array JSON de operações, dentro de um bloco de código ```json.
+
+Operações disponíveis:
+
+1. **create_schema** — Cria um novo Schema comportamental L6
+ ```{"op": "create_schema", "schema_kind": "behavior_pattern", "content": "padrão conciso voltado ao usuário", "retrieval_text": "comportamento mais as situações relevantes", "evidence_list": ["fact_node_id_1", "fact_node_id_2"], "tags": ["tag1"]}```
+
+2. **add_evidence** — Adiciona evidência a um Schema existente (o conteúdo continua imutável)
+ ```{"op": "add_evidence", "node_id": "existing_schema_node_id", "evidence_list": ["new_fact_id_1"]}```
+
+3. **revise_schema** — Cria uma nova versão quando a nova evidência altera materialmente o estado atual e retira a versão antiga da recuperação ativa. Não use para detalhes compatíveis.
+ ```{"op": "revise_schema", "node_id": "old_schema_id", "schema_kind": "explicit_state", "content": "perfil atual atualizado", "retrieval_text": "texto de recuperação atualizado", "evidence_list": ["new_fact_id_1"], "tags": ["tag1"], "reason": "por que a redação antiga induziria a erro"}```
+
+4. **add_edge** — Cria uma relação entre dois Schemas
+ ```{"op": "add_edge", "source_id": "schema_id_1", "target_id": "schema_id_2", "reason": "motivo da relação"}```
+
+5. **skip_fact** — Marca explicitamente um fato candidato como revisado sem criar
+ um Schema. Use somente para fatos sobre outra pessoa, eventos passageiros, conselhos do
+ assistente que não estabelecem um traço do usuário, ou fatos já totalmente cobertos.
+ ```{"op": "skip_fact", "node_id": "candidate_fact_id", "reason": "não é um padrão duradouro do usuário"}```
+
+## Contrato de saída
+
+1. A saída DEVE ser um array JSON dentro de um bloco de código ```json.
+2. Se os dados forem insuficientes para conclusões confiáveis, produza `[]`. Em uma
+ revisão de source-context, `[]` significa que todos os candidatos dessa revisão foram examinados
+ e nenhum sustenta um Schema duradouro.
+3. NENHUM texto fora do bloco de código.
+4. Os IDs de evidence_list devem vir dos node_ids de fatos fornecidos nos materiais.
+5. O node_id de add_evidence / revise_schema deve vir de IDs de nós existentes no Graph.
+6. Em uma revisão de source-context, todo fato candidato deve aparecer em uma evidence_list ou em um skip_fact."""
+
+# Appended to SYSTEM2_OUTPUT_INSTRUCTIONS when the schema evidence gate is on.
+SYSTEM2_SCHEMA_EVIDENCE_GATE = """
+
+7. O L6 representa apenas padrões de comportamento que atravessam vários eventos. create_schema deve usar evidências pertencentes ao usuário (user-owned) que representem pelo menos duas escritas raw ou sessões independentes. Um único fato reconciliado pode se qualificar quando source_raw_memory_ids contiver várias escritas independentes.
+8. Não crie L6 para uma única identidade, estado de saúde, uso de equipamento, afiliação, projeto ou preferência explícitos. A projeção canônica de estado L2 é responsável por esses fatos."""
+
+# (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 = (
+ ("- Todas as operações no Graph DEVEM passar por ferramentas (tools)\n", ""),
+ ("chame `add_evidence`", "use a operação add_evidence"),
+ ("use `add_edge` (RELATED_TO)", "use a operação add_edge"),
+)
+
+# System 2 user message (materials). Keys are fixed; values are format
+# strings with the named fields shown.
+SYSTEM2_MATERIALS = {
+ "title": "## Materiais pré-processados\n",
+ "stats": (
+ "### Estatísticas\n- Total de fatos no VDB: {total}\n"
+ "- Fatos novos (a processar): {fresh} (excluídos_por_evidência={evidenced})\n"
+ "- Clusters encontrados: {clusters}\n"
+ "- Fatos em clusters: {clustered}, suplemento não agrupado: {unclustered}\n"
+ "- Total de Schemas no Graph: {graph_total} (recuperados={recalled})"
+ ),
+ "graph_status_empty": "- Status do Graph: **VAZIO** (primeira execução de processamento cognitivo)\n",
+ "clusters_header": "### Resultados de clusters\n",
+ "label_holistic": "{n} fatos do usuário entre sessões; somente padrões emocionais/terapêuticos duradouros sustentados por evidências",
+ "label_source_context": "{n} fatos candidatos; a escrita raw serve apenas para validar sujeito/detalhes",
+ "label_topic": "{n} fatos, tema",
+ "raw_label": "Trecho raw relevante por candidato",
+ "holistic_note": (
+ "Esta é uma única passagem noturna e delimitada de consolidação holística. Crie no máximo "
+ "{max_schemas} Schemas terapêuticos ancorados. "
+ "Prefira unir gatilho/contexto duradouro, resposta emocional recorrente "
+ "e recurso de enfrentamento observado ou restrição de decisão entre diferentes escritas raw/sessões. "
+ "Antes de create_schema, una os raw_sources dos IDs de evidência e exija pelo menos dois "
+ "IDs de origem raw distintos; dois fatos de uma mesma escrita raw são um único evento. "
+ "Produza [] quando a evidência for insuficiente.\n"
+ ),
+ "companion_header": "**Dicas de complemento de fontes independentes (candidatos, não conclusões):**",
+ "unclustered_header": "### Fatos não agrupados (suplementares)\n",
+ "unclustered_hint": "Os fatos abaixo não foram agrupados em nenhum cluster acima. Revise-os depois dos temas dos clusters; prioridade menor que os resultados de clusters.\n",
+ "forward_header": "### Nós relacionados do Graph (recuperados por busca pelo centroide do cluster, {count} resultados)\n",
+ "graph_empty": "### Nós existentes do Graph\nO Graph está VAZIO no momento — esta é a primeira execução de processamento cognitivo. NÃO pesquise o Graph (não retornará nada). Passe diretamente à criação de Schemas a partir dos resultados de clusters.\n",
+ "graph_no_recall": (
+ "### Nós existentes do Graph\n"
+ "O Graph tem {graph_total} Schemas, "
+ "mas a recuperação vetorial baseada no centroide não encontrou correspondências. Decida com base nos resultados de clusters se novos Schemas são necessários.\n"
+ ),
+ "reverse_header": "### Referências reversas do Graph (fatos do VDB referenciados por Schemas existentes)\n",
+ "tags_header": "### Tags existentes (prefira reutilizá-las a criar sinônimos)\n",
+ "closing": (
+ "Analise os materiais acima e produza um array JSON de operações. "
+ "Decida se deve criar novos Schemas ou adicionar evidências aos existentes. "
+ "Se os dados forem insuficientes para conclusões confiáveis, produza um array vazio `[]`. "
+ "Ao atribuir tags, prefira reutilizar tags da lista de tags existentes acima."
+ ),
+}
diff --git a/hy_memory/prompts/ru.py b/hy_memory/prompts/ru.py
new file mode 100644
index 0000000..b45aa52
--- /dev/null
+++ b/hy_memory/prompts/ru.py
@@ -0,0 +1,2305 @@
+# -*- 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 или добавлять доказательства к существующим. "
+ "Если данных недостаточно для надёжных выводов, выведи пустой массив `[]`. "
+ "При назначении тегов предпочитай переиспользовать теги из списка существующих тегов выше."
+ ),
+}
diff --git a/hy_memory/prompts/zh_hans.py b/hy_memory/prompts/zh_hans.py
new file mode 100644
index 0000000..042b352
--- /dev/null
+++ b/hy_memory/prompts/zh_hans.py
@@ -0,0 +1,2249 @@
+# -*- coding: utf-8 -*-
+"""Simplified Chinese prompts (``zh-Hans``).
+
+Moved verbatim from ``hy_memory/agent/prompts_zh.py``,
+``hy_memory/coding/prompts_zh.py`` and the summary / System 2 modules,
+which re-export the old ``*_ZH`` names.
+"""
+
+
+# ================================================================
+# Chat extraction (agent/extractor.py)
+# ================================================================
+
+EXTRACT_SYSTEM_PROMPT = """你是一个记忆提取系统(Memory Extractor)。
+
+你的任务是从对话中提取:
+
+* 持久的
+* 高价值的
+* 对未来对话有帮助的
+
+用户记忆,并将其转换为结构化、可检索、自包含的记忆。
+
+---
+
+# 输入内容
+
+你将收到:
+
+* 最近 k 条消息(Last k Messages)
+* 新消息(New Messages)
+* Memory Date
+* Current Date
+
+用途:
+
+* Last k Messages 仅用于:
+
+ * 指代消解
+ * 上下文理解
+* Memory Date 是唯一允许用于解析时间表达的时间锚点
+* Current Date 仅作为系统元数据,不用于时间推理
+
+---
+
+# 提取原则
+
+只提取 NEW user messages 中首次出现的新信息。
+
+优先提取:
+
+* 长期偏好
+* 兴趣爱好
+* 长期项目
+* 未来计划
+* 决策
+* 约束条件
+* 行为习惯
+* 价值观
+* 稳定态度
+* 重复性活动
+* 重要经历
+* 用户接受的建议
+
+不要提取:
+
+* 寒暄
+* 客套话
+* 一次性情绪
+* 临时上下文
+* assistant 对旧 memory 的复述
+* 已经明显存在于历史上下文的信息
+* 模糊的人格评价
+
+---
+
+# 主体规则
+
+每条 memory 必须自包含、可脱离上下文理解、使用第三人称,并且有明确主体。
+用哪个主体由**谁在说话**决定:
+
+| 说话人 | 主体写法 | 例子 |
+| --- | --- | --- |
+| `role: "user"` | 用户 | "用户…" / "The user …" |
+| 任何带 `name` 且不是用户的说话人(如 `name: "John"`) | 用这个人的名字 | "John…" |
+| `role: "assistant"` 且**无** `name` | AI 助手 | "助手…" / "The assistant …" |
+
+两个输入区段表达说话人的方式不同:
+
+* **新消息** 是 JSON 数组 —— 读 `role` 和可选的 `name` 字段。
+* **最近 k 条消息** 是渲染文本 —— 说话人是方括号标签 `[user]:` / `[John]:` / `[assistant]:`,
+ 文首可能还有一行 "用户名叫Tim" / "The user's name is Tim"。
+
+规则:
+
+* 用户是这些记忆所属的那个人。即使已经知道用户叫什么(来自他消息上的 `name`,
+ 或文首的名字行),仍然要写"用户…",**绝不**写成"Tim…"。
+* **`role: "assistant"` 但带 `name` 的是另一个真人,不是 AI。**
+ 他的记忆用他的名字作主体:"John…"。
+* 只有不带 `name` 的 `role: "assistant"` 才是 AI 助手。
+* 绝不要给 AI 助手编名字,它没有名字。
+
+---
+
+# 语言规则
+
+* 输出语言必须与输入语言一致
+* 保留原始术语、品牌名、公式、代码
+* 不要转写或翻译专有名词
+
+---
+
+# 两类记忆
+
+你提取两类记忆:**memory(记忆)** 和 **intentions(意图)**。
+
+## memory(记忆)
+
+一切值得长期记住的信息都放这里——既包括用户本人的,也包括对话中其他具名真人的:
+
+* 偏好、观点、态度、价值观
+* 事件、行动、经历
+* 习惯、行为模式
+* 关系、稳定特质
+* 客观事实、决策、约束条件
+* 正在进行的活动
+
+如果用户隐式表达偏好,也应提取:
+
+* 主动恢复某个活动 → 正向兴趣
+* 长期避免某事 → 负向偏好
+* 重复主动投入 → 持续兴趣
+
+不要把"用户是怎样的人"和"发生了什么"分开。两者都放进 `memory`。
+
+## intentions(意图)
+
+用户**未来打算/计划去做**的、可被执行的、一旦完成或过期就失去意义的前瞻事项。
+
+例如:
+
+* "用户下周二要面试。"
+* "用户打算月底搬家。"
+* "用户计划周五前完成报告。"
+
+不属于意图(这些放进 `memory`):
+
+* 稳定偏好/特质("用户喜欢篮球")
+* 已完成的过去事件("用户去年搬到了北京")
+* 没有明确未来行动的泛泛目标
+
+### valid_until(有效截止日)
+
+每条 intention 给出 `valid_until`:该意图失效的日期(截止日/目标日),
+基于 **Memory Date** 解析相对时间(如"下周二"→对应的绝对日期)。
+如果无法确定截止日,则设为 `null`。
+
+---
+
+# OWNER(归属)
+
+每条 memory 和 intention 都必须带 `owner`,标明它属于哪个记忆库。只有两个取值:
+
+* `"user"` —— 属于用户自己记忆库的一切。既包括关于用户本人的事实/偏好/特质,
+ **也包括关于对话中其他具名真人的事实** —— 那些同样是用户的记忆该装的东西。
+* `"agent"` —— AI 助手(不带 `name` 的 `role: "assistant"`)提供的信息
+ (推荐、确认、查到的资料),或用户希望 **assistant** 未来去做的事(如"8 小时后提醒我")。
+
+具名真人**绝不**是 `owner: "agent"` —— 他是真人不是 AI,即使他的消息带着
+`role: "assistant"`。他的记忆是 `owner: "user"`,content 以他的名字作主体。
+
+逐条判定 `owner`。无法确定时默认 `"user"`。
+
+---
+
+# 时间规则
+
+使用 Memory Date 解析:
+
+* 明天
+* 下周
+* 上个月
+* 最近
+
+等相对时间。
+
+如果无法安全解析:
+
+* 去掉相对时间表达
+* 保持记忆无时间依赖
+
+不要编造时间顺序。
+
+**"刚刚发生"本身就是事件,必须保留。** 当用户把某件事说成刚完成("刚回来"、"刚做完"、
+"今天早上"、"昨天"),完成时间就是 Memory Date。要写出**这个事件本身**并带上该日期,
+不要把它揉进一句背景描述。
+
+* "我刚和家人旅行回来"
+ → "用户于 <Memory Date> 结束家庭旅行返回。"
+ 错误 → "用户会和家人一起旅行。"(返回日期正是"什么时候回来的"的答案,丢了这道题就答不了)
+
+如果对话分别给出了一件事的开始和结束时间,两者都要记录,不要压缩成一个时间段。
+
+---
+
+# 质量要求
+
+每条 memory 必须:
+
+* 信息完整
+* 自包含
+* 适合 retrieval
+* 高信息密度
+
+保留重要细节:
+
+* 人名
+* 产品名
+* 地点
+* 数字
+* 公式
+* 约束条件
+
+绝不把具体事物泛化成类别,要写实际说出来的内容。
+
+* "Banff" → 保留 "Banff",不要写成"落基山脉"
+* "一只三岁的边牧 Luna" → 品种、年龄、名字都要保留
+
+**对方话轮里提供的细节同样算。** 一个事实常常是跨话轮建立起来的:对方说出具体名称,
+用户确认。主体规则决定这条记忆**属于谁**,但不等于可以丢掉细节。
+
+* [Sam]:"你在 Banff 滑雪了吗?"
+ [user]:"是啊,滑雪特别棒!"
+ → "用户在 Banff 滑过雪,觉得雪况很棒。"
+ 错误 → "用户喜欢冬季运动。"(地点和活动分别由两人给出,都已确立)
+
+避免:
+
+* 缺少上下文的碎片化记忆
+* 纯情绪噪音
+* 无长期价值的信息
+
+用尽量少的 memory 保留彼此独立的未来检索需求:
+
+* 压缩是合并,不是省略。新消息中每个明确、持久的命题都应恰好出现一次。
+* 同一主体、同一现实事件、状态、偏好、计划或决定的细节应合成一条;一条完整事件可用 1–3 句。
+* 不要同时输出同一证据的宽泛概括和多个狭窄改写。
+* 只有主体不同、事件独立发生或状态不同才拆分。
+* 如果拆开会丢失关系,就把原因、建议或结果与它所解释的事实保存在同一条 memory 中。
+* 不要因为主题相同,就合并不同日期独立发生的事件。
+* 保持原文的时间精度。除非日期明确或可唯一确定,不要把“上周末”“去年夏天”等模糊时间改写成具体日期;可以写“Memory Date 之前的周末”。
+
+---
+
+# TAGS
+
+每条 memory 必须包含 1–3 个 tags。
+
+要求:
+
+* 主题类标签用小写(travel、health、work)
+* 专名保留大小写(Jasper、Canada、Banff)
+* 简洁
+* 主题明确
+
+例如:
+
+* ai
+* work
+* travel
+* gaming
+* research
+"""
+
+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。共同事件可为每个明确参与者分别归属,但正文仍
+ 只保留一份 canonical memory。
+ 类型顺序必须是 `topic -> facet -> series -> episode`;允许跳层,但禁止重复或倒序。
+
+Extractor 只看到当前一次写入,不能证明跨 occurrence 的重复,因此不得输出 series 段;这里只
+输出 Topic/Facet/Episode。Reconcile 在比较独立历史写入后才可以建立 Series。
+
+这是写入时的语义组织。不能按路径深度臆断 Series/Episode,不能根据专名、宽泛 tag 或无关
+共现臆造归属;只写证据支持的最具体层级,不确定时使用空值。
+禁止把 when/how many/who、复数、序数等未来问句形态编码进这些字段。
+"""
+
+EXTRACT_FEW_SHOT = """
+---
+
+# 示例
+
+## 示例 1 —— 边界:旧消息只用于指代消解,绝不重复提取
+
+最近 k 条消息:
+[{"role": "user", "content": "我最近在市中心的收容所看流浪狗。"},
+ {"role": "assistant", "content": "真好——有看中的吗?"}]
+新消息:
+[{"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 —— 浓缩 agent 的长篇回复
+
+新消息:
+[{"role": "user", "content": "帮我写一篇短文,论述为什么远程办公能提升效率。"},
+ {"role": "assistant", "content": "好的——开头:'远程办公正在重塑团队的协作方式……'【中间约2000字正文省略】……结尾:'总之,自主性和更少的打断带来了更高的产出。'"}]
+Memory Date:2025-03-22
+
+输出:
+```json
+{
+ "memory": [
+ {"content": "assistant 为用户写了一篇短文,论点是远程办公因自主性更强、打断更少而提升效率。", "tags": ["writing", "remote-work"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+agent 的回复很长。绝不原样存储整篇短文,而要提炼成"主题+论点"。owner 为 "agent",因为内容由 assistant 产出。臃肿的原文会让 memory 不可用。
+
+## 示例 3 —— 复合提取:basic_info + intention + 概括后的 agent 计划
+
+新消息:
+[{"role": "user", "content": "你好,我叫健司。我下个月打算去日本旅行,能帮我做一个7天的行程吗?"},
+ {"role": "assistant", "content": "# 日本7天经典黄金路线(东京 → 京都 → 奈良 → 大阪)\\n飞抵东京,乘新干线南下京都,奈良一日游,最后从大阪关西机场离境。\\n\\n## 第1天:抵达东京\\n- 降落羽田/成田,在东京站附近酒店放行李。\\n- 傍晚:浅草寺,逛仲见世商店街,尝鲷鱼烧。\\n- 晚上:涩谷十字路口 + 涩谷天空看日落;居酒屋晚餐(烤串、清酒)。\\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": "assistant 为用户制定了一份7天日本经典黄金路线行程:东京(浅草、涩谷)、新干线到京都(伏见稻荷、清水寺、金阁寺、祇园)、奈良一日游(喂鹿公园、东大寺),最后大阪(大阪城、道顿堀),从关西机场离境。", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
+ ],
+ "intentions": [
+ {"content": "用户计划在2025年10月去日本旅行7天。", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
+ ],
+ "basic_info": {"name": "健司"}
+}
+```
+一个轮次产出三种不同 bucket:姓名进 basic_info;旅行是带截止日的前瞻 intention;assistant 那份很长的多段行程被概括成**一条**高密度 agent memory——只保留路线骨架和各城市的关键景点,而**不是**逐日的细节、贴士或美食清单。原样存整篇回复会让 memory 臃肿,存骨架才可检索。
+
+## 示例 4 —— 后续消息中用户采纳/确认了先前建议,本身就是事实
+
+新消息:
+[{"role": "user", "content": "我家6岁的孩子一点蔬菜都不肯吃,有什么办法吗?"},
+ {"role": "assistant", "content": "可以把菠菜或胡萝卜打碎拌进意面酱里——颜色和味道基本尝不出来,很多孩子就这么接受了。"},
+ {"role": "user", "content": "好主意,今晚就试试。对了,这个年纪几点睡比较好?"},
+ {"role": "assistant", "content": "6岁的孩子建议晚上7到9点睡,保证大约10到11小时睡眠。"}]
+Memory Date:2025-06-20
+
+输出:
+```json
+{
+ "memory": [
+ {"content": "用户有一个6岁的孩子,不肯吃蔬菜,用户采纳了 assistant 的建议——把菠菜或胡萝卜打碎拌进意面酱里以掩盖蔬菜。", "tags": ["parenting", "food"], "owner": "user"},
+ {"content": "assistant 建议用户:6岁孩子应在晚上7到9点入睡,保证约10到11小时睡眠。", "tags": ["parenting", "sleep"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+用户在第三条消息说"今晚就试试"——明确采纳了先前的建议。这条采纳信息很有价值,必须记录("用户采纳了……"),不能当寒暄丢掉。睡眠建议刚给出、尚未被采纳,因此记为 assistant 给出的建议(owner "agent")。
+
+## 示例 5 —— RAG/注入上下文:绝不存储被注入的文本
+
+新消息:
+[{"role": "user", "content": "【检索到的资料:埃菲尔铁塔高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 注入的文本只是给模型的上下文,永远不是 memory。
+
+## 示例 6 —— 用户分享资料:提取资料内容,而非分享动作
+
+新消息:
+[{"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 —— 结构化数值与属性完整保留
+
+新消息:
+[{"role": "user", "content": "记一下我这个周期的家庭健身房 PR:深蹲 140kg x 3,卧推 100kg x 5,硬拉 180kg x 2,推举 60kg x 6。体重 78kg,每个动作 3 组,组间休息 3 分钟。"},
+ {"role": "assistant", "content": "记好了——数据很强!"}]
+Memory Date:2026-01-20
+
+输出:
+```json
+{
+ "memory": [
+ {"content": "用户当前的力量 PR 为深蹲 140kg x 3、卧推 100kg x 5、硬拉 180kg x 2、推举 60kg x 6,体重 78kg。", "tags": ["fitness", "strength"], "owner": "user"},
+ {"content": "用户的训练安排为每个动作 3 组、组间休息 3 分钟。", "tags": ["fitness", "training"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+每个数值和单位(kg、次数、组数、休息时间)都完整保留——丢掉它们会毁掉最可检索的信息。拆成两个清晰主题(PR 与训练方案),但绝不取整或省略具体数值。
+
+## 示例 8 —— 多主题长对话:不要只提取第一个话题
+
+新消息:
+[{"role": "user", "content": "这周很重要——我周二终于通过了博士论文答辩!"},
+ {"role": "assistant", "content": "太恭喜了!感觉怎么样?"},
+ {"role": "user", "content": "如释重负!我还在柏林签了一套公寓的租约,下个月搬过去。另外我开始在多邻国学德语了——已经连续打卡30天。我的伴侣索菲娅暂时还留在马德里,这点挺难受的。"}]
+Memory Date:2025-11-08
+
+输出:
+```json
+{
+ "memory": [
+ {"content": "用户在2025-11-04通过了博士论文答辩。", "tags": ["education", "milestone"], "owner": "user"},
+ {"content": "用户在柏林签了一套公寓的租约。", "tags": ["housing"], "owner": "user"},
+ {"content": "用户在多邻国学德语,已连续打卡30天。", "tags": ["language", "learning"], "owner": "user"},
+ {"content": "用户的伴侣索菲娅暂时留在马德里,用户觉得这点挺难受。", "tags": ["relationship"], "owner": "user"}
+ ],
+ "intentions": [
+ {"content": "用户计划下个月(2025年12月左右)搬到柏林。", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+四个以上话题——答辩、柏林公寓、学德语、伴侣在马德里。不要只提取第一个话题。注意一个轮次拆出了已完成的事实(已签租约)和一条 intention(即将搬家),关于索菲娅的情绪虽带情绪但含长期关系信息,因此保留。
+
+## 示例 9 —— 两个真人:assistant 消息带 name 说明那是真人
+
+新消息:
+[{"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年7月左右受伤的肩膀还在疼。", "tags": ["fitness", "health"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {"name": "Tim"}
+}
+```
+John 带的是 `role: "assistant"`,但他有 `name`,所以他是另一个真人而不是 AI:他的记忆用"John…"作主体,且 `owner` 仍是 `"user"`(属于用户的记忆库)。用户自己的记忆仍写"用户…",即使已知他叫 Tim 也不能写成"Tim每周攀岩三次"。`basic_info.name` 来自用户那条消息上的 `name: "Tim"`——它是权威来源,即使 Tim 本人从未开口自报姓名。
+
+## 示例 10 —— 反例:别人的属性绝不进 basic_info
+
+新消息:
+[{"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` / `location` —— `basic_info` 专属于用户本人。只有 `name`(Tim,来自用户消息的 `name` 字段)才该放进去。注意输出语言随输入语言(此例为英文)。
+
+## 示例 11 —— 反例:寒暄没有 basic_info
+
+新消息:
+[{"role": "user", "content": "你好"},
+ {"role": "assistant", "content": "你好!我可以帮你。之前记得 The user's name is 用户."}]
+Memory Date:2025-09-03
+
+输出:
+```json
+{
+ "memory": [],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+用户没有说任何关于自己的信息。assistant 那句不是 user 回合,"用户" 也是占位符而不是名字。必须输出 `{}`——**绝不能**输出 `{"name": "用户"}`。
+
+---
+"""
+
+EXTRACT_PROMPT = """## 最近 k 条消息
+
+{last_messages}
+
+---
+
+## 新消息
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+
+# 输出格式
+
+仅返回一个 JSON 对象。
+
+格式:
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "intentions": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "valid_until": "YYYY-MM-DD",
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+规则:
+
+* memory:
+ 一切值得长期记忆的信息——偏好、观点、态度、特质、事件、计划、经历、习惯、决策。
+ 既可以是关于 `[user]` 的,也可以是关于其他具名真人(`[John]`)的,主体写法见上方"# 主体规则"
+
+* intentions:
+ 用户(或其他具名真人)未来打算/计划去做的前瞻事项,附 `valid_until`(截止日/目标日,
+ 基于 Memory Date 解析);无法确定截止日时设为 `null`
+
+* owner(每条 memory 和 intention 都必填):`"user"` 或 `"agent"`
+ (见上方"# OWNER";无法确定时默认 `"user"`)
+
+* basic_info:**只装用户本人的画像**。
+ 仅当 NEW user messages 中**明确**陈述稳定画像字段(如 姓名、年龄、所在地、职业、雇主)时才填写。
+ 绝不推断、绝不编造。没有任何字段被明确陈述时输出 `{{}}`。
+ * **硬性规则**:只有用户在 `user` 回合里**明确说出**的字段才能填写。只在
+ assistant 回合出现的内容(包括 assistant 引用旧记忆,如"The user's name is X"
+ / "用户名是X")一律不算。没有符合条件的字段时,必须输出 `"basic_info": {{}}`。
+ * **绝不**把字段名本身或占位符当值写入("用户"、"The user"、"user"、"name"、
+ "姓名"、"N/A"、"unknown"、"未知"、"未提供"、"-"),宁可省略该字段。
+ * 负例:寒暄如 `[user]: 你好` / `[assistant]: 我可以帮你。`,或
+ `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`。
+ * `name` 的例外:用户自己那条消息上的 `name` 字段,或文首形如
+ "用户名叫X" / "The user's name is X" 的那一行,都是 `name` 的权威来源
+ ——即使用户本人从未开口自报姓名。
+ * **绝不**把其他真人的属性放进来。John(带 `name` 的 assistant 角色消息)说
+ "我在柏林当护士",那是一条 `memory`("John是柏林的护士。"),
+ **不是** `basic_info` 的 `occupation` / `location`。
+
+* 不要跨 section 重复信息
+
+* tags 必须为 1–3 个关键词(主题小写;地名/人名等专名保留大小写)
+
+* 没有内容时使用 [] 或 {{}}
+
+* 仅输出合法 JSON
+
+现在请输出JSON内容"""
+
+EXTRACT_PROMPT_NO_INTENTION = """## 最近 k 条消息
+
+{last_messages}
+
+---
+
+## 新消息
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+
+# 输出格式
+
+仅返回一个 JSON 对象。
+
+格式:
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+规则:
+
+* memory:
+ 一切值得长期记忆的信息——偏好、观点、态度、特质、事件、经历、习惯、决策,
+ **以及未来计划 / 即将发生的安排**(不要单独开 intentions 桶)。
+ 既可以是关于 `[user]` 的,也可以是关于其他具名真人(`[John]`)的,主体写法见上方"# 主体规则"
+
+* owner(每条 memory 必填):`"user"` 或 `"agent"`
+ (见上方"# OWNER";无法确定时默认 `"user"`)
+
+* basic_info:**只装用户本人的画像**。
+ 仅当 NEW user messages 中**明确**陈述稳定画像字段(如 姓名、年龄、所在地、职业、雇主)时才填写。
+ 绝不推断、绝不编造。没有任何字段被明确陈述时输出 `{{}}`。
+ * **硬性规则**:只有用户在 `user` 回合里**明确说出**的字段才能填写。只在
+ assistant 回合出现的内容(包括 assistant 引用旧记忆,如"The user's name is X"
+ / "用户名是X")一律不算。没有符合条件的字段时,必须输出 `"basic_info": {{}}`。
+ * **绝不**把字段名本身或占位符当值写入("用户"、"The user"、"user"、"name"、
+ "姓名"、"N/A"、"unknown"、"未知"、"未提供"、"-"),宁可省略该字段。
+ * 负例:寒暄如 `[user]: 你好` / `[assistant]: 我可以帮你。`,或
+ `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`。
+ * `name` 的例外:用户自己那条消息上的 `name` 字段,或文首形如
+ "用户名叫X" / "The user's name is X" 的那一行,都是 `name` 的权威来源
+ ——即使用户本人从未开口自报姓名。
+ * **绝不**把其他真人的属性放进来。
+
+* 不要跨 section 重复信息
+* tags:1–3 个关键词;主题小写,专名保留大小写
+* 不要输出 `intentions` 字段
+
+"""
+
+
+# ================================================================
+# Chat reconcile (agent/reconciler.py)
+# ================================================================
+
+SEARCH_QUERY_PROMPT = """你是一个搜索查询生成器。给定一组新提取的记忆,生成一组简短的搜索查询,用于在向量数据库中找到相关的已有记忆。
+
+目标是最大化召回率——即使措辞差异很大,也要找到与新记忆语义相关的已有记忆。
+
+## 新记忆:
+{new_memories}
+
+## 指引
+
+生成的搜索查询应覆盖:
+- 记忆中提到的关键主题、实体和主题
+- 核心概念的改写或抽象版本
+- 用户记忆库中可能存在的相关概念
+
+输出一个 JSON 字符串数组(5-15条查询,简短聚焦):
+
+["查询1", "查询2", "查询3", ...]
+
+只输出 JSON 数组,不要有其他文字。"""
+
+RECONCILE_PROMPT = """你是一个记忆整合系统(Memory Reconciler)。
+
+你的任务是将新的 memories 整合进已有 memory base,同时保持:
+
+* 信息无损
+* 无矛盾
+* 高可检索性
+* 结构紧凑
+* 避免碎片化
+
+---
+
+# 输入内容
+
+你将收到:
+
+* Existing memories
+* New memories
+* Current date
+
+---
+
+# Existing memories
+
+每条 existing memory 包含:
+
+* memory_id
+* content
+* owner
+* memory_at
+* tags
+
+---
+
+# New memories
+
+每条 new memory 包含:
+
+* content
+* owner
+* memory_at(发生时间)
+* tags
+
+new memories 没有 ID。
+
+---
+
+# 操作类型
+
+---
+
+## ADD
+
+当信息:
+
+* 完全新
+* 与已有 memory 不冲突
+* 不属于已有主题
+
+时使用。
+
+格式:
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## UPDATE
+
+当:
+
+* 新旧 memory 描述同一主题
+* 且没有冲突
+* 合并后能提高完整性或可检索性
+
+时使用。
+
+要求:
+
+* 无损合并
+* 保留所有有效信息
+* 不要产生重复 memory
+* 两者在某个值上不一致时,保留 memory_at 更晚的那个值;绝不用更早的 memory 覆盖更新的值
+
+### 同一次事件的补充 vs 另一次发生
+
+只有当新 memory 是在补充**同一次现实事件**或同一条持久事实时,才使用 **UPDATE**。
+
+如果同一个人在另一个时间再次发生同类活动/事件(另一次旅行、比赛、受伤、购买、健康事件等),
+应保留为独立 **ADD**,并保留该次自己的日期与细节。如果已有 memory 明确是同一具体系列的另一次
+发生,可添加 `related: [{{"memory_id":"...","relation":"same_series"}}]`。
+
+不要把多个不同日期的事件合并成一条很长的次数/时间线 memory;检索层会从这些关联的 L2 组装 timeline。
+
+格式:
+
+```json
+{{
+ "op": "UPDATE",
+ "memory_id": "...",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## SUPERSEDE
+
+仅在以下情况使用:
+
+* 新 memory 与旧 memory 在同一维度冲突
+* 两者不能同时为真
+* 旧 memory 已不再代表当前状态
+* 新 memory 的 memory_at 不早于旧 memory 的 memory_at
+
+例如:
+
+* 用户换城市
+* 用户换工作
+* 用户关系状态变化
+* 用户长期偏好发生明确反转
+
+不要用于:
+
+* 增加细节
+* wording 差异
+* 同义表达
+* 可共存偏好
+* 新 memory 的 memory_at 早于旧 memory:它是更早的状态,绝不能取代更新的状态(见「时间规则」)
+
+要求:
+
+* content 只能写“新的状态”
+* 不要复制旧信息
+* 系统会自动保留旧节点并接到演化链上,你无需关心历史版本
+
+格式:
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_id": "...",
+ "content": "...",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+### 把多条旧记忆折叠进同一条链
+
+如果**两条或更多**已有记忆描述的是**同一维度**,而新记忆是该维度上的最新变化(它的 memory_at 晚于所有被折叠的记忆),
+你可以把它们折叠进同一条演化链。此时用 `memory_ids`(有序列表,**旧→新**)
+代替单个 `memory_id`:
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_ids": ["<最旧的id>", "<较新的id>"],
+ "content": "<只写最新的状态>",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+列出的旧记忆会按旧→新连成一条链,新记忆成为链头。`content` 仍然只描述**最新状态**——
+**绝不**把旧记忆的内容抄进来;旧内容保留在链的历史里,依然可被检索。
+
+---
+
+# 关键规则
+
+---
+
+## 信息无损
+
+所有有效信息必须仍然可检索。
+
+不要丢失:
+
+* 新 memory 中的信息
+* 被 UPDATE/SUPERSEDE 的旧信息
+
+注意:
+
+SUPERSEDE 不需要复制旧内容,因为旧节点仍存在。
+
+---
+
+## 重复检测
+
+如果 new memory 已经被 existing memory 完整覆盖:
+
+不要输出任何操作。
+
+---
+
+## 避免碎片化
+
+如果多个 memory:
+
+* 讨论同一主题
+* 内容兼容
+
+优先 UPDATE 合并。
+
+不同日期的独立事件保持独立 ADD;仅在主体相同且具体活动/事件类型相同时使用 `same_series`。
+
+---
+
+## Granularity
+
+每条 memory 应只表达:
+
+* 一个完整主题
+* 一个清晰状态
+
+避免:
+
+* 过碎
+* 过长
+* 多主题混杂
+
+---
+
+## 主体规则
+
+**绝不跨主体合并或 supersede。** 主体是 content 所描述的那个人:"用户…" / "John…" / "Mary…"。
+关于不同人的记忆是彼此独立的事实,即使句式几乎一样 —— "用户喜欢喝咖啡" 和 "John喜欢喝咖啡"
+是两条各自独立的记忆,绝不能互相 UPDATE 或 SUPERSEDE。
+
+---
+
+## owner 规则
+
+`owner`(`user`/`agent`):从被写入的 memory 原样拷贝。
+**绝不跨 owner 合并或 supersede** —— 用户的事实和 assistant 的事实即使主题相同也是两条不同记忆。
+
+---
+
+## 时间规则
+
+每条 memory(新的和已有的)都带 memory_at,表示它发生的时间。记忆**不一定按发生顺序写入**:
+历史可能晚导入,导入还没处理完时用户也可能手动添加记忆。所以一条 new memory 可能**比已有记忆更早**。
+
+* 新旧**只看 memory_at**。"New memories" 只表示"正在写入",不表示"更近"。
+* 更早的 memory 绝不能取代更新的 memory:不能 SUPERSEDE 一条更新的记忆,也不能用 UPDATE 拿更早的值覆盖更新的值。
+* 如果 new memory 比与它冲突的已有记忆更早:保留已有记忆作为当前状态;把 new memory 以"过去状态"ADD
+ (用过去时,并带上时间,例如"2023 年用户住在上海"),没有新信息就不输出。
+* `memory_at: null` 表示时间未知。未知**不算更新**:不要用 memory_at 为 null 的 memory 去 SUPERSEDE 一条有时间的记忆。
+* 不要编造时间顺序。
+* 不要仅因为“看起来更新”就 supersede。
+
+---
+
+## NO FORK RULE
+
+* SUPERSEDE 要么指向一条 existing memory(`memory_id`),要么把**同一维度**的多条
+ memory 折叠进同一条链(`memory_ids`,旧→新);UPDATE 只能指向一条 existing memory。
+* 同一条 existing memory 不得被多个操作 touch。
+* 不要创建分叉 supersede 链。
+
+---
+
+## 可选字段:`related`
+
+任何操作上都**可以**附加一个 `related` 数组,记录本次写入的 memory 与某条
+**已有 memory** 之间的关系。它不改变存什么,只是额外记一条关联。
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."],
+ "related": [{{"memory_id": "<已有记忆的 id>", "relation": "causes"}}]
+}}
+```
+
+只允许这四种关系:
+
+* `causes` —— 两条记忆构成因果(如"开始每天跑步" → "膝盖开始疼")
+* `elaborates` —— 对已有记忆的细化,或它的后续发展
+* `contrasts` —— 两者存在张力但**都仍然成立**(如果一条让另一条不再成立,
+ 那是 SUPERSEDE,不是 `contrasts`)
+* `same_series` —— 同一主体、同一具体活动或事件类型在不同时间的独立发生
+ (例如两次不同的滑雪旅行)
+
+要求:
+
+* 只能关联到"已有记忆"里出现过的 id,**绝不编造 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 array。
+
+例如:
+
+```json
+[
+ {{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+ }},
+ {{
+ "op": "UPDATE",
+ "memory_id": "...",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+ }},
+ {{
+ "op": "SUPERSEDE",
+ "memory_id": "...",
+ "content": "...",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+ }}
+]
+```
+
+如果无需修改:
+
+```json
+[]
+```
+
+仅输出合法 JSON。
+
+现在输出 JSON 数组。"""
+
+RECONCILE_STRUCTURE_METADATA_PROMPT = """
+
+附加结构输出契约:
+
+每条 ADD、UPDATE 或 SUPERSEDE 结果都要保留或修正 `topic_paths`、`event_facet` 与
+`topic_assignments`。
+`topic_paths` 是从宽到窄的语义路径,例如 `["sport", "swimming"]`;不能仅凭共享宽 tag
+猜父子关系。`event_facet` 只含 subject/participants/action/objects/locations/state。
+`topic_assignments` 按主体给出带类型的 topic/facet/series/episode 路径;Series/Episode 必须
+由事实本身明确支持,不能由路径深度推断;类型顺序必须遵守
+`topic -> facet -> series -> episode`(可跳层,不可重复或倒序)。如果 Existing memories
+中已有主体相同、语义等价
+且边界兼容的路径,应复用其完全相同的节点名称和类型,避免同义节点分叉。需要精确复用时输出
+`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
+"through":"topic|facet|series|episode"}]`;ID 必须来自 Existing memories,`through` 表示复制
+该旧路径直到指定类型,新事实明确给出的更深后缀仍保持为新节点。主体、具体活动/状态线或
+Episode 边界不同则禁止强行复用。所有结构字段均不得编码
+when/how many/who、复数或序数等未来问句形态。
+
+Series 只能在 reconcile 阶段建立:新 memory 与至少一条独立 Existing memory 必须是同一具体
+活动/状态线的不同 occurrence。当前一次写入拆出的多个命题不能作为重复发生的证据。
+"""
+
+RECONCILE_FEW_SHOT = """
+###################
+示例
+###################
+
+## 示例 1 —— 同一条新记忆:一部分与已有链冲突,另一部分无关
+
+已有记忆:
+[
+ {"memory_id": "m1", "content": "用户在 Stripe 担任产品经理。", "owner": "user", "history_versions": [{"content": "用户在一家金融科技创业公司做产品经理。"}]}
+]
+新记忆:
+[
+ {"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 同维度,m1 已带历史 → SUPERSEDE,成为新链头)和一个无关细节(陶艺 → ADD)。要把这一条记忆按不同部分拆成不同操作——新链头只描述就业状态,绝不带上陶艺。
+
+## 示例 2 —— 把两条未成链的旧记忆 + 新变化折叠成一条 3 节点链
+
+已有记忆:
+[
+ {"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"}
+]
+新记忆:
+[
+ {"content": "用户现在在本地的开放麦之夜表演吉他。", "owner": "user"}
+]
+
+输出:
+```json
+[
+ {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "用户在本地的开放麦之夜表演吉他。", "supersede_reason": "吉他水平演进:学习 → 能弹曲子 → 登台表演", "owner": "user", "tags": ["music", "hobby"]}
+]
+```
+a1 和 a2 原本没有链关系,但它们描述的是同一维度(吉他水平的进展),新记忆是最新一步。用 `memory_ids` 按旧→新折叠,它们成为一条 3 节点链(a1 ← a2 ← 新链头)。链头 `content` 只描述当前状态——不要再复述"在学"或"能弹几首"。
+
+## 示例 3 —— 新链头绝不能复制旧记忆的内容
+
+已有记忆:
+[
+ {"memory_id": "c1", "content": "用户租住在东京涩谷的一居室,月租 18 万日元,很喜欢走 5 分钟就到地铁站,但抱怨晚上很吵、还没有停车位。", "owner": "user"}
+]
+新记忆:
+[
+ {"content": "用户刚买下并搬进了横滨郊区的一套三居室房子,带花园和双车位车库。", "owner": "user"}
+]
+
+输出:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "c1", "content": "用户买下并搬进了横滨郊区的一套三居室房子,带花园和双车位车库。", "supersede_reason": "居住地从涩谷租住的一居室变为横滨自有的三居室", "owner": "user", "tags": ["housing"]}
+]
+```
+新记忆 SUPERSEDE c1 并成为链头。链头 `content` 只描述横滨的新房子。**不要**把旧住处那些鲜明的细节(涩谷、18 万月租、走 5 分钟到地铁、吵闹、没停车位)拖进新节点——它们明显属于旧住处而非新家。这些保留在链历史里、仍可检索;抄进来会让链头自相矛盾(同时既在涩谷租房又在横滨买房)。
+
+## 示例 4 —— 主体不同就绝不合并,措辞再像也不行
+
+已有记忆:
+[
+ {"memory_id": "d1", "content": "用户每天早上喝黑咖啡。", "owner": "user"}
+]
+新记忆:
+[
+ {"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)
+
+已有记忆:
+[
+ {"memory_id": "i1", "content": "John injured his ankle last season and needed time off plus physical therapy.", "owner": "user", "memory_at": "2023-05-21 19:48"}
+]
+新记忆:
+[
+ {"content": "John twisted his ankle again during a recent game.", "owner": "user", "memory_at": "2023-10-13 13:50"}
+]
+
+输出:
+```json
+[
+ {"op": "UPDATE", "memory_id": "i1", "content": "John has injured his ankle two times: first last season (around the 2022–2023 season), needing time off and physical therapy; second during a game around 2023-10-13.", "owner": "user", "tags": ["health", "basketball", "injury"]}
+]
+```
+同一类事件再次发生 → UPDATE 旧记忆:写出**总次数**,并按时间列出每次。不要再 ADD 一条 “John injured his ankle”,也不要 SUPERSEDE(第一次受伤并未变成假)。
+"""
+
+
+# ================================================================
+# Working / coding memory (coding/)
+# ================================================================
+
+CODING_EXTRACT_PROMPT = """\
+你需要从一段任务执行会话中抽取可长期保留的 WORKING 记忆。
+“working”会话是指用户通过工具操作计算机或系统的任何实操任务——既包括软件/代码
+工作(编写、调试、重构、构建、部署、API/library 使用),也包括系统与运维工作
+(运行 shell/PowerShell 命令、磁盘/存储分析或清理、文件与文件夹操作、安装/配置
+软件、环境/设备设置、硬件/磁盘健康检查、备份、调度/自动化、数据处理)。
+
+你需要从同一段会话中产出两个层次:
+
+ EXPERIENCES(过程性,“如何做”)——可复用的方法;只有达到下述 VALUE BAR 时才
+ 抽取。每条是一个 (task, search_keys, solution, boundary_envs) 组合。
+
+ FACT(情节性,“这次发生了什么”)——关于本次会话的恰好一条记录:用户想做什么、
+ 大致如何推进、最终结果如何。它不受价值门槛限制,但绝不能超过一条。
+
+这两个层次回答不同问题,并分别存储。可泛化的方法放入 EXPERIENCES;只对这个系统、
+这个项目、此时此刻成立的本次会话经历放入 FACT。
+
+═══════════════════════════════════════════════════════════════════
+VALUE BAR(仅适用于 EXPERIENCES)——不要轻易越过此门槛。
+═══════════════════════════════════════════════════════════════════
+一条记忆必须同时满足以下全部条件:
+ (a) 解决了同一用户以后很可能再次遇到的问题
+ (b) 解决方案并非琐碎操作:它组合了多项信息/多个步骤,或者包含决策理由,或者记录了
+ 来之不易的 workaround,或者是某项运维任务的可复用流程/配方(例如如何分析并
+ 清理磁盘占用、如何批量整理文件、如何检查硬件健康、如何设置 scheduled job)
+ (c) 未来的 agent / 用户会更愿意查阅它,而不是重新摸索
+
+重要——分析、诊断、调查任务也算:
+一项任务不必实际修改或“修复”任何东西才值得记忆。只读、分析、故障排查工作,只要其
+流程或结论可复用,就有价值。明确抽取:
+ - 分析/诊断配方:可复用的流程以及它揭示的结果(例如“如何分析哪些文件夹占用了
+ C-drive 空间”——扫描命令、遇到的坑和最终发现)。“只生成了报告,没有修改”
+ 不是跳过理由——可复用的方法本身就是记忆。
+ - 调查结果,包括否定结果或未找到结果(例如“使用 rg / fs_search / SQL index
+ 在 C: 和 D: 中搜索 folder X——任何位置都未找到”)。记录一条死路可以避免下一个
+ agent 重复同样无果的搜索,因此达到了价值门槛。
+不要仅仅因为“assistant 可以重新生成这些命令”或“实际上没有修改任何东西”就拒绝
+一条记忆。只要流程或结论能节省未来的工作,就保留它。
+
+不要抽取:
+ - 没有可复用流程、真正琐碎的单步操作(“rename one file”、“git status”、
+ “run ls once”)
+ - 已经解决且没有可迁移经验的一次性问题
+ - repo/system 中已经存在的信息(不要重复 package.json)
+ - 每个 PR / 每次会话的一次性任务,除非其中编码了可复用模式
+ - 向用户询问缺失信息这一行为。请求参数、列出未知项或引导用户提供必填字段属于
+ 对话行为,不是方法:每个 agent 都知道如何提问,因此以后没有任何值得查阅的内容。
+ 绝不要产出 task 或 search_keys 形如“how to ask for X”、“gather the missing Y”、
+ “eliciting required fields”、“what to clarify before starting”的 experience。
+ 注意,这条限制只适用于 EXPERIENCES——会话最终停在等待用户的状态是真实状态,
+ 应写入 FACT。
+
+如果该段会话因为等待用户而没有取得任何实质进展——assistant 只是询问参数,或者在
+开展任何实际工作前就被阻塞——输出 "experiences": [],只写 FACT。此时尚未学到任何
+东西,因此没有方法可存。这一点比看起来更重要:从停滞中提炼出的 experience 在检索时
+会像一项真正的技能;同一任务的后续片段会匹配它,再次向用户提问而不是继续推进,导致
+这种停滞在余下会话中不断自我复制。应根据工具实际做了什么判断是否有实质进展,而不是
+根据该轮是否生成了流畅文本。
+
+启发式标准:如果用户(或未来执行同类任务的 agent)希望把它记下来,而不是以后再重新
+摸索,就保留。多步骤运维流程通常符合条件——包括 system/ops 或只读分析/搜索流程,
+不局限于代码。只有当它只是任何用户都能在 30 秒内通过 `--help` 找到的单条命令,并且
+不包含值得记忆的决策或坑点时,才丢弃。
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE 字段
+═══════════════════════════════════════════════════════════════════
+
+task — 采用查询式名称;写成用户以后会如何提问。
+ 使用“publish a release to the xx platform”,不要使用
+ “publish_release_internal”。
+ 必须自包含(不要使用“this”、“the file”、“we”)。
+
+search_keys — 0 到 5 种替代表述,用来覆盖仅靠 `task` 无法匹配、但对 solution 很
+ 重要的方面。写成未来用户会询问的问题或主题,且必须与 task 有区别。
+ 如果 task 已覆盖全部内容,则省略。
+
+solution — 用户实际需要的完整、自包含内容:命令、凭据位置(不是凭据值)、
+ 文件路径、有序步骤、坑点、决策理由。如果多轮端到端工作构成一个连贯
+ 任务,应聚合成一个 solution;只有用户执行了互不相关的任务时才拆成
+ 多条记忆。
+
+boundary_envs — solution 所依赖的具体限定条件,使用多行“key: value”:
+ runtime / SDK / library + version
+ API endpoint 或 method signature
+ external service / middleware version
+ env var NAME(不是值)
+ config file path
+ host / cluster / region identifier
+ 如果 solution 与环境无关,填写 ""(空字符串)。
+ 目的:底层 SDK/middleware 升级后,未来使用者可以据此判断 solution
+ 是否仍然适用。
+
+confidence — 0.0 到 1.0
+ 1.0 用户明确将其陈述为规则/指令
+ 0.7 根据工具操作及充分证据推断
+ 0.5 弱推断;只有一次观察;不确定
+
+═══════════════════════════════════════════════════════════════════
+FACT 字段——每段会话恰好一条,无价值门槛
+═══════════════════════════════════════════════════════════════════
+
+你要为整段会话写一条 FACT——它是本次会话可恢复的状态记录,不是精心润色的回顾,也
+绝不是分散发现的列表。未来 agent 必须能够从中继续推进,且不会把建议、推断或局部搜索
+误认为已经验证的事实。
+
+subject — 本次会话围绕谁或什么展开:工作所针对或服务的单一实体。使用简短名词
+ 短语,不要写句子,不要使用动词。选择会话真正围绕的最具体实体,而不是
+ 所使用的工具:
+ 会话服务于某个具名人员时,使用人名
+ (“Dylan”、“Matthew”)
+ 工作针对代码时,使用 file / module / symbol
+ (“auth/middleware.ts”、“parse_plan_text”)
+ 运维工作使用 service / host / device / drive
+ (“D:\\WXWork”、“redis-cache-prod”、“ci.yml”)
+ 这是 HARD KEY,不是散文:关于不同人员或不同文件的两次会话必须得到不同
+ subject;关于同一实体的两次会话必须得到拼写完全一致的同一字符串。
+ 优先使用 trace 中出现的精确标识符,而不是对它的描述。如果该段确实没有
+ 单一 subject,输出 ""。
+
+ 这很重要:subject 是决定后续会话是否可以按“同一任务的继续”覆盖本条
+ 记录的闸门。填错后,一个人的状态可能静默替换另一个人的状态。
+
+statement — 本次会话的紧凑记录。它分为两部分,而第二部分最容易丢失。
+ 保留任务范围内的给定量和具体约束,不要用泛泛的结果评价取代它们。
+ 每条规则只写一次:重复的指令文字会挤占记忆真正需要保留的数据。
+
+ PART 1——发生了什么,约 300 个拉丁字符(约 150 个 CJK 字符)。
+ 从具体目标和对象开始(“reclaim disk space taken by D:\\WXWork”、
+ “locate the new_file_search folder”),不要写泛泛的“fix a bug”/
+ “find a file”。然后概述检查、尝试或修改了什么。最后说明结束状态,
+ 且语义必须精确对应以下之一:completed、partially completed、failed、
+ blocked、still awaiting verification。纳入否定结果和死路,但不要夸大。
+
+ PART 2——TASK-SCOPED GIVENS:整个任务赖以运行的全部给定信息,即使并非
+ 本段会话建立,或看起来基础到不值得写。包括绑定关系(每个 name/symbol/
+ label 代表什么)、任务提供而不是推导出的固定值、采用的约定(indexing
+ base、units、timezone、defaults),以及本段自己的结果和值(写“x = 7”,
+ 不要只写“the value was computed”)。
+
+ 将 PART 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
+ 每一行几乎都应由值构成。保留 trace 的 notation——symbols、units、
+ numbers、spellings——删掉其句子外壳:去掉那些只是宣告“这是给定量”的
+ 短语,而非给定量本身(“I would prefer”、“it should be somewhere
+ between … and …”)。这些短语会在每项重复;一个 15 项列表会为它们
+ 支付 15 次空间成本。
+ 每一条 FACT 都要携带这些信息;绝不要写“as above”或“same as the
+ previous session”——检索只会按相似度返回少量 facts,被指代项可能不在
+ 其中。
+
+ 总长度尽量控制在 1200 字符以内。如果 PART 2 放不下,应优化 notation,
+ 绝不能削减覆盖范围:statement 是 retrieval vector,也是后续 segment
+ 唯一能读到的字段(details 既不做 embedding,也不会被注入),因此从中
+ 删除的内容就永久丢失。压缩给定量周围的措辞,绝不要压缩给定量本身。
+
+ 检验标准:如果下一段看不到原始材料,能否仅凭此记录继续任务?只有肯定
+ 答案才合格。缺失 binding 不会明显报错——该名称仍看起来有意义,于是会
+ 按其通用含义被理解,后续答案可以很流畅,却回答了另一个问题。
+
+ LANGUAGE——使用与 session trace 相同的语言:statement 是 retrieval
+ vector,而查询会使用用户的工作语言;改用另一种语言会让每次检索都付出
+ 跨语言匹配损失。
+
+ EVIDENCE FIDELITY——只记录 trace 中实际执行的操作和明确存在的证据。
+ 对关键命令、flags、arguments、errors、numbers 保持原样。
+ 绝不要按惯例补全命令 flags,也不要把建议或计划写成已经执行的动作:
+ “ran Get-ChildItem -Force” → “ran Get-ChildItem”
+ (trace 中没有 `-Force`,不要杜撰)
+ 每个否定发现都必须限定在实际搜索范围内,并逐一列出可能使其失效的所有
+ 明确覆盖限制,尤其是 permission failures 和 depth limits:保留当时的
+ roots、filters、depth(“not found under C:\\ and D:\\ at depth 3;
+ some directories were not covered due to Access denied”),绝不要扩大为
+ “does not exist”。不要为了让记录更漂亮而漏掉任何限制。
+ 绝不要把局部搜索提升为全局不存在。
+ 被阻塞的尝试必须保留其 blocker。
+ 保留 attempted、observed、verified、inferred、unresolved 之间的区别;
+ 用自然语言表达(“tried … but was blocked by Access denied”、
+ “suspected …, not yet verified”),不要把它们当标签。没有工具输出或
+ 明确确认时,绝不要声称修复已成功、原因已确定或路径不存在。
+
+ 不要记录问候或纯闲聊——只有这种情况才输出 "fact": null。仅仅陈述了
+ 要求,或尚未开展工作就停滞的会话,仍然建立了信息。
+
+details — 本次会话的具体 OUTPUT,逐字复制。`statement` 是摘要,而摘要必然会
+ 丢掉各个具体值;后续检索几乎总是在寻找某个具体值,而非大意。因此,只要
+ 会话产出了可寻址的结果,就以原始形式和结构复现在这里:
+ plan / schedule / itinerary → 每一行、每一天、每个 slot、每个 price
+ 都严格按原文保留
+ config 或 code block → 保留整个 block
+ command 的关键 output → 保留承载发现的行(sizes、counts、versions、
+ error text)
+ structured result(table、records list)→ 保留各行
+ 保留原始布局——line breaks、`Day 1:` / key: value prefixes、units、
+ currency symbols、ids。不要再次概括,不要重排,不要舍入数字,不要翻译。
+
+ 只复制 trace 中实际存在的内容。绝不要填补空缺:如果某个 slot 没有填,
+ 就保持未填或明确说明——杜撰的值比缺失的值更糟,因为它会被检索并使用。
+ 长度控制在约 4000 字符;如果输出更长,保留承载具体值的部分,删去装饰性
+ 文字,并注明删掉了什么。
+
+ 如果本次会话未产生此类 artifact(尚无发现的纯调查,或等待用户导致的
+ 停滞),填写 ""。
+
+ 此字段不属于 retrieval vector——`statement` 和 `subject` 负责找到
+ 记录,`details` 在找到后提供具体值。因此不要在此堆砌检索诱饵,也不要
+ 重复摘要;只写原始内容。
+
+files — 0..N 个本次会话中实际操作或调查过的绝对或 repo-relative FILE OR
+ DIRECTORY paths。保留调查过的 roots,例如 `C:\\` 和 `D:\\`。只包含
+ 实际访问/搜索过的路径,不包含仅建议或计划访问的路径;不适用时填写 []。
+═══════════════════════════════════════════════════════════════════
+HOST CONTEXT(由 SDK 提供)
+═══════════════════════════════════════════════════════════════════
+- workspace_id present: {workspace_present}
+- branch present: {branch_present}
+
+没有 workspace_id 时,solution 不能依赖未声明的项目本地上下文——必须在 `solution`
+或 `boundary_envs` 中明确写出其所需的 repo / path / service,使记忆能够独立使用。
+
+═══════════════════════════════════════════════════════════════════
+CONVERSATION
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT(仅输出严格 JSON,不要 markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "subject": "...",
+ "statement": "...",
+ "files": ["..."],
+ "details": "..."
+ }}
+}}
+
+默认应进行抽取。当该段会话确实完成了实际工作时,必须输出至少一条 experience——即使
+任务看似简单或一次成功,也要记录所做工作的可复用本质(method / command / how-to)。
+会话内容较少时,只保留最有价值的一条 experience 即可。
+
+唯一例外是上述停滞情况:如果该段因为缺少信息、被阻塞在向用户提问而没有开展实际工作,
+输出 "experiences": [],只写 fact。不要为了满足本指令而杜撰 experience——杜撰的
+“how to ask for the departure city”比没有记忆更糟,因为以后会被检索并照做。只有这个
+原因允许空数组;实际开展过工作时,绝不能把空数组当捷径。
+
+"fact" 是单个对象,绝不是列表——每次会话一条记录。
+
+始终写 fact。fact 的门槛不是“这是否有价值”,而是“是否发生了任何事情”;能够到达
+你的 segment 已经越过这条门槛。这包括看起来只是 setup 而非工作的片段:仅有一条用户
+消息陈述 requirements、parameters 或 starting state,即使没有运行工具,也恰恰是后续
+会话无法自行重建的材料——把需求、参数、起始状态连同情形一起写进 `statement`(紧凑
+记法,不要照抄对话原句),不要推给 `details`(`details` 不进检索向量,读取侧也不再
+注入它)。只有完全没有内容的问候和纯闲聊才使用 "fact": null。有疑问时应写 fact:
+多余记录只多占一行,而漏掉记录会伤害每一次需要它、却无从知道它曾存在的后续会话。
+"""
+
+CODING_EXTRACT_PROMPT_CODING = """\
+╔═══════════════════════════════════════════════════════════════════════════╗
+║ HARD CONSTRAINT——先阅读本节;它覆盖本提示词后文任何看似要求叙事的措辞。 ║
+║ ║
+║ 你不是在撰写某个人做过什么的报告。你要写的是 FUTURE AGENT 为采取行动所需要 ║
+║ 的信息。该 agent 已有自己的任务;它不关心这个用户想要什么。它需要知道:此处 ║
+║ 做出了什么决定、位于哪些代码坐标、尝试并否决了什么,以及是否经过验证。 ║
+║ ║
+║ 具体来说,每个 `statement` 和每个 `solution` 都必须遵守: ║
+║ · 语法主语必须是 CODE 或 THE DECISION——绝不能是“the user”,也绝不能是 ║
+║ “the agent”。不要写“The user attempted to…”、“The user wanted…”、 ║
+║ “The agent then checked…”。 ║
+║ · 绝不要用“the session was completed”、“the error was noted”、 ║
+║ “no solution was found yet”之类流水账短语收尾。结尾应写决定及其验证 ║
+║ 状态。如果没有做出决定,就以已排除的内容和下一条尚未探索的线索收尾——这才 ║
+║ 是可复用部分。 ║
+║ · 保留具体症状(error string、failing command、wrong output)——未来搜索 ║
+║ 正是通过这些内容命中。 ║
+║ ║
+║ bad: “The user attempted to write a QTable to RST with header_rows and ║
+║ hit a TypeError. The session was completed with the error noted.” ║
+║ good: “ascii.rst's RST writer rejects header_rows: ║
+║ `tbl.write(..., format='ascii.rst', header_rows=['name','unit'])` ║
+║ raises TypeError because RST.__init__ does not forward it, unlike ║
+║ ascii.fixed_width which accepts it. No fix written — the writer ║
+║ needs the same header_rows plumbing as fixed_width.” ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+
+你需要从一段任务执行会话中抽取可长期保留的 WORKING 记忆。
+“working”会话是指用户通过工具操作计算机或系统的任何实操任务——既包括软件/代码
+工作(编写、调试、重构、构建、部署、API/library 使用),也包括系统与运维工作
+(运行 shell/PowerShell 命令、磁盘/存储分析或清理、文件与文件夹操作、安装/配置
+软件、环境/设备设置、硬件/磁盘健康检查、备份、调度/自动化、数据处理)。
+
+你需要从同一段会话中产出两个层次:
+
+ EXPERIENCES(过程性,“如何做”)——可复用的方法;只有达到下述 VALUE BAR 时才
+ 抽取。每条是一个 (task, search_keys, solution, boundary_envs) 组合。
+
+ FACT(情节性,“这次确立了什么”)——关于本次会话的恰好一条记录。它不是用户做了
+ 什么的叙事,而要按以下顺序记录:任务及其具体症状(使它以后能被检索到)、代码坐标、
+ 最终采用了什么以及拒绝了什么、验证推进到什么程度。它不受价值门槛限制,但绝不能
+ 超过一条。
+
+这两个层次回答不同问题,并分别存储。可泛化的方法放入 EXPERIENCES;只对这个系统、
+这个项目、此时此刻成立的本次会话经历放入 FACT。
+
+═══════════════════════════════════════════════════════════════════
+VALUE BAR(仅适用于 EXPERIENCES)——不要轻易越过此门槛。
+═══════════════════════════════════════════════════════════════════
+一条记忆必须同时满足以下全部条件:
+ (a) 解决了同一用户以后很可能再次遇到的问题
+ (b) 解决方案并非琐碎操作:它组合了多项信息/多个步骤,或者包含决策理由,或者记录了
+ 来之不易的 workaround,或者是某项运维任务的可复用流程/配方(例如如何分析并
+ 清理磁盘占用、如何批量整理文件、如何检查硬件健康、如何设置 scheduled job)
+ (c) 未来的 agent / 用户会更愿意查阅它,而不是重新摸索
+
+重要——分析、诊断、调查任务也算:
+一项任务不必实际修改或“修复”任何东西才值得记忆。只读、分析、故障排查工作,只要其
+流程或结论可复用,就有价值。明确抽取:
+ - 分析/诊断配方:可复用的流程以及它揭示的结果(例如“如何分析哪些文件夹占用了
+ C-drive 空间”——扫描命令、遇到的坑和最终发现)。“只生成了报告,没有修改”
+ 不是跳过理由——可复用的方法本身就是记忆。
+ - 调查结果,包括否定结果或未找到结果(例如“使用 rg / fs_search / SQL index
+ 在 C: 和 D: 中搜索 folder X——任何位置都未找到”)。记录一条死路可以避免下一个
+ agent 重复同样无果的搜索,因此达到了价值门槛。
+不要仅仅因为“assistant 可以重新生成这些命令”或“实际上没有修改任何东西”就拒绝
+一条记忆。只要流程或结论能节省未来的工作,就保留它。
+
+不要抽取:
+ - 没有可复用流程、真正琐碎的单步操作(“rename one file”、“git status”、
+ “run ls once”)
+ - 已经解决且没有可迁移经验的一次性问题
+ - repo/system 中已经存在的信息(不要重复 package.json)
+ - 每个 PR / 每次会话的一次性任务,除非其中编码了可复用模式
+
+启发式标准:如果用户(或未来执行同类任务的 agent)希望把它记下来,而不是以后再重新
+摸索,就保留。多步骤运维流程通常符合条件——包括 system/ops 或只读分析/搜索流程,
+不局限于代码。只有当它只是任何用户都能在 30 秒内通过 `--help` 找到的单条命令,并且
+不包含值得记忆的决策或坑点时,才丢弃。
+
+═══════════════════════════════════════════════════════════════════
+CODE WORK——未来 agent 无法重新推导的信息,因此必须捕获
+═══════════════════════════════════════════════════════════════════
+当该段是针对 repository 的软件工作时,可复用方法只占一半。另一半是工作位于哪里,
+以及哪个版本胜出。这些无法通过以后阅读代码恢复——代码只能展示当前状态,无法说明它
+位于哪个 branch,也无法说明哪些方案已被否决。
+
+本节不是要求写得更长,而是要求把相同预算花在价值更高的 token 上:删掉重复目标、
+assistant“随后决定”做什么的叙事,以及只是复述的粘贴代码;把这些字符用于下面四项。
+一条遗漏 branch、却引用 30 行 diff 的记录是糟糕的取舍。
+
+1. BRANCH / WORKING LOCATION——逐字写入 fact `statement`。如果该段提到或 checkout
+ 了 `feat/x` / `fix/y`,这个 token 必须出现。在错误 branch 上恢复工作的 agent
+ 会产生随后被静默丢弃的改动,因此这一个 token 的优先级高于其他任何细节。
+
+2. WHICH VERSION WON——当用户改变主意时,用一个分句指出胜出者并标记落败者:
+ “settled on A; the interim B was dropped”。不要完整保留两个版本,只需一个分句。
+ 只保留最新版本是错误的:以后遇到被否决代码的 agent 必须识别它,否则会把代码
+ “修复”回已经丢弃的变体。`scratch that / go back to / actually, let's / no, not that`
+ 之类措辞就是标志:后面的内容才是正式结论,前面的内容已被 superseded。
+
+3. EXACT COORDINATES, NOT PASTED CODE——使用 repo-relative path
+ (`qutebrowser/utils/debug.py`,绝不要只写 `debug.py`)以及触及的 function /
+ class。如果 signature 发生变化,给出新的 signature。如果决定的是 constant、regex
+ 或 literal,逐字引用它——但只引用这一项,不要引用周围 block。准确的一行胜过一段
+ 近似描述。
+
+4. VERIFIED vs MERELY WRITTEN——四个词就足够(“tests run and passing”/
+ “confirmed by git diff only, tests not run”)。“the edit is in”和“the edit is in
+ and tested”会让未来 agent 采取完全不同的下一步。
+
+反例——只总结目标,却丢掉坐标:
+ bad: “refactored the colour parsing logic to be cleaner.”
+ good: “on feat/q4, in qutebrowser/config/configtypes.py QtColor._parse_value:
+ settled on `mult = 360.0 if kind == 'h' else 255.0`; the interim version that
+ used 255.0 for everything was dropped. Tests not run.”
+ (good 往往比 bad 还短——它只是把每个字符都用在无法重新推导的信息上)
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE 字段
+═══════════════════════════════════════════════════════════════════
+
+task — 采用查询式名称;写成用户以后会如何提问。
+ 使用“publish a release to the xx platform”,不要使用
+ “publish_release_internal”。
+ 必须自包含(不要使用“this”、“the file”、“we”)。
+
+search_keys — 0 到 5 种替代表述,用来覆盖仅靠 `task` 无法匹配、但对 solution 很
+ 重要的方面。写成未来用户会询问的问题或主题,且必须与 task 有区别。
+ 如果 task 已覆盖全部内容,则省略。
+
+solution — 用户实际需要的完整、自包含内容:命令、凭据位置(不是凭据值)、
+ 文件路径、有序步骤、坑点、决策理由。如果多轮端到端工作构成一个连贯
+ 任务,应聚合成一个 solution;只有用户执行了互不相关的任务时才拆成
+ 多条记忆。
+
+boundary_envs — solution 所依赖的具体限定条件,使用多行“key: value”:
+ runtime / SDK / library + version
+ API endpoint 或 method signature
+ external service / middleware version
+ env var NAME(不是值)
+ config file path
+ host / cluster / region identifier
+ 如果 solution 与环境无关,填写 ""(空字符串)。
+ 目的:底层 SDK/middleware 升级后,未来使用者可以据此判断 solution
+ 是否仍然适用。
+
+confidence — 0.0 到 1.0
+ 1.0 用户明确将其陈述为规则/指令
+ 0.7 根据工具操作及充分证据推断
+ 0.5 弱推断;只有一次观察;不确定
+
+═══════════════════════════════════════════════════════════════════
+FACT 字段——每段会话恰好一条,无价值门槛
+═══════════════════════════════════════════════════════════════════
+
+你要为整段会话写一条 FACT——它是本次会话可恢复的状态记录,不是精心润色的回顾,也
+绝不是分散发现的列表。未来 agent 必须能够从中继续推进,且不会把建议、推断或局部搜索
+误认为已经验证的事实。
+
+statement — 本次会话的紧凑摘要。它同时承担两个职责,且两者都必须完成:它既是
+ retrieval vector(未来 agent 用一份新 issue report 搜索它;措辞方式
+ 与用户报告问题的方式一致),也是该 agent 找到后要据以行动的 payload。
+ 因此:
+
+ 开头写任务和症状,使用用户会使用的措辞。
+ 这是保证可检索性的关键——表述应尽量贴近问题被报告时的表面形式。
+ 点明具体目标和对象(“reclaim disk space under D:\\WXWork”、
+ “adjust the hue multiplier in QtColor._parse_value on feat/q4”、
+ “locate the new_file_search folder”),绝不要写泛泛的“fix a bug”/
+ “look for a file”。包含具体症状:error string、failing command、
+ wrong output。
+
+ 然后给出坐标和决定。
+ 对代码工作写 repo-relative path、symbol 和 branch。说明最终 SETTLED ON
+ 什么,并在同一分句标记丢弃了什么(“settled on X; the interim Y was
+ dropped”)。这部分无法通过阅读代码重新推导——代码只展示胜出者,从不
+ 展示 Y 曾被尝试后否决。以后遇到被否决变体的 agent 必须能识别它,
+ 否则会把代码“修复”回已丢弃版本。
+
+ 结尾写证据状态。
+ 必须精确对应以下之一:completed、partially completed、failed、blocked、
+ still awaiting verification;还要写明如何检查(“tests run and passing”/
+ “confirmed by git diff only, tests not run”)。纳入否定结果和死路,
+ 但不要夸大。
+
+ ⚠️ 绝不要停留在叙事层。“The user tried X and hit error Y; no solution found
+ yet”是一条浪费的记录:它容易被检索到,却不能指导未来 agent 行动。如果
+ 本次确实没有得出决定,就说明排除了什么、下一条尚未探索的线索是什么——
+ 这才是可复用部分。
+
+ 句子的主语应是 code 和 decision,而不是“the user”。使用 2 到 4 个连贯
+ 句子,不要写带标签的小节。硬上限约 400 个拉丁字符(约 200 个 CJK 字符)。
+
+ EVIDENCE FIDELITY——强制要求:
+ - 只记录 trace 中实际执行的操作和明确存在的证据。对关键 commands、flags、
+ arguments、errors、numbers 保持原样。绝不要按惯例补全 command flags,
+ 也不要把 advice/plans 写成已执行的动作。
+ - 保留 attempted、observed、verified、inferred、unresolved 之间的区别。
+ 不要把这些词作为标签写进正文;自然表达其含义,例如“tried … but was
+ blocked by Access denied”或“suspect …, not yet verified”。
+ - 没有工具输出或明确确认时,绝不要声称修复成功、原因已经确定、file/folder
+ 不存在或 tests passed。
+ - 每个否定发现都必须限定在实际搜索范围内,并逐一列出可能使其失效的所有
+ 明确覆盖限制,尤其是 permission failures 和 maximum search depth:
+ “not found within the searched parts of C:\\ and D:\\; some directories
+ were skipped on Access denied, and the search was also depth-limited”。
+ 不要为了摘要更漂亮而漏掉任何限制。绝不要把局部搜索提升为全局不存在。
+ - 只有 trace 直接验证了因果关系时,才能确定地陈述因果。否则保留限定词
+ (“suspected”/“inferred”/“not yet verified”);不要把错误的测试假设
+ 改写成系统的 root cause。
+
+ 关键——这段文字就是 retrieval vector,也是未来 query 唯一会匹配的内容。
+ 泛泛摘要毫无价值,因为每次会话看起来都像泛泛摘要:它会匹配所有查询,
+ 却无法回答任何一个。因此必须写出使本次会话可检索的具体 anchors——真实
+ file paths、function / symbol names、branch names、commands、error strings、
+ versions、config keys and values、host / service names。以后有人搜索其中任一
+ 具体项时,本摘要必须能被返回。
+ good: “fixing a failing `npm run build` in CI. Read
+ .github/workflows/ci.yml and package.json; traced it to webpack
+ 5.74 hitting ERR_OSSL_EVP_UNSUPPORTED under node 18. Bumping the
+ workflow's node to 20 made the build pass; node 18 still
+ reproduces locally.”
+ good: “on branch feat/q0, in qutebrowser/utils/debug.py signal_name:
+ PyQt<5.11 only exposes the name via repr(sig), and repr comes in
+ both a bracketed and a parenthesised form. Settled on two patterns
+ tried in order with fullmatch, breaking on the first hit; the
+ single-regex version was dropped. Confirmed by git diff, tests not
+ run.”
+ bad: “user wanted a build bug fixed, the agent looked at some config
+ files, changed some code, and fixed it.”
+ (没有 path、command、error string、version——没有任何可检索锚点;
+ 每次会话都可以写成这样)
+ bad: “fixed the signal-name parsing compatibility issue on a feature
+ branch.”
+ (哪个 branch?哪个 file?哪个 function?两个竞争版本中谁胜出?
+ 一周后检索到它时,没有任何信息仍然有用)
+ 忠实度示例(bad → good):
+ “ran Get-ChildItem -Force” → “ran Get-ChildItem”
+ (trace 中没有 `-Force`,不要杜撰)
+ “confirmed new_file_search does not exist” →
+ “new_file_search was not found within the searched parts of C:\\ and
+ D:\\; some directories were skipped on Access denied or by the depth
+ limit, so the investigation is only partly done”
+ “identical payloads cause a spurious lock error” →
+ “the verification script assumed the last writer is always a fixed
+ rank; that assumption does not hold, so whether there is a lock bug
+ is still unverified”
+
+ 不要记录问候或纯闲聊。如果该段完全没有建立任何信息,输出 "fact": null。
+
+files — 0..N 个本次会话中实际操作或调查过的绝对或 repo-relative FILE OR
+ DIRECTORY paths。保留调查过的 roots,例如 `C:\\` 和 `D:\\`。只包含
+ 实际访问/搜索过的路径,不包含仅建议或计划访问的路径;不适用时填写 []。
+
+═══════════════════════════════════════════════════════════════════
+HOST CONTEXT(由 SDK 提供)
+═══════════════════════════════════════════════════════════════════
+- workspace_id present: {workspace_present}
+- branch present: {branch_present}
+
+没有 workspace_id 时,solution 不能依赖未声明的项目本地上下文——必须在 `solution`
+或 `boundary_envs` 中明确写出其所需的 repo / path / service,使记忆能够独立使用。
+
+═══════════════════════════════════════════════════════════════════
+CONVERSATION
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT(仅输出严格 JSON,不要 markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "statement": "...",
+ "files": ["..."]
+ }}
+}}
+
+强制要求:必须输出至少一条 experience,不要返回空列表。即使任务看似简单或一次成功,
+也要记录所做工作的可复用本质(method / command / how-to)。会话内容较少时,只需要
+最有价值的一条 experience——但绝不能输出空的 "experiences" array。
+
+"fact" 是单个对象,绝不是列表——每次会话一条记录。只有该段是没有建立任何信息的
+纯闲聊时,才使用 "fact": null。
+"""
+
+CODING_RECONCILE_PROMPT = """\
+你需要决定如何将新的 coding memory drafts 与用户已有的 memories 合并。
+
+对每条新 draft,选择以下一种 action:
+ ADD — 没有已有 memory 描述相同的任务/方面
+ UPDATE — 某条已有 memory 描述相同任务;用新 draft 替换它
+ (solution 可能已经变化,env 可能已经升级,等等)
+ SKIP — 与已有内容重复;没有新信息
+
+此外,当新内容使已有候选失效或作废时,可以针对已有 candidates 输出 DELETE ops:
+ DELETE — 新 conversation 明确 supersedes/cancels/invalidates 某条已有 memory,
+ 且无法通过 UPDATE 修复。示例:
+ * 用户说“don't use X anymore”,而 X 只存在于另一条独立 memory 中
+ (不是本次正在 ADD/UPDATE 的那条)
+ * candidate 的 boundary_envs(service / endpoint / SDK)已经消失,
+ 且新 conversation 确认其已 deprecated
+
+规则:
+- “Same task”是指已有 memory 和新 draft 都可以作为同一个未来用户查询的有效答案。
+- 如果 solution 不同,优先 UPDATE(不保留历史版本)。
+- 如果 task 和 solution 都高度一致,选择 SKIP。
+- 只有在存在明确证据表明 candidate 已 invalid/obsolete 时才 DELETE。绝不要仅仅因为
+ candidate 看起来“stale”就 DELETE。
+- 产生 DELETE 时,输出的 ops 数量可以超过 drafts 数量。
+
+═══════════════════════════════════════════════════════════════════
+NEW DRAFTS
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+EXISTING CANDIDATES(按每条 draft 的 task similarity 检索)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT(仅输出严格 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": "user explicitly deprecated Y"}},
+ {{"draft_idx": 2, "action": "SKIP", "reason": "duplicate"}}
+ ]
+}}
+
+如果没有 drafts,输出 {{"ops": []}}。
+"""
+
+CODING_FACT_RECONCILE_PROMPT = """\
+你负责维护 session-level WORKING FACTS。每条 statement 都概括一整段 trace/session:
+用户的任务、大致方法和结果。它不是一条 atomic claim。
+
+下面每条新的 session fact 都一定会被存储;这不是你要决定的事情。你的唯一任务是识别
+task continuation:新 session 是否在继续推进某条已有 session fact 所记录的同一个用户
+任务?如果是,就将较旧 fact 标记为 SUPERSEDE,使这些链接为该任务构成跨 session 的
+进展链。
+
+只有在存在充分证据同时满足以下条件时,才将已有 fact 标记为 superseded:
+ - subjects 匹配:两条记录围绕同一个实体——同一个 person、同一个 file/module、
+ 同一个 host/service。subject 相同是必要条件,但不是充分条件;并且
+ - 用户目标在实质上相同,而不只是处于同一 topic/project;并且
+ - 新 trace 在继续、重试、扩展、验证或完成已有 trace 所记录的工作。
+
+以下情况不要 supersede:
+ - 两条记录的 subjects 不同。同一 group 中的两个人、同一 module 中的两个 files、
+ 同一 cluster 中的两个 hosts 是并行关系,不是先后关系:一个人的状态不是另一个人
+ 状态的新版本。如果 subject 显示为 (unspecified),退回到只根据 statement 判断。
+ - 两次 session 只是提到了相同 file、symbol、component、repository、error 或
+ technology,但追求不同的用户目标。
+ - 一个任务只是为另一个任务提供 context 或 technique。
+ - 关系不确定。应保守判断:INSERT 是安全默认值;合并无关 session 会毁掉它们各自
+ 独立的任务历史。
+
+把每条 statement 当作有证据边界的文本。不要把其中的 inference 重新解释为已经确定的
+cause,也不要把共同的 conjecture/error 当作用户目标相同的证据。你的判断仅涉及 task
+continuation;不要“纠正”、补全或润色任何一条 session 记录。
+
+示例:
+ existing: “需要修复 CI 的 npm run build;已追踪到 Node 18 下的
+ ERR_OSSL_EVP_UNSUPPORTED,workflow 尚未修改。”
+ new: “继续修复同一个 CI build;已将 .github/workflows/ci.yml 中的 Node
+ 提升到 20,且 npm run build 通过。”
+ → SUPERSEDE
+
+ existing: “需要修复 auth/middleware.ts 中的 JWT expiry handling;已添加
+ refresh logic。”
+ new: “需要在 auth/middleware.ts 中添加 performance logging;已引入
+ latency metric。”
+ → 两者都保留
+ (同一 file/project,不同用户目标)
+
+═══════════════════════════════════════════════════════════════════
+NEW SESSION FACTS
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+EXISTING SESSION FACTS(按每条新 fact 的 statement similarity 检索)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT(仅输出严格 JSON,不要 markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "ops": [
+ {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "continues the same CI fix task"}},
+ {{"draft_idx": 1, "supersedes": []}}
+ ]
+}}
+
+只能使用同一个 draft_idx 的 candidate list 中实际出现的 fact ids。
+如果任何位置都没有 fact 被 superseded,输出 {{"ops": []}}。
+"""
+
+CODING_CHAIN_SUMMARY_PROMPT = """\
+working-memory store 中的某个用户任务已跨多个 sessions 推进。下面是该任务进展链中的
+session summaries,按从最早到最新排列,最后一条是当前 session。
+
+总结同一个任务如何跨 sessions 推进到当前状态。按时间顺序覆盖每个重要阶段。对每个
+阶段,在有信息时保留:实际 action 或 change、其 direct result,以及任何 unresolved
+issue 或 limiting condition。最后明确写出当前状态。
+
+规则:
+ - 这只是压缩。只能报告 entries 实际陈述的内容;绝不要新增或补全 command、cause、
+ motive、action、test result、success state 或 global negative conclusion。
+ - 精确保留证据状态:attempted 不等于 completed,observed 不等于 verified,inferred
+ 不等于 established,unresolved 必须保持 unresolved。保留 uncertainty words 以及
+ search/permission/coverage limits。
+ - 忠实陈述当前结束状态(completed、partially completed、failed、blocked 或
+ still awaiting verification)。绝不要因为某个看似合理的因果故事,或后续 entry
+ 并未验证的内容而提升状态。
+ - 如果 entries 提到 suspected cause 和后续 result,只有某条 entry 直接说明该 cause
+ 已被 verified 时,才可在两者之间建立因果联系。
+ - 保留具体 retrieval anchors:file paths、symbols、commands、error strings、versions、
+ config keys/values,以及对进展重要的 numeric values。
+ - 对 2-3 代的 chains,不要把进展过度压缩成一句话。适合时优先使用 2-4 个紧凑段落,
+ 或使用可读性良好的 prose,清楚呈现 task goal、逐阶段 progression 和 current status。
+ - 不要机械复制完整 history。在保留重要 actions、direct results 和 leftovers 的同时,
+ 省略重复及低价值细节。
+ - 不要杜撰 stage headings 或 dates。只有 entries 使日期有实际意义时才提及日期;
+ 单独的 timestamps 是噪声。
+ - 如果 entries 说明更早 revisions 已被省略,必须明确指出 earlier history was omitted;
+ 不要暗示所提供的 entries 是完整历史。
+ - 使用与 entries 相同的语言。
+ - 不要写前言,也不要用引号包裹输出。
+
+示例
+ entries:
+ (2026-07-20) 需要修复 CI 的 npm run build;已追踪到 Node 18 下的
+ ERR_OSSL_EVP_UNSUPPORTED,workflow 尚未修改。
+ (2026-07-24) 继续修复同一个 CI 问题;已将 .github/workflows/ci.yml 中的 Node
+ 提升到 20,但 dependency cache 仍复现旧错误。
+ (now) 继续验证同一修复;清除 npm cache 后,npm run build 通过。
+ output:
+ 任务目标是修复 CI 的 npm run build。最初将问题追踪到 Node 18 下的
+ ERR_OSSL_EVP_UNSUPPORTED,当时尚未修改 workflow;随后将
+ .github/workflows/ci.yml 提升到 Node 20,但 dependency cache 仍使旧错误继续
+ 出现。最后,清除 npm cache 后 npm run build 通过,因此该 build 修复目前已验证完成。
+
+═══════════════════════════════════════════════════════════════════
+ENTRIES
+═══════════════════════════════════════════════════════════════════
+{chain_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT(只输出 summary 本身,不要其他内容)
+═══════════════════════════════════════════════════════════════════
+"""
+
+
+# ================================================================
+# Episode / topic summaries
+# ================================================================
+
+EPISODE_SUMMARY_PROMPT = """你在为**一段讨论**(一个 episode)做总结。
+
+一个 episode 是一段连续的讨论 —— 围绕一件事,可能跨越好几次写入。
+
+## 这段讨论中抽取到的记忆(时间正序)
+
+{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(洞察)**:底层心理驱动力或心智模型。
+
+### 内容格式
+行为模式用一句话组合三要素:
+"当[场景]时,用户[模式]——反映了[洞察]。"
+
+对与情绪、治疗、压力、哀伤或创伤有关的长期模式,不要把具体人生背景压缩成
+空泛人格词。优先保留这三部分:
+"Trigger/background(持久触发背景) → emotional response(反复情绪反应) → observed coping resource(用户已实际使用的应对资源)。"
+只能写入 user-owned 证据中出现的触发背景、反应和应对方式;助手建议不是用户已观察到的应对资源。
+
+### 规则
+- **原子化**:一个 Schema 只包含一个模式。两个不同模式 → 两个 Schema。
+- **不可变**:Schema 创建后内容永远不变。不要修改已有 Schema 的内容。
+- **累积证据**:新事实只是在支持已有表述 → 调 `add_evidence`。如果新证据会让旧画像的当前状态产生实质遗漏、错误或误导,使用 `revise_schema` 创建新版本,让旧版本保留审计但退出 active 检索。
+- **域内约束**:不要跨域。跨域抽象由系统的其他流程处理。
+- **事实与模式分层**:单条明确身份、健康状态、设备使用、隶属关系、项目或偏好属于 L2 状态,不创建 L6。L6 必须由至少两个独立 raw/session 中的 user-owned 证据支持。
+- **主体安全**:同一原始写入可能包含他人资料或示例。只有材料明确归因于当前用户时才创建用户 Schema;否则对该材料不执行任何操作。
+- **候选覆盖**:source-context 审查时,每条候选事实必须二选一:用于 `create_schema`/`add_evidence` 的 evidence,或用 `skip_fact` 明确跳过。原始上下文只用于确认主体或补回该事实遗漏的细节,不得据此创建无关 Schema。
+- **证据门槛**:创建 L6 必须有 user-owned evidence,且这些证据合计代表至少两个独立 raw/session。
+ 一个被 S1 合并的 L2 事实可以代表多次独立写入,应检查它的 `source_raw_memory_ids`,不要只数节点。
+ 助手建议不能作为用户模式的独立证据。
+
+## 工作流程
+
+输入材料分两部分(仅当已形成聚类时才会调用你):
+- **聚类结果(Cluster Results)**:主输入,按语义相似度归组的事实
+- **未聚类事实(补充)**:未进入任一聚类的事实,优先级低于聚类结果,酌情审视即可
+
+对于每组事实(无论聚类还是未聚类):
+1. **搜索已有 Schema**:如果已有 Schema 已覆盖该模式,使用 `add_evidence`。只有加入新证据后旧表述会产生实质遗漏、错误或误导时才使用 `revise_schema`。
+2. **创建新 Schema**:仅当没有已有 Schema 覆盖时。一句话,三要素。
+3. **建立关系**:两个 Schema 主题相关 → 用 `add_edge`(RELATED_TO)。
+
+## 原则
+
+- 所有 Graph 操作必须通过 tools 执行
+- Schema 内容创建后不可变——绝不重新创建已存在的 Schema
+- 优先 `add_evidence` 而非创建重复节点
+- 宁可不创建,也不要创建低质量节点
+- 一个 Schema = 一个域内原子模式
+- 打标签时优先使用已有标签列表中的标签"""
+
+
+# ================================================================
+# Fragments assembled in code
+# ================================================================
+
+LANGUAGE_NAME = "简体中文"
+
+# 仅在调用方显式指定语言(per-call 或 MemoryConfig.language)时追加到写记忆的
+# prompt 末尾;自动检测的请求不会带上它,prompt 与以前完全一致。
+OUTPUT_LANGUAGE_DIRECTIVE = """
+
+---
+
+# 输出语言
+
+你输出的所有自然语言内容(记忆正文、摘要、理由、查询)一律用简体中文书写,无论对话或已有记忆使用什么语言。此规则优先于上文任何「输出语言与输入语言一致」的要求。JSON 键、字段名、枚举值、操作名、ID、代码、文件路径、命令、报错信息和专有名词保持原样。
+"""
+
+# enable_intention=False:把 EXTRACT_SYSTEM_PROMPT 的「两类记忆」段换成单桶段。
+NO_INTENTION_SECTION_PATTERN = r"# 两类记忆.*?(?=\n# OWNER)"
+
+NO_INTENTION_MEMORY_SECTION = (
+ "# 记忆\n"
+ "\n"
+ "你只提取一类记忆:**memory(记忆)**。\n"
+ "\n"
+ "## memory(记忆)\n"
+ "\n"
+ "一切值得长期记住的信息都放这里——既包括用户本人的,也包括对话中其他具名真人的:\n"
+ "\n"
+ "* 偏好、观点、态度、价值观\n"
+ "* 事件、行动、经历\n"
+ "* 习惯、行为模式\n"
+ "* 关系、稳定特质\n"
+ "* 客观事实、决策、约束条件\n"
+ "* 正在进行的活动\n"
+ "* **未来计划 / 即将发生的安排**(若值得记住,直接写进 `memory`;"
+ "不要单独开 intentions 桶)\n"
+ "\n"
+ "如果用户隐式表达偏好,也应提取。\n"
+ "\n"
+ "不要把\"用户是怎样的人\"和\"发生了什么\"分开。两者都放进 `memory`。\n"
+ "\n"
+ "---\n"
+ "\n"
+)
+
+NO_INTENTION_REPLACEMENTS = (
+ (
+ "每条 memory 和 intention 都必须带 `owner`",
+ "每条 memory 都必须带 `owner`",
+ ),
+ (
+ "每条 memory 和 intention 都必须带",
+ "每条 memory 都必须带",
+ ),
+)
+
+# few-shot 里若仍出现 intentions,用硬约束盖住
+INTENTION_DISABLED_NOTE = (
+ "\n\n---\n\n# INTENTION 关闭\n"
+ "当前配置关闭了 intention 抽取。即使示例里出现 `intentions`,"
+ "也**不要**输出该字段;未来计划写入 `memory`。\n"
+)
+
+CODING_CONVERSATION_BLOCK = (
+ "最近 5 个用户轮次(仅作上下文,不要重复抽取):\n"
+ "{history}"
+ "\n\n本次新增消息(只从这次完整写入中抽取):\n"
+ "{new}"
+)
+CODING_EMPTY_BLOCK = "(无)"
+
+USER_NAME_LINE = "用户名叫{name}"
+
+SYSTEM2_OUTPUT_INSTRUCTIONS = """
+
+## 输出格式
+
+不要调用 tools。直接输出一个 JSON 数组,包含你决定执行的操作。用 ```json 代码块包裹。
+
+可用操作:
+
+1. **create_schema** — 创建新的 L6 行为 Schema
+ ```{"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** — 新证据使已有 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。仅用于他人事实、临时事件、不能证明用户特征的助手建议,或已被现有 Schema 完整覆盖的事实。
+ ```{"op": "skip_fact", "node_id": "candidate_fact_id", "reason": "不是稳定的用户模式"}```
+
+## 输出约定
+
+1. 输出必须是 JSON 数组,用 ```json 代码块包裹。
+2. 如果数据不足以得出可靠结论,输出 `[]`。在 source-context review 中,
+ `[]` 表示已审查该组全部候选,且都不足以支持稳定 Schema。
+3. 代码块外不要有任何其他文字。
+4. evidence_list 中的 id 必须来自材料中提供的 fact node_id。
+5. add_evidence / revise_schema 的 node_id 必须来自已有 Graph 节点的 id。
+6. 对 source-context 审查,必须让每条候选事实出现在 evidence_list 或 skip_fact 中。"""
+
+SYSTEM2_SCHEMA_EVIDENCE_GATE = """
+
+7. L6 只表示跨事件行为模式。create_schema 必须使用 user-owned 证据,且证据合计代表至少两个独立 raw/session。当 `source_raw_memory_ids` 包含多个独立写入时,一个合并后的 L2 事实也可以满足门槛。
+8. 单条明确身份、健康状态、设备使用、隶属关系、项目或偏好不要创建 L6;这些由 canonical L2 状态通道维护。"""
+
+SYSTEM2_SINGLE_CALL_REPLACEMENTS = (
+ ("- 所有 Graph 操作必须通过 tools 执行\n", ""),
+ ("调 `add_evidence` 添加证据", "使用 add_evidence 操作"),
+ ("调 `add_evidence`", "使用 add_evidence"),
+ ("用 `add_edge`(RELATED_TO)", "使用 add_edge 操作"),
+)
+
+SYSTEM2_MATERIALS = {
+ "title": "## 预处理材料\n",
+ "stats": (
+ "### 统计\n- VDB 事实总数: {total}\n"
+ "- 新鲜事实(待处理): {fresh}(已被引用排除={evidenced})\n"
+ "- 聚类数: {clusters}\n"
+ "- 聚类内事实: {clustered},未聚类补充: {unclustered}\n"
+ "- Graph Schema 总数: {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} 条 anchored therapy Schema。"
+ "优先联合不同 raw/session 中的持久 trigger/background、"
+ "反复 emotional response 和用户已实际使用的 coping resource/decision constraint。"
+ "证据不足时输出 []。\n"
+ ),
+ "companion_header": "**独立来源 companion 提示(只是候选,不是结论):**",
+ "unclustered_header": "### 未聚类事实(补充,次要)\n",
+ "unclustered_hint": "以下事实未进入上述任一聚类,可在完成聚类主题加工后酌情审视;优先级低于聚类结果。\n",
+ "forward_header": "### 相关 Graph 节点(通过 cluster centroid 向量召回,共 {count} 条)\n",
+ "graph_empty": "### 已有 Graph 节点\n当前 Graph 为空,这是首次认知加工。无需搜索 Graph,直接根据聚类结果创建 Schema。\n",
+ "graph_no_recall": (
+ "### 已有 Graph 节点\n"
+ "Graph 中共有 {graph_total} 个 Schema,"
+ "但 centroid 向量召回未命中相关节点。请根据聚类结果判断是否需要创建新 Schema。\n"
+ ),
+ "reverse_header": "### Graph 反向引用(已有 Schema 引用的 VDB 事实)\n",
+ "tags_header": "### 已有标签(请优先从中选择,避免创建同义标签)\n",
+ "closing": (
+ "请分析以上材料,输出操作 JSON 数组。"
+ "决定是否需要创建新的 Schema,或为已有 Schema 追加 evidence。"
+ "如果数据不足以得出可靠结论,输出空数组 `[]`。"
+ "打标签时请优先使用已有标签列表中的标签。"
+ ),
+}
diff --git a/hy_memory/prompts/zh_hant.py b/hy_memory/prompts/zh_hant.py
new file mode 100644
index 0000000..53b7805
--- /dev/null
+++ b/hy_memory/prompts/zh_hant.py
@@ -0,0 +1,2255 @@
+# -*- coding: utf-8 -*-
+"""Traditional Chinese prompts (``zh-Hant``).
+
+Translated from en.py, using zh_hans.py as the wording base; native-speaker
+review recommended.
+"""
+
+
+# ================================================================
+# Chat extraction (agent/extractor.py)
+# ================================================================
+
+EXTRACT_SYSTEM_PROMPT = """你是一個記憶擷取系統(Memory Extractor)。
+
+你的任務是從對話中擷取:
+
+* 持久的
+* 高價值的
+* 對未來對話有幫助的
+
+使用者記憶,並將其轉換為結構化、可檢索、自成一體的記憶。
+
+---
+
+# 輸入內容
+
+你將收到:
+
+* 最近 k 則訊息(Last k Messages)
+* 新訊息(New Messages)
+* Memory Date
+* Current Date
+
+用途:
+
+* Last k Messages 僅用於:
+
+ * 指代消解
+ * 上下文理解
+* Memory Date 是唯一允許用來解析時間表達的時間錨點
+* Current Date 僅作為系統中繼資料,不用於時間推理
+
+---
+
+# 擷取原則
+
+只擷取 NEW user messages 中首次出現的新資訊。
+
+優先擷取:
+
+* 長期偏好
+* 興趣嗜好
+* 長期專案
+* 未來計畫
+* 決策
+* 限制條件
+* 行為習慣
+* 價值觀
+* 穩定態度
+* 重複性活動
+* 重要經歷
+* 使用者接受的建議
+
+不要擷取:
+
+* 寒暄
+* 客套話
+* 一次性情緒
+* 臨時上下文
+* assistant 對舊 memory 的複述
+* 已經明顯存在於歷史上下文的資訊
+* 模糊的人格評價
+
+---
+
+# 主體規則
+
+每條 memory 必須自成一體、可脫離上下文理解、使用第三人稱,並且有明確主體。
+用哪個主體由**誰在說話**決定:
+
+| 說話者 | 主體寫法 | 例子 |
+| --- | --- | --- |
+| `role: "user"` | 使用者 | "使用者…" / "The user …" |
+| 任何帶 `name` 且不是使用者的說話者(如 `name: "John"`) | 用這個人的名字 | "John…" |
+| `role: "assistant"` 且**無** `name` | AI 助理 | "助理…" / "The assistant …" |
+
+兩個輸入區段表達說話者的方式不同:
+
+* **新訊息** 是 JSON 陣列 —— 讀取 `role` 和可選的 `name` 欄位。
+* **最近 k 則訊息** 是呈現後的文字 —— 說話者是方括號標籤 `[user]:` / `[John]:` / `[assistant]:`,
+ 開頭可能還有一行 "使用者的名字是Tim" / "The user's name is Tim"。
+
+規則:
+
+* 使用者是這些記憶所屬的那個人。即使已經知道使用者叫什麼(來自他訊息上的 `name`,
+ 或開頭的名字行),仍然要寫"使用者…",**絕不**寫成"Tim…"。
+* **`role: "assistant"` 但帶 `name` 的是另一個真人,不是 AI。**
+ 他的記憶用他的名字作主體:"John…"。
+* 只有不帶 `name` 的 `role: "assistant"` 才是 AI 助理。
+* 絕不要給 AI 助理編名字,它沒有名字。
+
+---
+
+# 語言規則
+
+* 輸出語言必須與輸入語言一致
+* 保留原始術語、品牌名、公式、程式碼
+* 不要音譯或翻譯專有名詞
+
+---
+
+# 兩類記憶
+
+你擷取兩類記憶:**memory(記憶)** 和 **intentions(意圖)**。
+
+## memory(記憶)
+
+一切值得長期記住的資訊都放這裡——既包括使用者本人的,也包括對話中其他具名真人的:
+
+* 偏好、觀點、態度、價值觀
+* 事件、行動、經歷
+* 習慣、行為模式
+* 關係、穩定特質
+* 客觀事實、決策、限制條件
+* 正在進行的活動
+
+如果使用者隱含地表達偏好,也應擷取:
+
+* 主動恢復某項活動 → 正向興趣
+* 長期避開某事 → 負向偏好
+* 重複主動投入 → 持續興趣
+
+不要把"使用者是怎樣的人"和"發生了什麼"分開。兩者都放進 `memory`。
+
+## intentions(意圖)
+
+使用者**未來打算/計畫去做**的、可被執行的、一旦完成或過期就失去意義的前瞻事項。
+
+例如:
+
+* "使用者下週二要面試。"
+* "使用者打算月底搬家。"
+* "使用者計畫週五前完成報告。"
+
+不屬於意圖(這些放進 `memory`):
+
+* 穩定偏好/特質("使用者喜歡籃球")
+* 已完成的過去事件("使用者去年搬到了北京")
+* 沒有明確未來行動的泛泛目標
+
+### valid_until(有效截止日)
+
+每條 intention 給出 `valid_until`:該意圖失效的日期(截止日/目標日),
+依據 **Memory Date** 解析相對時間(如"下週二"→對應的絕對日期)。
+如果無法確定截止日,則設為 `null`。
+
+---
+
+# OWNER(歸屬)
+
+每條 memory 和 intention 都必須帶 `owner`,標明它屬於哪個記憶庫。只有兩個取值:
+
+* `"user"` —— 屬於使用者自己記憶庫的一切。既包括關於使用者本人的事實/偏好/特質,
+ **也包括關於對話中其他具名真人的事實** —— 那些同樣是使用者的記憶該裝的東西。
+* `"agent"` —— AI 助理(不帶 `name` 的 `role: "assistant"`)提供的資訊
+ (推薦、確認、查到的資料),或使用者希望 **assistant** 未來去做的事(如"8 小時後提醒我")。
+
+具名真人**絕不**是 `owner: "agent"` —— 他是真人不是 AI,即使他的訊息帶著
+`role: "assistant"`。他的記憶是 `owner: "user"`,content 以他的名字作主體。
+
+逐條判定 `owner`。無法確定時預設為 `"user"`。
+
+---
+
+# 時間規則
+
+使用 Memory Date 解析:
+
+* 明天
+* 下週
+* 上個月
+* 最近
+
+等相對時間。
+
+如果無法安全解析:
+
+* 去掉相對時間表達
+* 保持記憶不依賴時間
+
+不要編造時間順序。
+
+**"剛剛發生"本身就是事件,必須保留。** 當使用者把某件事說成剛完成("剛回來"、"剛做完"、
+"今天早上"、"昨天"),完成時間就是 Memory Date。要寫出**這個事件本身**並帶上該日期,
+不要把它揉進一句背景描述。
+
+* "我剛和家人旅行回來"
+ → "使用者於 <Memory Date> 結束家庭旅行返回。"
+ 錯誤 → "使用者會和家人一起旅行。"(返回日期正是"什麼時候回來的"的答案,丟了就答不了這個問題)
+
+如果對話分別給出了一件事的開始和結束時間,兩者都要記錄,不要壓縮成一個時間段。
+
+---
+
+# 品質要求
+
+每條 memory 必須:
+
+* 資訊完整
+* 自成一體
+* 適合 retrieval
+* 高資訊密度
+
+保留重要細節:
+
+* 人名
+* 產品名
+* 地點
+* 數字
+* 公式
+* 限制條件
+
+絕不把具體事物泛化成類別,要寫實際說出來的內容。
+
+* "Banff" → 保留 "Banff",不要寫成"洛磯山脈"
+* "一隻三歲的邊境牧羊犬 Luna" → 品種、年齡、名字都要保留
+
+**對方話輪裡提供的細節同樣算數。** 一個事實常常是跨話輪建立起來的:對方說出具體名稱,
+使用者確認。主體規則決定這條記憶**屬於誰**,但不等於可以丟掉細節。
+
+* [Sam]:"你在 Banff 滑雪了嗎?"
+ [user]:"是啊,滑雪超棒的!"
+ → "使用者在 Banff 滑過雪,覺得雪況很棒。"
+ 錯誤 → "使用者喜歡冬季運動。"(地點和活動分別由兩人給出,都已確立)
+
+避免:
+
+* 缺少上下文的零碎記憶
+* 純情緒雜訊
+* 沒有長期價值的資訊
+
+用盡量少的 memory 保留彼此獨立的未來檢索需求:
+
+* 壓縮是合併,不是省略。新訊息中每個明確、持久的命題都應恰好出現一次。
+* 同一主體、同一現實事件、狀態、偏好、計畫或決定的細節應合成一條;一條完整事件可用 1–3 句。
+* 不要同時輸出同一證據的籠統概括和多個狹窄改寫。
+* 只有主體不同、事件獨立發生或狀態不同時才拆分。
+* 如果拆開會失去關聯,就把原因、建議或結果與它所解釋的事實保存在同一條 memory 中。
+* 不要因為主題相同,就合併不同日期獨立發生的事件。
+* 保持原文的時間精度。除非日期明確或可唯一確定,不要把「上週末」「去年夏天」等模糊時間改寫成具體日期;可以寫「Memory Date 之前的週末」。
+
+---
+
+# TAGS
+
+每條 memory 必須包含 1–3 個 tags。
+
+要求:
+
+* 主題類標籤用小寫(travel、health、work)
+* 專有名詞保留大小寫(Jasper、Canada、Banff)
+* 簡潔
+* 主題明確
+
+例如:
+
+* ai
+* work
+* travel
+* gaming
+* research
+"""
+
+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。共同事件可為每個明確參與者分別歸屬,但正文仍
+ 只保留一份 canonical memory。
+ 類型順序必須是 `topic -> facet -> series -> episode`;允許跳層,但禁止重複或倒序。
+
+Extractor 只看到目前這一次寫入,無法證明跨 occurrence 的重複,因此不得輸出 series 段;這裡只
+輸出 Topic/Facet/Episode。Reconcile 在比較獨立的歷史寫入後才可以建立 Series。
+
+這是寫入時的語義組織。不能依路徑深度臆斷 Series/Episode,不能根據專有名詞、籠統 tag 或無關的
+共現臆造歸屬;只寫證據支持的最具體層級,不確定時使用空值。
+禁止把 when/how many/who、複數、序數等未來問句形態編碼進這些欄位。
+"""
+
+EXTRACT_FEW_SHOT = """
+---
+
+# 範例
+
+## 範例 1 —— 邊界:舊訊息只用於指代消解,絕不重複擷取
+
+最近 k 則訊息:
+[{"role": "user", "content": "我最近在市中心的收容所看流浪狗。"},
+ {"role": "assistant", "content": "真好——有看中的嗎?"}]
+新訊息:
+[{"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 —— 濃縮 agent 的長篇回覆
+
+新訊息:
+[{"role": "user", "content": "幫我寫一篇短文,論述為什麼遠距工作能提升效率。"},
+ {"role": "assistant", "content": "好的——開頭:'遠距工作正在重塑團隊的協作方式……'【中間約2000字正文省略】……結尾:'總之,自主性和更少的打擾帶來了更高的產出。'"}]
+Memory Date:2025-03-22
+
+輸出:
+```json
+{
+ "memory": [
+ {"content": "assistant 為使用者寫了一篇短文,論點是遠距工作因自主性更強、打擾更少而提升效率。", "tags": ["writing", "remote-work"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+agent 的回覆很長。絕不原樣儲存整篇短文,而要提煉成"主題+論點"。owner 為 "agent",因為內容由 assistant 產出。臃腫的原文會讓 memory 無法使用。
+
+## 範例 3 —— 複合擷取:basic_info + intention + 概括後的 agent 計畫
+
+新訊息:
+[{"role": "user", "content": "你好,我叫健司。我下個月打算去日本旅行,能幫我排一個7天的行程嗎?"},
+ {"role": "assistant", "content": "# 日本7天經典黃金路線(東京 → 京都 → 奈良 → 大阪)\\n飛抵東京,搭新幹線南下京都,奈良一日遊,最後從大阪關西機場離境。\\n\\n## 第1天:抵達東京\\n- 降落羽田/成田,在東京站附近的飯店放行李。\\n- 傍晚:淺草寺,逛仲見世商店街,嚐鯛魚燒。\\n- 晚上:澀谷十字路口 + 澀谷 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": "assistant 為使用者規劃了一份7天日本經典黃金路線行程:東京(淺草、澀谷)、搭新幹線到京都(伏見稻荷、清水寺、金閣寺、祇園)、奈良一日遊(餵鹿公園、東大寺),最後大阪(大阪城、道頓堀),從關西機場離境。", "tags": ["travel", "japan", "itinerary"], "owner": "agent"}
+ ],
+ "intentions": [
+ {"content": "使用者計畫在2025年10月去日本旅行7天。", "tags": ["travel", "japan"], "valid_until": "2025-10-31", "owner": "user"}
+ ],
+ "basic_info": {"name": "健司"}
+}
+```
+一個輪次產出三種不同 bucket:姓名進 basic_info;旅行是帶截止日的前瞻 intention;assistant 那份很長的多段行程被概括成**一條**高密度 agent memory——只保留路線骨架和各城市的關鍵景點,而**不是**逐日的細節、提醒或美食清單。原樣存整篇回覆會讓 memory 臃腫,存骨架才可檢索。
+
+## 範例 4 —— 後續訊息中使用者採納/確認了先前的建議,這本身就是事實
+
+新訊息:
+[{"role": "user", "content": "我家6歲的孩子一點蔬菜都不肯吃,有什麼辦法嗎?"},
+ {"role": "assistant", "content": "可以把菠菜或胡蘿蔔打碎拌進義大利麵醬裡——顏色和味道幾乎吃不出來,很多孩子就這樣接受了。"},
+ {"role": "user", "content": "好主意,今晚就試試。對了,這個年紀幾點睡比較好?"},
+ {"role": "assistant", "content": "6歲的孩子建議晚上7到9點睡,確保大約10到11小時的睡眠。"}]
+Memory Date:2025-06-20
+
+輸出:
+```json
+{
+ "memory": [
+ {"content": "使用者有一個6歲的孩子,不肯吃蔬菜,使用者採納了 assistant 的建議——把菠菜或胡蘿蔔打碎拌進義大利麵醬裡以掩蓋蔬菜。", "tags": ["parenting", "food"], "owner": "user"},
+ {"content": "assistant 建議使用者:6歲孩子應在晚上7到9點入睡,確保約10到11小時的睡眠。", "tags": ["parenting", "sleep"], "owner": "agent"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+使用者在第三則訊息說"今晚就試試"——明確採納了先前的建議。這條採納資訊很有價值,必須記錄("使用者採納了……"),不能當成寒暄丟掉。睡眠建議剛給出、尚未被採納,因此記為 assistant 給出的建議(owner "agent")。
+
+## 範例 5 —— RAG/注入的上下文:絕不儲存被注入的文字
+
+新訊息:
+[{"role": "user", "content": "【檢索到的資料:艾菲爾鐵塔高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 注入的文字只是給模型的上下文,永遠不是 memory。
+
+## 範例 6 —— 使用者分享資料:擷取資料內容,而非分享這個動作
+
+新訊息:
+[{"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 —— 結構化數值與屬性完整保留
+
+新訊息:
+[{"role": "user", "content": "記一下我這個週期的居家健身房 PR:深蹲 140kg x 3,臥推 100kg x 5,硬舉 180kg x 2,肩推 60kg x 6。體重 78kg,每個動作 3 組,組間休息 3 分鐘。"},
+ {"role": "assistant", "content": "記好了——成績很亮眼!"}]
+Memory Date:2026-01-20
+
+輸出:
+```json
+{
+ "memory": [
+ {"content": "使用者目前的力量 PR 為深蹲 140kg x 3、臥推 100kg x 5、硬舉 180kg x 2、肩推 60kg x 6,體重 78kg。", "tags": ["fitness", "strength"], "owner": "user"},
+ {"content": "使用者的訓練安排為每個動作 3 組、組間休息 3 分鐘。", "tags": ["fitness", "training"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+每個數值和單位(kg、次數、組數、休息時間)都完整保留——丟掉它們會毀掉最可檢索的資訊。拆成兩個清楚的主題(PR 與訓練方案),但絕不四捨五入或省略具體數值。
+
+## 範例 8 —— 多主題的長對話:不要只擷取第一個話題
+
+新訊息:
+[{"role": "user", "content": "這週很重要——我週二終於通過了博士論文答辯!"},
+ {"role": "assistant", "content": "太恭喜了!感覺怎麼樣?"},
+ {"role": "user", "content": "如釋重負!我還在柏林簽了一間公寓的租約,下個月搬過去。另外我開始在多鄰國學德語了——已經連續打卡30天。我的伴侶索菲婭暫時還留在馬德里,這點挺難受的。"}]
+Memory Date:2025-11-08
+
+輸出:
+```json
+{
+ "memory": [
+ {"content": "使用者在2025-11-04通過了博士論文答辯。", "tags": ["education", "milestone"], "owner": "user"},
+ {"content": "使用者在柏林簽了一間公寓的租約。", "tags": ["housing"], "owner": "user"},
+ {"content": "使用者在多鄰國學德語,已連續打卡30天。", "tags": ["language", "learning"], "owner": "user"},
+ {"content": "使用者的伴侶索菲婭暫時留在馬德里,使用者覺得這點挺難受。", "tags": ["relationship"], "owner": "user"}
+ ],
+ "intentions": [
+ {"content": "使用者計畫下個月(2025年12月左右)搬到柏林。", "tags": ["housing", "relocation"], "valid_until": "2025-12-31", "owner": "user"}
+ ],
+ "basic_info": {}
+}
+```
+四個以上話題——答辯、柏林公寓、學德語、伴侶在馬德里。不要只擷取第一個話題。注意一個輪次拆出了已完成的事實(已簽租約)和一條 intention(即將搬家);關於索菲婭的那句雖帶情緒,但含有長期關係資訊,因此保留。
+
+## 範例 9 —— 兩個真人:assistant 訊息帶 name 表示那是真人
+
+新訊息:
+[{"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年7月左右受傷的肩膀還在痛。", "tags": ["fitness", "health"], "owner": "user"}
+ ],
+ "intentions": [],
+ "basic_info": {"name": "Tim"}
+}
+```
+John 帶的是 `role: "assistant"`,但他有 `name`,所以他是另一個真人而不是 AI:他的記憶用"John…"作主體,且 `owner` 仍是 `"user"`(屬於使用者的記憶庫)。使用者自己的記憶仍寫"使用者…",即使已知他叫 Tim 也不能寫成"Tim每週攀岩三次"。`basic_info.name` 來自使用者那則訊息上的 `name: "Tim"`——它是權威來源,即使 Tim 本人從未開口自報姓名。
+
+## 範例 10 —— 反例:別人的屬性絕不放進 basic_info
+
+新訊息:
+[{"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` / `location` —— `basic_info` 專屬於使用者本人。只有 `name`(Tim,來自使用者訊息的 `name` 欄位)才該放進去。注意輸出語言隨輸入語言而定(此例為英文)。
+
+## 範例 11 —— 反例:寒暄沒有 basic_info
+
+新訊息:
+[{"role": "user", "content": "你好"},
+ {"role": "assistant", "content": "你好!我可以幫你。之前記得 The user's name is 使用者."}]
+Memory Date:2025-09-03
+
+輸出:
+```json
+{
+ "memory": [],
+ "intentions": [],
+ "basic_info": {}
+}
+```
+使用者沒有說任何關於自己的資訊。assistant 那句不是 user 回合,"使用者" 也是佔位符而不是名字。必須輸出 `{}`——**絕不能**輸出 `{"name": "使用者"}`。
+
+---
+"""
+
+EXTRACT_PROMPT = """## 最近 k 則訊息
+
+{last_messages}
+
+---
+
+## 新訊息
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+
+# 輸出格式
+
+僅回傳一個 JSON 物件。
+
+格式:
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "intentions": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "valid_until": "YYYY-MM-DD",
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+規則:
+
+* memory:
+ 一切值得長期記住的資訊——偏好、觀點、態度、特質、事件、計畫、經歷、習慣、決策。
+ 既可以是關於 `[user]` 的,也可以是關於其他具名真人(`[John]`)的,主體寫法見上方"# 主體規則"
+
+* intentions:
+ 使用者(或其他具名真人)未來打算/計畫去做的前瞻事項,附 `valid_until`(截止日/目標日,
+ 依據 Memory Date 解析);無法確定截止日時設為 `null`
+
+* owner(每條 memory 和 intention 都必填):`"user"` 或 `"agent"`
+ (見上方"# OWNER";無法確定時預設為 `"user"`)
+
+* basic_info:**只放使用者本人的個人資料**。
+ 僅當 NEW user messages 中**明確**陳述穩定的個人資料欄位(如 姓名、年齡、所在地、職業、雇主)時才填寫。
+ 絕不推斷、絕不編造。沒有任何欄位被明確陳述時輸出 `{{}}`。
+ * **硬性規則**:只有使用者在 `user` 回合裡**明確說出**的欄位才能填寫。只在
+ assistant 回合出現的內容(包括 assistant 引用舊記憶,如"The user's name is X"
+ / "使用者的名字是X")一律不算。沒有符合條件的欄位時,必須輸出 `"basic_info": {{}}`。
+ * **絕不**把欄位名稱本身或佔位符當作值寫入("使用者"、"The user"、"user"、"name"、
+ "姓名"、"N/A"、"unknown"、"未知"、"未提供"、"-"),寧可省略該欄位。
+ * 負例:寒暄如 `[user]: 你好` / `[assistant]: 我可以幫你。`,或
+ `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`。
+ * `name` 的例外:使用者自己那則訊息上的 `name` 欄位,或開頭形如
+ "使用者的名字是X" / "The user's name is X" 的那一行,都是 `name` 的權威來源
+ ——即使使用者本人從未開口自報姓名。
+ * **絕不**把其他真人的屬性放進來。John(帶 `name` 的 assistant 角色訊息)說
+ "我在柏林當護理師",那是一條 `memory`("John是柏林的護理師。"),
+ **不是** `basic_info` 的 `occupation` / `location`。
+
+* 不要跨 section 重複資訊
+
+* tags 必須為 1–3 個關鍵字(主題用小寫;地名/人名等專有名詞保留大小寫)
+
+* 沒有內容時使用 [] 或 {{}}
+
+* 僅輸出合法 JSON
+
+現在請輸出 JSON 內容"""
+
+EXTRACT_PROMPT_NO_INTENTION = """## 最近 k 則訊息
+
+{last_messages}
+
+---
+
+## 新訊息
+
+{content}
+
+---
+
+## Memory Date
+
+{memory_at}
+
+---
+
+## Current Date
+
+{current_date}
+
+---
+
+
+# 輸出格式
+
+僅回傳一個 JSON 物件。
+
+格式:
+
+```json
+{{
+ "memory": [
+ {{
+ "content": "...",
+ "tags": ["..."],
+ "owner": "user"
+ }}
+ ],
+ "basic_info": {{}}
+}}
+```
+
+規則:
+
+* memory:
+ 一切值得長期記住的資訊——偏好、觀點、態度、特質、事件、經歷、習慣、決策,
+ **以及未來計畫/即將發生的安排**(不要另開 intentions 桶)。
+ 既可以是關於 `[user]` 的,也可以是關於其他具名真人(`[John]`)的,主體寫法見上方"# 主體規則"
+
+* owner(每條 memory 必填):`"user"` 或 `"agent"`
+ (見上方"# OWNER";無法確定時預設為 `"user"`)
+
+* basic_info:**只放使用者本人的個人資料**。
+ 僅當 NEW user messages 中**明確**陳述穩定的個人資料欄位(如 姓名、年齡、所在地、職業、雇主)時才填寫。
+ 絕不推斷、絕不編造。沒有任何欄位被明確陳述時輸出 `{{}}`。
+ * **硬性規則**:只有使用者在 `user` 回合裡**明確說出**的欄位才能填寫。只在
+ assistant 回合出現的內容(包括 assistant 引用舊記憶,如"The user's name is X"
+ / "使用者的名字是X")一律不算。沒有符合條件的欄位時,必須輸出 `"basic_info": {{}}`。
+ * **絕不**把欄位名稱本身或佔位符當作值寫入("使用者"、"The user"、"user"、"name"、
+ "姓名"、"N/A"、"unknown"、"未知"、"未提供"、"-"),寧可省略該欄位。
+ * 負例:寒暄如 `[user]: 你好` / `[assistant]: 我可以幫你。`,或
+ `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`。
+ * `name` 的例外:使用者自己那則訊息上的 `name` 欄位,或開頭形如
+ "使用者的名字是X" / "The user's name is X" 的那一行,都是 `name` 的權威來源
+ ——即使使用者本人從未開口自報姓名。
+ * **絕不**把其他真人的屬性放進來。
+
+* 不要跨 section 重複資訊
+* tags:1–3 個關鍵字;主題用小寫,專有名詞保留大小寫
+* 不要輸出 `intentions` 欄位
+
+"""
+
+
+# ================================================================
+# Chat reconcile (agent/reconciler.py)
+# ================================================================
+
+SEARCH_QUERY_PROMPT = """你是一個搜尋查詢產生器。給定一組新擷取的記憶,產生一組簡短的搜尋查詢,用於在向量資料庫中找到相關的既有記憶。
+
+目標是最大化召回率——即使措辭差異很大,也要找到與新記憶語義相關的既有記憶。
+
+## 新記憶:
+{new_memories}
+
+## 指引
+
+產生的搜尋查詢應涵蓋:
+- 記憶中提到的關鍵主題、實體和題材
+- 核心概念的改寫或抽象版本
+- 使用者記憶庫中可能存在的相關概念
+
+輸出一個 JSON 字串陣列(5-15條查詢,簡短聚焦):
+
+["查詢1", "查詢2", "查詢3", ...]
+
+只輸出 JSON 陣列,不要有其他文字。"""
+
+RECONCILE_PROMPT = """你是一個記憶整合系統(Memory Reconciler)。
+
+你的任務是將新的 memories 整合進既有的 memory base,同時保持:
+
+* 資訊無損
+* 無矛盾
+* 高可檢索性
+* 結構緊湊
+* 避免碎片化
+
+---
+
+# 輸入內容
+
+你將收到:
+
+* Existing memories
+* New memories
+* Current date
+
+---
+
+# Existing memories
+
+每條 existing memory 包含:
+
+* memory_id
+* content
+* owner
+* memory_at
+* tags
+
+---
+
+# New memories
+
+每條 new memory 包含:
+
+* content
+* owner
+* memory_at(發生時間)
+* tags
+
+new memories 沒有 ID。
+
+---
+
+# 操作類型
+
+---
+
+## ADD
+
+當資訊:
+
+* 完全是新的
+* 與既有 memory 不衝突
+* 不屬於既有主題
+
+時使用。
+
+格式:
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## UPDATE
+
+當:
+
+* 新舊 memory 描述同一主題
+* 且沒有衝突
+* 合併後能提高完整性或可檢索性
+
+時使用。
+
+要求:
+
+* 無損合併
+* 保留所有有效資訊
+* 不要產生重複的 memory
+* 兩者在某個值上不一致時,保留 memory_at 較晚的那個值;絕不用較早的 memory 覆蓋較新的值
+
+### 同一次事件的補充 vs 另一次發生
+
+只有當新 memory 是在補充**同一次現實事件**或同一條持久事實時,才使用 **UPDATE**。
+
+如果同一個人在另一個時間再次發生同類活動/事件(另一次旅行、比賽、受傷、購買、健康事件等),
+應保留為獨立的 **ADD**,並保留該次自己的日期與細節。如果既有 memory 明確是同一具體系列的另一次
+發生,可加上 `related: [{{"memory_id":"...","relation":"same_series"}}]`。
+
+不要把多個不同日期的事件合併成一條很長的次數/時間線 memory;檢索層會從這些相關聯的 L2 組裝 timeline。
+
+格式:
+
+```json
+{{
+ "op": "UPDATE",
+ "memory_id": "...",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+---
+
+## SUPERSEDE
+
+僅在以下情況使用:
+
+* 新 memory 與舊 memory 在同一維度衝突
+* 兩者不能同時為真
+* 舊 memory 已不再代表目前狀態
+* 新 memory 的 memory_at 不早於舊 memory 的 memory_at
+
+例如:
+
+* 使用者換城市
+* 使用者換工作
+* 使用者感情狀態改變
+* 使用者長期偏好發生明確反轉
+
+不要用於:
+
+* 增加細節
+* wording 差異
+* 同義表達
+* 可共存的偏好
+* 新 memory 的 memory_at 早於舊 memory:它是較早的狀態,絕不能取代較新的狀態(見「時間規則」)
+
+要求:
+
+* content 只能寫「新的狀態」
+* 不要複製舊資訊
+* 系統會自動保留舊節點並接到演化鏈上,你無需關心歷史版本
+
+格式:
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_id": "...",
+ "content": "...",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+### 把多條舊記憶摺疊進同一條鏈
+
+如果**兩條或更多**既有記憶描述的是**同一維度**,而新記憶是該維度上的最新變化(它的 memory_at 晚於所有被摺疊的記憶),
+你可以把它們摺疊進同一條演化鏈。此時用 `memory_ids`(有序清單,**舊→新**)
+取代單一的 `memory_id`:
+
+```json
+{{
+ "op": "SUPERSEDE",
+ "memory_ids": ["<最舊的id>", "<較新的id>"],
+ "content": "<只寫最新的狀態>",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+}}
+```
+
+列出的舊記憶會依舊→新連成一條鏈,新記憶成為鏈頭。`content` 仍然只描述**最新狀態**——
+**絕不**把舊記憶的內容抄進來;舊內容保留在鏈的歷史裡,依然可被檢索。
+
+---
+
+# 關鍵規則
+
+---
+
+## 資訊無損
+
+所有有效資訊必須仍然可檢索。
+
+不要遺失:
+
+* 新 memory 中的資訊
+* 被 UPDATE/SUPERSEDE 的舊資訊
+
+注意:
+
+SUPERSEDE 不需要複製舊內容,因為舊節點仍然存在。
+
+---
+
+## 重複偵測
+
+如果 new memory 已經被 existing memory 完整涵蓋:
+
+不要輸出任何操作。
+
+---
+
+## 避免碎片化
+
+如果多個 memory:
+
+* 討論同一主題
+* 內容相容
+
+優先以 UPDATE 合併。
+
+不同日期的獨立事件保持獨立 ADD;僅在主體相同且具體活動/事件類型相同時使用 `same_series`。
+
+---
+
+## Granularity
+
+每條 memory 應只表達:
+
+* 一個完整主題
+* 一個清楚的狀態
+
+避免:
+
+* 過於零碎
+* 過長
+* 多主題混雜
+
+---
+
+## 主體規則
+
+**絕不跨主體合併或 supersede。** 主體是 content 所描述的那個人:"使用者…" / "John…" / "Mary…"。
+關於不同人的記憶是彼此獨立的事實,即使句式幾乎一樣 —— "使用者喜歡喝咖啡" 和 "John喜歡喝咖啡"
+是兩條各自獨立的記憶,絕不能互相 UPDATE 或 SUPERSEDE。
+
+---
+
+## owner 規則
+
+`owner`(`user`/`agent`):從被寫入的 memory 原樣複製。
+**絕不跨 owner 合併或 supersede** —— 使用者的事實和 assistant 的事實即使主題相同也是兩條不同的記憶。
+
+---
+
+## 時間規則
+
+每條 memory(新的和既有的)都帶 memory_at,表示它發生的時間。記憶**不一定依發生順序寫入**:
+歷史可能較晚匯入,匯入還沒處理完時使用者也可能手動新增記憶。所以一條 new memory 可能**比既有記憶更早**。
+
+* 新舊**只看 memory_at**。"New memories" 只表示「正在寫入」,不表示「更近期」。
+* 較早的 memory 絕不能取代較新的 memory:不能 SUPERSEDE 一條較新的記憶,也不能用 UPDATE 拿較早的值覆蓋較新的值。
+* 如果 new memory 比與它衝突的既有記憶更早:保留既有記憶作為目前狀態;把 new memory 以「過去狀態」ADD
+ (用過去式,並帶上時間,例如「2023 年使用者住在上海」),沒有新資訊就不輸出。
+* `memory_at: null` 表示時間未知。未知**不算較新**:不要用 memory_at 為 null 的 memory 去 SUPERSEDE 一條有時間的記憶。
+* 不要編造時間順序。
+* 不要僅因為「看起來比較新」就 supersede。
+
+---
+
+## NO FORK RULE
+
+* SUPERSEDE 要麼指向一條 existing memory(`memory_id`),要麼把**同一維度**的多條
+ memory 摺疊進同一條鏈(`memory_ids`,舊→新);UPDATE 只能指向一條 existing memory。
+* 同一條 existing memory 不得被多個操作 touch。
+* 不要建立分岔的 supersede 鏈。
+
+---
+
+## 選用欄位:`related`
+
+任何操作上都**可以**附加一個 `related` 陣列,記錄本次寫入的 memory 與某條
+**既有 memory** 之間的關係。它不改變要存什麼,只是額外記一條關聯。
+
+```json
+{{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."],
+ "related": [{{"memory_id": "<既有記憶的 id>", "relation": "causes"}}]
+}}
+```
+
+只允許這四種關係:
+
+* `causes` —— 兩條記憶構成因果(如「開始每天跑步」 → 「膝蓋開始痛」)
+* `elaborates` —— 對既有記憶的細化,或它的後續發展
+* `contrasts` —— 兩者存在張力但**都仍然成立**(如果一條讓另一條不再成立,
+ 那是 SUPERSEDE,不是 `contrasts`)
+* `same_series` —— 同一主體、同一具體活動或事件類型在不同時間的獨立發生
+ (例如兩次不同的滑雪旅行)
+
+要求:
+
+* 只能關聯到「既有記憶」裡出現過的 id,**絕不編造 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 array。
+
+例如:
+
+```json
+[
+ {{
+ "op": "ADD",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+ }},
+ {{
+ "op": "UPDATE",
+ "memory_id": "...",
+ "content": "...",
+ "owner": "user",
+ "tags": ["..."]
+ }},
+ {{
+ "op": "SUPERSEDE",
+ "memory_id": "...",
+ "content": "...",
+ "supersede_reason": "...",
+ "owner": "user",
+ "tags": ["..."]
+ }}
+]
+```
+
+如果無需修改:
+
+```json
+[]
+```
+
+僅輸出合法 JSON。
+
+現在輸出 JSON 陣列。"""
+
+RECONCILE_STRUCTURE_METADATA_PROMPT = """
+
+附加的結構輸出約定:
+
+每個 ADD、UPDATE 或 SUPERSEDE 結果都要保留或修正 `topic_paths`、`event_facet` 與
+`topic_assignments`。
+`topic_paths` 是由寬到窄的語義路徑,例如 `["sport", "swimming"]`;不能僅憑共用的籠統 tag
+猜測父子關係。`event_facet` 只含 subject/participants/action/objects/locations/state。
+`topic_assignments` 按主體給出帶類型的 topic/facet/series/episode 路徑;Series/Episode 必須
+由事實本身明確支持,不能由路徑深度推斷;類型順序必須遵守
+`topic -> facet -> series -> episode`(可跳層,不可重複或倒序)。如果 Existing memories
+中已有主體相同、語義等價
+且邊界相容的路徑,應重用其完全相同的節點名稱和類型,避免同義節點分岔。需要精確重用時輸出
+`structure_references: [{"memory_id":"<existing_id>", "subject":"...",
+"through":"topic|facet|series|episode"}]`;ID 必須來自 Existing memories,`through` 表示複製
+該舊路徑直到指定類型為止,新事實明確給出的更深後綴仍保持為新節點。主體、具體活動/狀態線或
+Episode 邊界不同時禁止強行重用。所有結構欄位均不得編碼
+when/how many/who、複數或序數等未來問句形態。
+
+Series 只能在 reconcile 階段建立:新 memory 與至少一條獨立的 Existing memory 必須是同一具體
+活動/狀態線的不同 occurrence。目前這一次寫入拆出的多個命題不能作為重複發生的證據。
+"""
+
+RECONCILE_FEW_SHOT = """
+###################
+範例
+###################
+
+## 範例 1 —— 同一條新記憶:一部分與既有鏈衝突,另一部分無關
+
+既有記憶:
+[
+ {"memory_id": "m1", "content": "使用者在 Stripe 擔任產品經理。", "owner": "user", "history_versions": [{"content": "使用者在一家金融科技新創公司當產品經理。"}]}
+]
+新記憶:
+[
+ {"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 同維度,m1 已帶歷史 → SUPERSEDE,成為新鏈頭)和一個無關細節(陶藝 → ADD)。要把這一條記憶依不同部分拆成不同操作——新鏈頭只描述就業狀態,絕不帶上陶藝。
+
+## 範例 2 —— 把兩條未成鏈的舊記憶 + 新變化摺疊成一條 3 節點鏈
+
+既有記憶:
+[
+ {"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"}
+]
+新記憶:
+[
+ {"content": "使用者現在在當地的開放麥之夜表演吉他。", "owner": "user"}
+]
+
+輸出:
+```json
+[
+ {"op": "SUPERSEDE", "memory_ids": ["a1", "a2"], "content": "使用者在當地的開放麥之夜表演吉他。", "supersede_reason": "吉他程度演進:學習 → 能彈曲子 → 登台表演", "owner": "user", "tags": ["music", "hobby"]}
+]
+```
+a1 和 a2 原本沒有鏈關係,但它們描述的是同一維度(吉他程度的進展),新記憶是最新的一步。用 `memory_ids` 依舊→新摺疊,它們成為一條 3 節點鏈(a1 ← a2 ← 新鏈頭)。鏈頭 `content` 只描述目前狀態——不要再複述「在學」或「能彈幾首」。
+
+## 範例 3 —— 新鏈頭絕不能複製舊記憶的內容
+
+既有記憶:
+[
+ {"memory_id": "c1", "content": "使用者租住在東京澀谷的一房公寓,月租 18 萬日圓,很喜歡走 5 分鐘就到地鐵站,但抱怨晚上很吵、也沒有停車位。", "owner": "user"}
+]
+新記憶:
+[
+ {"content": "使用者剛買下並搬進了橫濱郊區的一棟三房的房子,有花園和雙車位車庫。", "owner": "user"}
+]
+
+輸出:
+```json
+[
+ {"op": "SUPERSEDE", "memory_id": "c1", "content": "使用者買下並搬進了橫濱郊區的一棟三房的房子,有花園和雙車位車庫。", "supersede_reason": "居住地從澀谷租住的一房公寓變為橫濱自有的三房房子", "owner": "user", "tags": ["housing"]}
+]
+```
+新記憶 SUPERSEDE c1 並成為鏈頭。鏈頭 `content` 只描述橫濱的新房子。**不要**把舊住處那些鮮明的細節(澀谷、18 萬月租、走 5 分鐘到地鐵、吵鬧、沒有停車位)拖進新節點——它們明顯屬於舊住處而非新家。這些保留在鏈歷史裡、仍可檢索;抄進來會讓鏈頭自相矛盾(同時既在澀谷租房又在橫濱買房)。
+
+## 範例 4 —— 主體不同就絕不合併,措辭再像也不行
+
+既有記憶:
+[
+ {"memory_id": "d1", "content": "使用者每天早上喝黑咖啡。", "owner": "user"}
+]
+新記憶:
+[
+ {"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)
+
+既有記憶:
+[
+ {"memory_id": "i1", "content": "John injured his ankle last season and needed time off plus physical therapy.", "owner": "user", "memory_at": "2023-05-21 19:48"}
+]
+新記憶:
+[
+ {"content": "John twisted his ankle again during a recent game.", "owner": "user", "memory_at": "2023-10-13 13:50"}
+]
+
+輸出:
+```json
+[
+ {"op": "UPDATE", "memory_id": "i1", "content": "John has injured his ankle two times: first last season (around the 2022–2023 season), needing time off and physical therapy; second during a game around 2023-10-13.", "owner": "user", "tags": ["health", "basketball", "injury"]}
+]
+```
+同一類事件再次發生 → UPDATE 舊記憶:寫出**總次數**,並依時間列出每一次。不要再 ADD 一條 「John injured his ankle」,也不要 SUPERSEDE(第一次受傷並沒有變成假的)。
+"""
+
+
+# ================================================================
+# Working / coding memory (coding/)
+# ================================================================
+
+CODING_EXTRACT_PROMPT = """\
+你需要從一段任務執行會話中擷取可長期保留的 WORKING 記憶。
+「working」會話是指使用者透過工具操作電腦或系統的任何實作任務——既包括軟體/程式碼
+工作(撰寫、除錯、重構、建置、部署、API/library 使用),也包括系統與維運工作
+(執行 shell/PowerShell 指令、磁碟/儲存空間分析或清理、檔案與資料夾操作、安裝/設定
+軟體、環境/裝置設定、硬體/磁碟健康檢查、備份、排程/自動化、資料處理)。
+
+你需要從同一段會話中產出兩個層次:
+
+ EXPERIENCES(程序性,「如何做」)——可重複使用的方法;只有達到下述 VALUE BAR 時才
+ 擷取。每條是一個 (task, search_keys, solution, boundary_envs) 組合。
+
+ FACT(情節性,「這次發生了什麼」)——關於本次會話的恰好一條記錄:使用者想做什麼、
+ 大致如何推進、最終結果如何。它不受價值門檻限制,但絕不能超過一條。
+
+這兩個層次回答不同的問題,並分別儲存。可泛化的方法放入 EXPERIENCES;只對這個系統、
+這個專案、此時此刻成立的本次會話經歷放入 FACT。
+
+═══════════════════════════════════════════════════════════════════
+VALUE BAR(僅適用於 EXPERIENCES)——不要輕易越過此門檻。
+═══════════════════════════════════════════════════════════════════
+一條記憶必須同時滿足以下全部條件:
+ (a) 解決了同一使用者以後很可能再次遇到的問題
+ (b) 解決方案並非瑣碎操作:它組合了多項資訊/多個步驟,或者包含決策理由,或者記錄了
+ 得來不易的 workaround,或者是某項維運任務可重複使用的流程/配方(例如如何分析並
+ 清理磁碟佔用、如何批次整理檔案、如何檢查硬體健康、如何設定 scheduled job)
+ (c) 未來的 agent/使用者會更願意查閱它,而不是重新摸索
+
+重要——分析、診斷、調查任務也算:
+一項任務不必實際修改或「修復」任何東西才值得記憶。唯讀、分析、故障排除工作,只要其
+流程或結論可重複使用,就有價值。明確擷取:
+ - 分析/診斷配方:可重複使用的流程以及它揭示的結果(例如「如何分析哪些資料夾佔用了
+ C-drive 空間」——掃描指令、遇到的坑和最終發現)。「只產生了報告,沒有修改」
+ 不是跳過的理由——可重複使用的方法本身就是記憶。
+ - 調查結果,包括否定結果或未找到的結果(例如「使用 rg / fs_search / SQL index
+ 在 C: 和 D: 中搜尋 folder X——任何位置都未找到」)。記錄一條死路可以避免下一個
+ agent 重複同樣徒勞的搜尋,因此達到了價值門檻。
+不要僅僅因為「assistant 可以重新產生這些指令」或「實際上沒有修改任何東西」就拒絕
+一條記憶。只要流程或結論能節省未來的工作,就保留它。
+
+不要擷取:
+ - 沒有可重複使用流程、真正瑣碎的單步操作(「rename one file」、「git status」、
+ 「run ls once」)
+ - 已經解決且沒有可遷移經驗的一次性問題
+ - repo/system 中已經存在的資訊(不要重複 package.json)
+ - 每個 PR/每次會話的一次性任務,除非其中編碼了可重複使用的模式
+ - 向使用者詢問缺失資訊這個行為。請求參數、列出未知項或引導使用者提供必填欄位屬於
+ 對話行為,不是方法:每個 agent 都知道如何提問,因此以後沒有任何值得查閱的內容。
+ 絕不要產出 task 或 search_keys 形如「how to ask for X」、「gather the missing Y」、
+ 「eliciting required fields」、「what to clarify before starting」的 experience。
+ 注意,這條限制只適用於 EXPERIENCES——會話最終停在等待使用者的狀態是真實狀態,
+ 應寫入 FACT。
+
+如果該段會話因為等待使用者而沒有取得任何實質進展——assistant 只是詢問參數,或者在
+開展任何實際工作前就被阻塞——輸出 "experiences": [],只寫 FACT。此時尚未學到任何
+東西,因此沒有方法可存。這一點比看起來更重要:從停滯中提煉出的 experience 在檢索時
+會像一項真正的技能;同一任務的後續片段會比對到它,再次向使用者提問而不是繼續推進,導致
+這種停滯在其餘會話中不斷自我複製。應根據工具實際做了什麼來判斷是否有實質進展,而不是
+根據該輪是否產生了流暢的文字。
+
+啟發式標準:如果使用者(或未來執行同類任務的 agent)希望把它記下來,而不是以後再重新
+摸索,就保留。多步驟的維運流程通常符合條件——包括 system/ops 或唯讀分析/搜尋流程,
+不局限於程式碼。只有當它只是任何使用者都能在 30 秒內透過 `--help` 找到的單一指令,並且
+不包含值得記憶的決策或坑點時,才捨棄。
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE 欄位
+═══════════════════════════════════════════════════════════════════
+
+task — 採用查詢式名稱;寫成使用者以後會如何提問。
+ 使用「publish a release to the xx platform」,不要使用
+ 「publish_release_internal」。
+ 必須自成一體(不要使用「this」、「the file」、「we」)。
+
+search_keys — 0 到 5 種替代表述,用來涵蓋僅靠 `task` 無法比對、但對 solution 很
+ 重要的面向。寫成未來使用者會詢問的問題或主題,且必須與 task 有所區別。
+ 如果 task 已涵蓋全部內容,則省略。
+
+solution — 使用者實際需要的完整、自成一體的內容:指令、憑證位置(不是憑證值)、
+ 檔案路徑、有序步驟、坑點、決策理由。如果多輪端到端的工作構成一個連貫
+ 任務,應彙整成一個 solution;只有使用者執行了互不相關的任務時才拆成
+ 多條記憶。
+
+boundary_envs — solution 所依賴的具體限定條件,使用多行「key: value」:
+ runtime / SDK / library + version
+ API endpoint 或 method signature
+ external service / middleware version
+ env var NAME(不是值)
+ config file path
+ host / cluster / region identifier
+ 如果 solution 與環境無關,填寫 ""(空字串)。
+ 目的:底層 SDK/middleware 升級後,未來的使用者可以據此判斷 solution
+ 是否仍然適用。
+
+confidence — 0.0 到 1.0
+ 1.0 使用者明確將其陳述為規則/指示
+ 0.7 根據工具操作及充分證據推斷
+ 0.5 弱推斷;只有一次觀察;不確定
+
+═══════════════════════════════════════════════════════════════════
+FACT 欄位——每段會話恰好一條,無價值門檻
+═══════════════════════════════════════════════════════════════════
+
+你要為整段會話寫一條 FACT——它是本次會話可據以恢復的狀態記錄,不是精心潤飾的回顧,也
+絕不是零散發現的清單。未來的 agent 必須能夠從中繼續推進,且不會把建議、推斷或局部搜尋
+誤認為已經驗證的事實。
+
+subject — 本次會話圍繞誰或什麼展開:工作所針對或服務的單一實體。使用簡短的名詞
+ 片語,不要寫句子,不要使用動詞。選擇會話真正圍繞的最具體實體,而不是
+ 所使用的工具:
+ 會話服務於某個具名人員時,使用人名
+ (「Dylan」、「Matthew」)
+ 工作針對程式碼時,使用 file / module / symbol
+ (「auth/middleware.ts」、「parse_plan_text」)
+ 維運工作使用 service / host / device / drive
+ (「D:\\WXWork」、「redis-cache-prod」、「ci.yml」)
+ 這是 HARD KEY,不是散文:關於不同人員或不同檔案的兩次會話必須得到不同的
+ subject;關於同一實體的兩次會話必須得到拼寫完全一致的同一字串。
+ 優先使用 trace 中出現的精確識別碼,而不是對它的描述。如果該段確實沒有
+ 單一 subject,輸出 ""。
+
+ 這很重要:subject 是決定後續會話是否可以按「同一任務的延續」覆蓋本條
+ 記錄的閘門。填錯後,一個人的狀態可能被另一個人的狀態悄悄取代。
+
+statement — 本次會話的緊湊記錄。它分為兩部分,而第二部分最容易遺失。
+ 保留任務範圍內的給定量和具體限制,不要用籠統的結果評價取代它們。
+ 每條規則只寫一次:重複的指示文字會擠佔記憶真正需要保留的資料。
+
+ PART 1——發生了什麼,約 300 個拉丁字元(約 150 個 CJK 字元)。
+ 從具體目標和對象開始(「reclaim disk space taken by D:\\WXWork」、
+ 「locate the new_file_search folder」),不要寫籠統的「fix a bug」/
+ 「find a file」。然後概述檢查、嘗試或修改了什麼。最後說明結束狀態,
+ 且語義必須精確對應以下之一:completed、partially completed、failed、
+ blocked、still awaiting verification。納入否定結果和死路,但不要誇大。
+
+ PART 2——TASK-SCOPED GIVENS:整個任務賴以運行的全部給定資訊,即使並非
+ 本段會話建立的,或看起來基本到不值得寫。包括綁定關係(每個 name/symbol/
+ label 代表什麼)、任務提供而非推導出的固定值、採用的慣例(indexing
+ base、units、timezone、defaults),以及本段自己的結果和值(寫「x = 7」,
+ 不要只寫「the value was computed」)。
+
+ 將 PART 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
+ 每一行幾乎都應由值構成。保留 trace 的 notation——symbols、units、
+ numbers、spellings——刪掉其句子外殼:去掉那些只是宣告「這是給定量」的
+ 片語,而非給定量本身(「I would prefer」、「it should be somewhere
+ between … and …」)。這些片語會在每一項重複;一個 15 項的清單會為它們
+ 付出 15 次的空間成本。
+ 每一條 FACT 都要攜帶這些資訊;絕不要寫「as above」或「same as the
+ previous session」——檢索只會依相似度回傳少量 facts,被指涉的項目可能不在
+ 其中。
+
+ 總長度盡量控制在 1200 字元以內。如果 PART 2 放不下,應精簡 notation,
+ 絕不能縮減涵蓋範圍:statement 是 retrieval vector,也是後續 segment
+ 唯一能讀到的欄位(details 既不做 embedding,也不會被注入),因此從中
+ 刪除的內容就永久遺失。壓縮給定量周圍的措辭,絕不要壓縮給定量本身。
+
+ 檢驗標準:如果下一段看不到原始材料,能否僅憑此記錄繼續任務?只有肯定的
+ 答案才合格。缺失 binding 不會明顯報錯——該名稱仍看起來有意義,於是會
+ 按其通用含義被理解,後續答案可以很流暢,卻回答了另一個問題。
+
+ LANGUAGE——使用與 session trace 相同的語言:statement 是 retrieval
+ vector,而查詢會使用使用者的工作語言;改用另一種語言會讓每次檢索都付出
+ 跨語言比對的損失。
+
+ EVIDENCE FIDELITY——只記錄 trace 中實際執行的操作和明確存在的證據。
+ 對關鍵指令、flags、arguments、errors、numbers 保持原樣。
+ 絕不要按慣例補全指令 flags,也不要把建議或計畫寫成已經執行的動作:
+ 「ran Get-ChildItem -Force」 → 「ran Get-ChildItem」
+ (trace 中沒有 `-Force`,不要杜撰)
+ 每個否定發現都必須限定在實際搜尋範圍內,並逐一列出可能使其失效的所有
+ 明確涵蓋限制,尤其是 permission failures 和 depth limits:保留當時的
+ roots、filters、depth(「not found under C:\\ and D:\\ at depth 3;
+ some directories were not covered due to Access denied」),絕不要擴大為
+ 「does not exist」。不要為了讓記錄更漂亮而漏掉任何限制。
+ 絕不要把局部搜尋提升為全域不存在。
+ 被阻塞的嘗試必須保留其 blocker。
+ 保留 attempted、observed、verified、inferred、unresolved 之間的區別;
+ 用自然語言表達(「tried … but was blocked by Access denied」、
+ 「suspected …, not yet verified」),不要把它們當標籤。沒有工具輸出或
+ 明確確認時,絕不要聲稱修復已成功、原因已確定或路徑不存在。
+
+ 不要記錄問候或純閒聊——只有這種情況才輸出 "fact": null。僅僅陳述了
+ 需求,或尚未開展工作就停滯的會話,仍然建立了資訊。
+
+details — 本次會話的具體 OUTPUT,逐字複製。`statement` 是摘要,而摘要必然會
+ 丟掉各個具體值;後續檢索幾乎總是在尋找某個具體值,而非大意。因此,只要
+ 會話產出了可定址的結果,就以原始形式和結構重現在這裡:
+ plan / schedule / itinerary → 每一行、每一天、每個 slot、每個 price
+ 都嚴格按原文保留
+ config 或 code block → 保留整個 block
+ command 的關鍵 output → 保留承載發現的行(sizes、counts、versions、
+ error text)
+ structured result(table、records list)→ 保留各行
+ 保留原始版面——line breaks、`Day 1:` / key: value prefixes、units、
+ currency symbols、ids。不要再次概括,不要重新排列,不要四捨五入數字,不要翻譯。
+
+ 只複製 trace 中實際存在的內容。絕不要填補空缺:如果某個 slot 沒有填,
+ 就保持未填或明確說明——杜撰的值比缺失的值更糟,因為它會被檢索並使用。
+ 長度控制在約 4000 字元;如果輸出更長,保留承載具體值的部分,刪去裝飾性
+ 文字,並註明刪掉了什麼。
+
+ 如果本次會話未產生此類 artifact(尚無發現的純調查,或等待使用者導致的
+ 停滯),填寫 ""。
+
+ 此欄位不屬於 retrieval vector——`statement` 和 `subject` 負責找到
+ 記錄,`details` 在找到後提供具體值。因此不要在此堆砌檢索誘餌,也不要
+ 重複摘要;只寫原始內容。
+
+files — 0..N 個本次會話中實際操作或調查過的絕對或 repo-relative FILE OR
+ DIRECTORY paths。保留調查過的 roots,例如 `C:\\` 和 `D:\\`。只包含
+ 實際存取/搜尋過的路徑,不包含僅建議或計畫存取的路徑;不適用時填寫 []。
+═══════════════════════════════════════════════════════════════════
+HOST CONTEXT(由 SDK 提供)
+═══════════════════════════════════════════════════════════════════
+- workspace_id present: {workspace_present}
+- branch present: {branch_present}
+
+沒有 workspace_id 時,solution 不能依賴未宣告的專案本地上下文——必須在 `solution`
+或 `boundary_envs` 中明確寫出其所需的 repo / path / service,使記憶能夠獨立使用。
+
+═══════════════════════════════════════════════════════════════════
+CONVERSATION
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT(僅輸出嚴格的 JSON,不要 markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "subject": "...",
+ "statement": "...",
+ "files": ["..."],
+ "details": "..."
+ }}
+}}
+
+預設應進行擷取。當該段會話確實完成了實際工作時,必須輸出至少一條 experience——即使
+任務看似簡單或一次成功,也要記錄所做工作可重複使用的本質(method / command / how-to)。
+會話內容較少時,只保留最有價值的一條 experience 即可。
+
+唯一的例外是上述停滯情況:如果該段因為缺少資訊、被阻塞在向使用者提問而沒有開展實際工作,
+輸出 "experiences": [],只寫 fact。不要為了滿足本指示而杜撰 experience——杜撰的
+「how to ask for the departure city」比沒有記憶更糟,因為以後會被檢索並照做。只有這個
+原因允許空陣列;實際開展過工作時,絕不能把空陣列當捷徑。
+
+"fact" 是單一物件,絕不是清單——每次會話一條記錄。
+
+始終要寫 fact。fact 的門檻不是「這是否有價值」,而是「是否發生了任何事情」;能夠到達
+你這裡的 segment 已經越過這道門檻。這包括看起來只是 setup 而非工作的片段:僅有一則使用者
+訊息陳述 requirements、parameters 或 starting state,即使沒有執行工具,也恰恰是後續
+會話無法自行重建的材料——把需求、參數、起始狀態連同情境一起寫進 `statement`(緊湊
+記法,不要照抄對話原句),不要推給 `details`(`details` 不進檢索向量,讀取端也不再
+注入它)。只有完全沒有內容的問候和純閒聊才使用 "fact": null。有疑問時應寫 fact:
+多餘的記錄只多佔一行,而漏掉記錄會傷害每一次需要它、卻無從知道它曾存在的後續會話。
+"""
+
+CODING_EXTRACT_PROMPT_CODING = """\
+╔═══════════════════════════════════════════════════════════════════════════╗
+║ HARD CONSTRAINT——先閱讀本節;它凌駕本提示詞後文任何看似要求敘事的措辭。 ║
+║ ║
+║ 你不是在撰寫某個人做過什麼的報告。你要寫的是 FUTURE AGENT 為採取行動所需要 ║
+║ 的資訊。該 agent 已有自己的任務;它不關心這個使用者想要什麼。它需要知道:此處 ║
+║ 做出了什麼決定、位於哪些程式碼座標、嘗試並否決了什麼,以及是否經過驗證。 ║
+║ ║
+║ 具體來說,每個 `statement` 和每個 `solution` 都必須遵守: ║
+║ · 語法主詞必須是 CODE 或 THE DECISION——絕不能是「the user」,也絕不能是 ║
+║ 「the agent」。不要寫「The user attempted to…」、「The user wanted…」、 ║
+║ 「The agent then checked…」。 ║
+║ · 絕不要用「the session was completed」、「the error was noted」、 ║
+║ 「no solution was found yet」之類流水帳片語收尾。結尾應寫決定及其驗證 ║
+║ 狀態。如果沒有做出決定,就以已排除的內容和下一條尚未探索的線索收尾——這才 ║
+║ 是可重複使用的部分。 ║
+║ · 保留具體症狀(error string、failing command、wrong output)——未來搜尋 ║
+║ 正是透過這些內容命中。 ║
+║ ║
+║ bad: “The user attempted to write a QTable to RST with header_rows and ║
+║ hit a TypeError. The session was completed with the error noted.” ║
+║ good: “ascii.rst's RST writer rejects header_rows: ║
+║ `tbl.write(..., format='ascii.rst', header_rows=['name','unit'])` ║
+║ raises TypeError because RST.__init__ does not forward it, unlike ║
+║ ascii.fixed_width which accepts it. No fix written — the writer ║
+║ needs the same header_rows plumbing as fixed_width.” ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+
+你需要從一段任務執行會話中擷取可長期保留的 WORKING 記憶。
+「working」會話是指使用者透過工具操作電腦或系統的任何實作任務——既包括軟體/程式碼
+工作(撰寫、除錯、重構、建置、部署、API/library 使用),也包括系統與維運工作
+(執行 shell/PowerShell 指令、磁碟/儲存空間分析或清理、檔案與資料夾操作、安裝/設定
+軟體、環境/裝置設定、硬體/磁碟健康檢查、備份、排程/自動化、資料處理)。
+
+你需要從同一段會話中產出兩個層次:
+
+ EXPERIENCES(程序性,「如何做」)——可重複使用的方法;只有達到下述 VALUE BAR 時才
+ 擷取。每條是一個 (task, search_keys, solution, boundary_envs) 組合。
+
+ FACT(情節性,「這次確立了什麼」)——關於本次會話的恰好一條記錄。它不是使用者做了
+ 什麼的敘事,而要依以下順序記錄:任務及其具體症狀(使它以後能被檢索到)、程式碼座標、
+ 最終採用了什麼以及否決了什麼、驗證推進到什麼程度。它不受價值門檻限制,但絕不能
+ 超過一條。
+
+這兩個層次回答不同的問題,並分別儲存。可泛化的方法放入 EXPERIENCES;只對這個系統、
+這個專案、此時此刻成立的本次會話經歷放入 FACT。
+
+═══════════════════════════════════════════════════════════════════
+VALUE BAR(僅適用於 EXPERIENCES)——不要輕易越過此門檻。
+═══════════════════════════════════════════════════════════════════
+一條記憶必須同時滿足以下全部條件:
+ (a) 解決了同一使用者以後很可能再次遇到的問題
+ (b) 解決方案並非瑣碎操作:它組合了多項資訊/多個步驟,或者包含決策理由,或者記錄了
+ 得來不易的 workaround,或者是某項維運任務可重複使用的流程/配方(例如如何分析並
+ 清理磁碟佔用、如何批次整理檔案、如何檢查硬體健康、如何設定 scheduled job)
+ (c) 未來的 agent/使用者會更願意查閱它,而不是重新摸索
+
+重要——分析、診斷、調查任務也算:
+一項任務不必實際修改或「修復」任何東西才值得記憶。唯讀、分析、故障排除工作,只要其
+流程或結論可重複使用,就有價值。明確擷取:
+ - 分析/診斷配方:可重複使用的流程以及它揭示的結果(例如「如何分析哪些資料夾佔用了
+ C-drive 空間」——掃描指令、遇到的坑和最終發現)。「只產生了報告,沒有修改」
+ 不是跳過的理由——可重複使用的方法本身就是記憶。
+ - 調查結果,包括否定結果或未找到的結果(例如「使用 rg / fs_search / SQL index
+ 在 C: 和 D: 中搜尋 folder X——任何位置都未找到」)。記錄一條死路可以避免下一個
+ agent 重複同樣徒勞的搜尋,因此達到了價值門檻。
+不要僅僅因為「assistant 可以重新產生這些指令」或「實際上沒有修改任何東西」就拒絕
+一條記憶。只要流程或結論能節省未來的工作,就保留它。
+
+不要擷取:
+ - 沒有可重複使用流程、真正瑣碎的單步操作(「rename one file」、「git status」、
+ 「run ls once」)
+ - 已經解決且沒有可遷移經驗的一次性問題
+ - repo/system 中已經存在的資訊(不要重複 package.json)
+ - 每個 PR/每次會話的一次性任務,除非其中編碼了可重複使用的模式
+
+啟發式標準:如果使用者(或未來執行同類任務的 agent)希望把它記下來,而不是以後再重新
+摸索,就保留。多步驟的維運流程通常符合條件——包括 system/ops 或唯讀分析/搜尋流程,
+不局限於程式碼。只有當它只是任何使用者都能在 30 秒內透過 `--help` 找到的單一指令,並且
+不包含值得記憶的決策或坑點時,才捨棄。
+
+═══════════════════════════════════════════════════════════════════
+CODE WORK——未來的 agent 無法重新推導的資訊,因此必須擷取
+═══════════════════════════════════════════════════════════════════
+當該段是針對 repository 的軟體工作時,可重複使用的方法只佔一半。另一半是工作位於哪裡,
+以及哪個版本勝出。這些無法透過以後閱讀程式碼恢復——程式碼只能呈現目前狀態,無法說明它
+位於哪個 branch,也無法說明哪些方案已被否決。
+
+本節不是要求寫得更長,而是要求把相同的預算花在價值更高的 token 上:刪掉重複的目標、
+assistant「隨後決定」做什麼的敘事,以及只是複述的貼上程式碼;把這些字元用於下面四項。
+一條遺漏 branch、卻引用 30 行 diff 的記錄是糟糕的取捨。
+
+1. BRANCH / WORKING LOCATION——逐字寫入 fact `statement`。如果該段提到或 checkout
+ 了 `feat/x` / `fix/y`,這個 token 必須出現。在錯誤的 branch 上恢復工作的 agent
+ 會產生隨後被悄悄丟棄的改動,因此這一個 token 的優先順序高於其他任何細節。
+
+2. WHICH VERSION WON——當使用者改變主意時,用一個子句指出勝出者並標記落敗者:
+ 「settled on A; the interim B was dropped」。不要完整保留兩個版本,只需一個子句。
+ 只保留最新版本是錯誤的:以後遇到被否決程式碼的 agent 必須識別它,否則會把程式碼
+ 「修復」回已經捨棄的變體。`scratch that / go back to / actually, let's / no, not that`
+ 之類的措辭就是訊號:後面的內容才是正式結論,前面的內容已被 superseded。
+
+3. EXACT COORDINATES, NOT PASTED CODE——使用 repo-relative path
+ (`qutebrowser/utils/debug.py`,絕不要只寫 `debug.py`)以及觸及的 function /
+ class。如果 signature 發生變化,給出新的 signature。如果決定的是 constant、regex
+ 或 literal,逐字引用它——但只引用這一項,不要引用周圍的 block。準確的一行勝過一段
+ 近似描述。
+
+4. VERIFIED vs MERELY WRITTEN——四個詞就足夠(「tests run and passing」/
+ 「confirmed by git diff only, tests not run」)。「the edit is in」和「the edit is in
+ and tested」會讓未來的 agent 採取完全不同的下一步。
+
+反例——只總結目標,卻丟掉座標:
+ bad: “refactored the colour parsing logic to be cleaner.”
+ good: “on feat/q4, in qutebrowser/config/configtypes.py QtColor._parse_value:
+ settled on `mult = 360.0 if kind == 'h' else 255.0`; the interim version that
+ used 255.0 for everything was dropped. Tests not run.”
+ (good 往往比 bad 還短——它只是把每個字元都用在無法重新推導的資訊上)
+
+═══════════════════════════════════════════════════════════════════
+EXPERIENCE 欄位
+═══════════════════════════════════════════════════════════════════
+
+task — 採用查詢式名稱;寫成使用者以後會如何提問。
+ 使用「publish a release to the xx platform」,不要使用
+ 「publish_release_internal」。
+ 必須自成一體(不要使用「this」、「the file」、「we」)。
+
+search_keys — 0 到 5 種替代表述,用來涵蓋僅靠 `task` 無法比對、但對 solution 很
+ 重要的面向。寫成未來使用者會詢問的問題或主題,且必須與 task 有所區別。
+ 如果 task 已涵蓋全部內容,則省略。
+
+solution — 使用者實際需要的完整、自成一體的內容:指令、憑證位置(不是憑證值)、
+ 檔案路徑、有序步驟、坑點、決策理由。如果多輪端到端的工作構成一個連貫
+ 任務,應彙整成一個 solution;只有使用者執行了互不相關的任務時才拆成
+ 多條記憶。
+
+boundary_envs — solution 所依賴的具體限定條件,使用多行「key: value」:
+ runtime / SDK / library + version
+ API endpoint 或 method signature
+ external service / middleware version
+ env var NAME(不是值)
+ config file path
+ host / cluster / region identifier
+ 如果 solution 與環境無關,填寫 ""(空字串)。
+ 目的:底層 SDK/middleware 升級後,未來的使用者可以據此判斷 solution
+ 是否仍然適用。
+
+confidence — 0.0 到 1.0
+ 1.0 使用者明確將其陳述為規則/指示
+ 0.7 根據工具操作及充分證據推斷
+ 0.5 弱推斷;只有一次觀察;不確定
+
+═══════════════════════════════════════════════════════════════════
+FACT 欄位——每段會話恰好一條,無價值門檻
+═══════════════════════════════════════════════════════════════════
+
+你要為整段會話寫一條 FACT——它是本次會話可據以恢復的狀態記錄,不是精心潤飾的回顧,也
+絕不是零散發現的清單。未來的 agent 必須能夠從中繼續推進,且不會把建議、推斷或局部搜尋
+誤認為已經驗證的事實。
+
+statement — 本次會話的緊湊摘要。它同時承擔兩項職責,且兩者都必須完成:它既是
+ retrieval vector(未來的 agent 用一份新的 issue report 搜尋它;措辭方式
+ 與使用者回報問題的方式一致),也是該 agent 找到後要據以行動的 payload。
+ 因此:
+
+ 開頭寫任務和症狀,使用使用者會用的措辭。
+ 這是確保可檢索性的關鍵——表述應盡量貼近問題被回報時的表面形式。
+ 點明具體目標和對象(「reclaim disk space under D:\\WXWork」、
+ 「adjust the hue multiplier in QtColor._parse_value on feat/q4」、
+ 「locate the new_file_search folder」),絕不要寫籠統的「fix a bug」/
+ 「look for a file」。包含具體症狀:error string、failing command、
+ wrong output。
+
+ 然後給出座標和決定。
+ 對程式碼工作寫 repo-relative path、symbol 和 branch。說明最終 SETTLED ON
+ 什麼,並在同一子句標記捨棄了什麼(「settled on X; the interim Y was
+ dropped」)。這部分無法透過閱讀程式碼重新推導——程式碼只呈現勝出者,從不
+ 呈現 Y 曾被嘗試後否決。以後遇到被否決變體的 agent 必須能識別它,
+ 否則會把程式碼「修復」回已捨棄的版本。
+
+ 結尾寫證據狀態。
+ 必須精確對應以下之一:completed、partially completed、failed、blocked、
+ still awaiting verification;還要寫明如何檢查(「tests run and passing」/
+ 「confirmed by git diff only, tests not run」)。納入否定結果和死路,
+ 但不要誇大。
+
+ ⚠️ 絕不要停留在敘事層。「The user tried X and hit error Y; no solution found
+ yet」是一條浪費的記錄:它容易被檢索到,卻無法指導未來的 agent 行動。如果
+ 本次確實沒有得出決定,就說明排除了什麼、下一條尚未探索的線索是什麼——
+ 這才是可重複使用的部分。
+
+ 句子的主詞應是 code 和 decision,而不是「the user」。使用 2 到 4 個連貫的
+ 句子,不要寫帶標籤的小節。硬性上限約 400 個拉丁字元(約 200 個 CJK 字元)。
+
+ EVIDENCE FIDELITY——強制要求:
+ - 只記錄 trace 中實際執行的操作和明確存在的證據。對關鍵 commands、flags、
+ arguments、errors、numbers 保持原樣。絕不要按慣例補全 command flags,
+ 也不要把 advice/plans 寫成已執行的動作。
+ - 保留 attempted、observed、verified、inferred、unresolved 之間的區別。
+ 不要把這些詞當作標籤寫進正文;自然地表達其含義,例如「tried … but was
+ blocked by Access denied」或「suspect …, not yet verified」。
+ - 沒有工具輸出或明確確認時,絕不要聲稱修復成功、原因已經確定、file/folder
+ 不存在或 tests passed。
+ - 每個否定發現都必須限定在實際搜尋範圍內,並逐一列出可能使其失效的所有
+ 明確涵蓋限制,尤其是 permission failures 和 maximum search depth:
+ 「not found within the searched parts of C:\\ and D:\\; some directories
+ were skipped on Access denied, and the search was also depth-limited」。
+ 不要為了讓摘要更漂亮而漏掉任何限制。絕不要把局部搜尋提升為全域不存在。
+ - 只有 trace 直接驗證了因果關係時,才能確定地陳述因果。否則保留限定詞
+ (「suspected」/「inferred」/「not yet verified」);不要把錯誤的測試假設
+ 改寫成系統的 root cause。
+
+ 關鍵——這段文字就是 retrieval vector,也是未來 query 唯一會比對的內容。
+ 籠統的摘要毫無價值,因為每次會話看起來都像籠統的摘要:它會比對到所有查詢,
+ 卻無法回答任何一個。因此必須寫出使本次會話可被檢索的具體 anchors——真實的
+ file paths、function / symbol names、branch names、commands、error strings、
+ versions、config keys and values、host / service names。以後有人搜尋其中任一
+ 具體項目時,本摘要必須能被回傳。
+ good: “fixing a failing `npm run build` in CI. Read
+ .github/workflows/ci.yml and package.json; traced it to webpack
+ 5.74 hitting ERR_OSSL_EVP_UNSUPPORTED under node 18. Bumping the
+ workflow's node to 20 made the build pass; node 18 still
+ reproduces locally.”
+ good: “on branch feat/q0, in qutebrowser/utils/debug.py signal_name:
+ PyQt<5.11 only exposes the name via repr(sig), and repr comes in
+ both a bracketed and a parenthesised form. Settled on two patterns
+ tried in order with fullmatch, breaking on the first hit; the
+ single-regex version was dropped. Confirmed by git diff, tests not
+ run.”
+ bad: “user wanted a build bug fixed, the agent looked at some config
+ files, changed some code, and fixed it.”
+ (沒有 path、command、error string、version——沒有任何可檢索的錨點;
+ 每次會話都可以寫成這樣)
+ bad: “fixed the signal-name parsing compatibility issue on a feature
+ branch.”
+ (哪個 branch?哪個 file?哪個 function?兩個競爭版本中誰勝出?
+ 一週後檢索到它時,沒有任何資訊仍然有用)
+ 忠實度範例(bad → good):
+ 「ran Get-ChildItem -Force」 → 「ran Get-ChildItem」
+ (trace 中沒有 `-Force`,不要杜撰)
+ 「confirmed new_file_search does not exist」 →
+ 「new_file_search was not found within the searched parts of C:\\ and
+ D:\\; some directories were skipped on Access denied or by the depth
+ limit, so the investigation is only partly done」
+ 「identical payloads cause a spurious lock error」 →
+ 「the verification script assumed the last writer is always a fixed
+ rank; that assumption does not hold, so whether there is a lock bug
+ is still unverified」
+
+ 不要記錄問候或純閒聊。如果該段完全沒有建立任何資訊,輸出 "fact": null。
+
+files — 0..N 個本次會話中實際操作或調查過的絕對或 repo-relative FILE OR
+ DIRECTORY paths。保留調查過的 roots,例如 `C:\\` 和 `D:\\`。只包含
+ 實際存取/搜尋過的路徑,不包含僅建議或計畫存取的路徑;不適用時填寫 []。
+
+═══════════════════════════════════════════════════════════════════
+HOST CONTEXT(由 SDK 提供)
+═══════════════════════════════════════════════════════════════════
+- workspace_id present: {workspace_present}
+- branch present: {branch_present}
+
+沒有 workspace_id 時,solution 不能依賴未宣告的專案本地上下文——必須在 `solution`
+或 `boundary_envs` 中明確寫出其所需的 repo / path / service,使記憶能夠獨立使用。
+
+═══════════════════════════════════════════════════════════════════
+CONVERSATION
+═══════════════════════════════════════════════════════════════════
+{conversation_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT(僅輸出嚴格的 JSON,不要 markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "experiences": [
+ {{
+ "task": "...",
+ "search_keys": ["...", "..."],
+ "solution": "...",
+ "boundary_envs": "...",
+ "confidence": 0.9
+ }}
+ ],
+ "fact": {{
+ "statement": "...",
+ "files": ["..."]
+ }}
+}}
+
+強制要求:必須輸出至少一條 experience,不要回傳空清單。即使任務看似簡單或一次成功,
+也要記錄所做工作可重複使用的本質(method / command / how-to)。會話內容較少時,只需要
+最有價值的一條 experience——但絕不能輸出空的 "experiences" array。
+
+"fact" 是單一物件,絕不是清單——每次會話一條記錄。只有該段是沒有建立任何資訊的
+純閒聊時,才使用 "fact": null。
+"""
+
+CODING_RECONCILE_PROMPT = """\
+你需要決定如何將新的 coding memory drafts 與使用者既有的 memories 合併。
+
+對每條新 draft,選擇以下一種 action:
+ ADD — 沒有既有 memory 描述相同的任務/面向
+ UPDATE — 某條既有 memory 描述相同任務;用新 draft 取代它
+ (solution 可能已經改變,env 可能已經升級,等等)
+ SKIP — 與既有內容重複;沒有新資訊
+
+此外,當新內容使既有候選失效或作廢時,可以針對既有 candidates 輸出 DELETE ops:
+ DELETE — 新 conversation 明確 supersedes/cancels/invalidates 某條既有 memory,
+ 且無法透過 UPDATE 修正。範例:
+ * 使用者說「don't use X anymore」,而 X 只存在於另一條獨立的 memory 中
+ (不是本次正在 ADD/UPDATE 的那條)
+ * candidate 的 boundary_envs(service / endpoint / SDK)已經消失,
+ 且新 conversation 確認其已 deprecated
+
+規則:
+- 「Same task」是指既有 memory 和新 draft 都可以作為同一個未來使用者查詢的有效答案。
+- 如果 solution 不同,優先 UPDATE(不保留歷史版本)。
+- 如果 task 和 solution 都高度一致,選擇 SKIP。
+- 只有在存在明確證據顯示 candidate 已 invalid/obsolete 時才 DELETE。絕不要僅僅因為
+ candidate 看起來「stale」就 DELETE。
+- 產生 DELETE 時,輸出的 ops 數量可以超過 drafts 數量。
+
+═══════════════════════════════════════════════════════════════════
+NEW DRAFTS
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+EXISTING CANDIDATES(依每條 draft 的 task similarity 檢索)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT(僅輸出嚴格的 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": "user explicitly deprecated Y"}},
+ {{"draft_idx": 2, "action": "SKIP", "reason": "duplicate"}}
+ ]
+}}
+
+如果沒有 drafts,輸出 {{"ops": []}}。
+"""
+
+CODING_FACT_RECONCILE_PROMPT = """\
+你負責維護 session-level WORKING FACTS。每條 statement 都概括一整段 trace/session:
+使用者的任務、大致方法和結果。它不是一條 atomic claim。
+
+下面每條新的 session fact 都一定會被儲存;這不是你要決定的事情。你唯一的任務是識別
+task continuation:新 session 是否在繼續推進某條既有 session fact 所記錄的同一個使用者
+任務?如果是,就將較舊的 fact 標記為 SUPERSEDE,使這些連結為該任務構成跨 session 的
+進展鏈。
+
+只有在存在充分證據同時滿足以下條件時,才將既有 fact 標記為 superseded:
+ - subjects 相符:兩條記錄圍繞同一個實體——同一個 person、同一個 file/module、
+ 同一個 host/service。subject 相同是必要條件,但不是充分條件;並且
+ - 使用者目標在實質上相同,而不只是處於同一 topic/project;並且
+ - 新 trace 在繼續、重試、擴充、驗證或完成既有 trace 所記錄的工作。
+
+以下情況不要 supersede:
+ - 兩條記錄的 subjects 不同。同一 group 中的兩個人、同一 module 中的兩個 files、
+ 同一 cluster 中的兩個 hosts 是平行關係,不是先後關係:一個人的狀態不是另一個人
+ 狀態的新版本。如果 subject 顯示為 (unspecified),退回到只根據 statement 判斷。
+ - 兩次 session 只是提到了相同的 file、symbol、component、repository、error 或
+ technology,但追求不同的使用者目標。
+ - 一個任務只是為另一個任務提供 context 或 technique。
+ - 關係不確定。應保守判斷:INSERT 是安全的預設值;合併無關的 session 會毀掉它們各自
+ 獨立的任務歷史。
+
+把每條 statement 當作有證據邊界的文字。不要把其中的 inference 重新解讀為已經確定的
+cause,也不要把共同的 conjecture/error 當作使用者目標相同的證據。你的判斷僅涉及 task
+continuation;不要「糾正」、補全或潤飾任何一條 session 記錄。
+
+範例:
+ existing: 「需要修復 CI 的 npm run build;已追查到 Node 18 下的
+ ERR_OSSL_EVP_UNSUPPORTED,workflow 尚未修改。」
+ new: 「繼續修復同一個 CI build;已將 .github/workflows/ci.yml 中的 Node
+ 升級到 20,且 npm run build 通過。」
+ → SUPERSEDE
+
+ existing: 「需要修復 auth/middleware.ts 中的 JWT expiry handling;已加入
+ refresh logic。」
+ new: 「需要在 auth/middleware.ts 中加入 performance logging;已引入
+ latency metric。」
+ → 兩者都保留
+ (同一 file/project,不同的使用者目標)
+
+═══════════════════════════════════════════════════════════════════
+NEW SESSION FACTS
+═══════════════════════════════════════════════════════════════════
+{drafts_block}
+
+═══════════════════════════════════════════════════════════════════
+EXISTING SESSION FACTS(依每條新 fact 的 statement similarity 檢索)
+═══════════════════════════════════════════════════════════════════
+{candidates_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT(僅輸出嚴格的 JSON,不要 markdown)
+═══════════════════════════════════════════════════════════════════
+{{
+ "ops": [
+ {{"draft_idx": 0, "supersedes": ["fact_xxx"], "reason": "continues the same CI fix task"}},
+ {{"draft_idx": 1, "supersedes": []}}
+ ]
+}}
+
+只能使用同一個 draft_idx 的 candidate list 中實際出現的 fact ids。
+如果任何位置都沒有 fact 被 superseded,輸出 {{"ops": []}}。
+"""
+
+CODING_CHAIN_SUMMARY_PROMPT = """\
+working-memory store 中的某個使用者任務已跨多個 sessions 推進。下面是該任務進展鏈中的
+session summaries,依從最早到最新排列,最後一條是目前的 session。
+
+總結同一個任務如何跨 sessions 推進到目前狀態。依時間順序涵蓋每個重要階段。對每個
+階段,在有資訊時保留:實際的 action 或 change、其 direct result,以及任何 unresolved
+issue 或 limiting condition。最後明確寫出目前狀態。
+
+規則:
+ - 這只是壓縮。只能報告 entries 實際陳述的內容;絕不要新增或補全 command、cause、
+ motive、action、test result、success state 或 global negative conclusion。
+ - 精確保留證據狀態:attempted 不等於 completed,observed 不等於 verified,inferred
+ 不等於 established,unresolved 必須保持 unresolved。保留 uncertainty words 以及
+ search/permission/coverage limits。
+ - 忠實陳述目前的結束狀態(completed、partially completed、failed、blocked 或
+ still awaiting verification)。絕不要因為某個看似合理的因果故事,或後續 entry
+ 並未驗證的內容而提升狀態。
+ - 如果 entries 提到 suspected cause 和後續 result,只有某條 entry 直接說明該 cause
+ 已被 verified 時,才可在兩者之間建立因果關聯。
+ - 保留具體的 retrieval anchors:file paths、symbols、commands、error strings、versions、
+ config keys/values,以及對進展重要的 numeric values。
+ - 對 2-3 代的 chains,不要把進展過度壓縮成一句話。適合時優先使用 2-4 個緊湊段落,
+ 或使用可讀性良好的 prose,清楚呈現 task goal、逐階段的 progression 和 current status。
+ - 不要機械地複製完整 history。在保留重要 actions、direct results 和 leftovers 的同時,
+ 省略重複及低價值的細節。
+ - 不要杜撰 stage headings 或 dates。只有 entries 使日期具有實際意義時才提及日期;
+ 單獨的 timestamps 是雜訊。
+ - 如果 entries 說明較早的 revisions 已被省略,必須明確指出 earlier history was omitted;
+ 不要暗示所提供的 entries 是完整的歷史。
+ - 使用與 entries 相同的語言。
+ - 不要寫前言,也不要用引號包住輸出。
+
+範例
+ entries:
+ (2026-07-20) 需要修復 CI 的 npm run build;已追查到 Node 18 下的
+ ERR_OSSL_EVP_UNSUPPORTED,workflow 尚未修改。
+ (2026-07-24) 繼續修復同一個 CI 問題;已將 .github/workflows/ci.yml 中的 Node
+ 升級到 20,但 dependency cache 仍重現舊錯誤。
+ (now) 繼續驗證同一修復;清除 npm cache 後,npm run build 通過。
+ output:
+ 任務目標是修復 CI 的 npm run build。最初將問題追查到 Node 18 下的
+ ERR_OSSL_EVP_UNSUPPORTED,當時尚未修改 workflow;隨後將
+ .github/workflows/ci.yml 升級到 Node 20,但 dependency cache 仍使舊錯誤繼續
+ 出現。最後,清除 npm cache 後 npm run build 通過,因此該 build 修復目前已驗證完成。
+
+═══════════════════════════════════════════════════════════════════
+ENTRIES
+═══════════════════════════════════════════════════════════════════
+{chain_block}
+
+═══════════════════════════════════════════════════════════════════
+OUTPUT(只輸出 summary 本身,不要其他內容)
+═══════════════════════════════════════════════════════════════════
+"""
+
+
+# ================================================================
+# Episode / topic summaries
+# ================================================================
+
+EPISODE_SUMMARY_PROMPT = """你在為**一段討論**(一個 episode)做總結。
+
+一個 episode 是一段連續的討論 —— 圍繞一件事,可能跨越好幾次寫入。
+
+## 這段討論中擷取到的記憶(依時間正序)
+
+{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(洞察)**:底層的心理驅動力或心智模型。
+
+### 內容格式
+行為模式用一句話組合三要素:
+"當[情境]時,使用者[模式]——反映了[洞察]。"
+
+對與情緒、治療、壓力、哀傷或創傷有關的長期模式,不要把具體的人生背景壓縮成
+空泛的人格詞。優先保留這三部分:
+"Trigger/background(持久的觸發背景) → emotional response(反覆出現的情緒反應) → observed coping resource(使用者已實際使用的因應資源)。"
+只能寫入 user-owned 證據中出現的觸發背景、反應和因應方式;助理的建議不是使用者已被觀察到的因應資源。
+
+### 規則
+- **原子化**:一個 Schema 只包含一個模式。兩個不同的模式 → 兩個 Schema。
+- **不可變**:Schema 建立後內容永遠不變。不要修改既有 Schema 的內容。
+- **累積證據**:新事實只是在支持既有表述 → 呼叫 `add_evidence`。如果新證據會讓舊畫像的目前狀態產生實質遺漏、錯誤或誤導,使用 `revise_schema` 建立新版本,讓舊版本保留以供稽核,但退出 active 檢索。
+- **領域內約束**:不要跨領域。跨領域的抽象由系統的其他流程處理。
+- **事實與模式分層**:單條明確的身分、健康狀態、裝置使用、隸屬關係、專案或偏好屬於 L2 狀態,不建立 L6。L6 必須由至少兩個獨立 raw/session 中的 user-owned 證據支持。
+- **主體安全**:同一次原始寫入可能包含他人的資料或範例。只有材料明確歸屬於目前使用者時才建立使用者 Schema;否則對該材料不執行任何操作。
+- **候選涵蓋**:source-context 審查時,每條候選事實必須二選一:作為 `create_schema`/`add_evidence` 的 evidence,或用 `skip_fact` 明確跳過。原始上下文只用於確認主體或補回該事實遺漏的細節,不得據此建立無關的 Schema。
+- **證據門檻**:建立 L6 必須有 user-owned evidence,且這些證據合計代表至少兩個獨立的 raw/session。
+ 一個被 S1 合併的 L2 事實可以代表多次獨立寫入,應檢查它的 `source_raw_memory_ids`,不要只數節點。
+ 助理的建議不能作為使用者模式的獨立證據。
+
+## 工作流程
+
+輸入材料分兩部分(僅在已形成聚類時才會呼叫你):
+- **聚類結果(Cluster Results)**:主要輸入,依語義相似度分組的事實
+- **未聚類事實(補充)**:未進入任一聚類的事實,優先順序低於聚類結果,酌情審視即可
+
+對於每組事實(無論是否聚類):
+1. **搜尋既有 Schema**:如果既有 Schema 已涵蓋該模式,使用 `add_evidence`。只有加入新證據後舊表述會產生實質遺漏、錯誤或誤導時才使用 `revise_schema`。
+2. **建立新 Schema**:僅在沒有既有 Schema 涵蓋時。一句話,三要素。
+3. **建立關係**:兩個 Schema 主題相關 → 使用 `add_edge`(RELATED_TO)。
+
+## 原則
+
+- 所有 Graph 操作必須透過 tools 執行
+- Schema 內容建立後不可變——絕不重新建立已存在的 Schema
+- 優先使用 `add_evidence`,而非建立重複的節點
+- 寧可不建立,也不要建立低品質的節點
+- 一個 Schema = 一個領域內的原子模式
+- 加標籤時優先使用既有標籤清單中的標籤"""
+
+
+# ================================================================
+# Fragments assembled in code
+# ================================================================
+
+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, so their prompts stay exactly as before.
+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)"
+
+NO_INTENTION_MEMORY_SECTION = (
+ "# 記憶\n"
+ "\n"
+ "你只擷取一類記憶:**memory(記憶)**。\n"
+ "\n"
+ "## memory(記憶)\n"
+ "\n"
+ "一切值得長期記住的資訊都放這裡——既包括使用者本人的,也包括對話中其他具名真人的:\n"
+ "\n"
+ "* 偏好、觀點、態度、價值觀\n"
+ "* 事件、行動、經歷\n"
+ "* 習慣、行為模式\n"
+ "* 關係、穩定特質\n"
+ "* 客觀事實、決策、限制條件\n"
+ "* 正在進行的活動\n"
+ "* **未來計畫/即將發生的安排**(若值得記住,直接寫進 `memory`;"
+ "不要另開 intentions 桶)\n"
+ "\n"
+ "如果使用者隱含地表達偏好,也應擷取。\n"
+ "\n"
+ "不要把\"使用者是怎樣的人\"和\"發生了什麼\"分開。兩者都放進 `memory`。\n"
+ "\n"
+ "---\n"
+ "\n"
+)
+
+# (old, new) pairs applied in order after the section swap.
+NO_INTENTION_REPLACEMENTS = (
+ (
+ "每條 memory 和 intention 都必須帶 `owner`",
+ "每條 memory 都必須帶 `owner`",
+ ),
+)
+
+INTENTION_DISABLED_NOTE = (
+ "\n\n---\n\n# INTENTION 已關閉\n"
+ "目前設定已關閉 intention 擷取。即使範例裡出現 `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 = """
+
+## 輸出格式
+
+不要呼叫 tools。直接輸出一個 JSON 陣列,包含你決定執行的操作。用 ```json 程式碼區塊包住。
+
+可用操作:
+
+1. **create_schema** — 建立新的 L6 行為 Schema
+ ```{"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** — 新證據使既有 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。僅用於他人的事實、臨時事件、無法證明使用者特徵的助理建議,或已被既有 Schema 完整涵蓋的事實。
+ ```{"op": "skip_fact", "node_id": "candidate_fact_id", "reason": "不是穩定的使用者模式"}```
+
+## 輸出約定
+
+1. 輸出必須是 JSON 陣列,用 ```json 程式碼區塊包住。
+2. 如果資料不足以得出可靠結論,輸出 `[]`。在 source-context review 中,
+ `[]` 表示已審查該組全部候選,且都不足以支持穩定的 Schema。
+3. 程式碼區塊外不要有任何其他文字。
+4. evidence_list 中的 id 必須來自材料中提供的 fact node_id。
+5. add_evidence / revise_schema 的 node_id 必須來自既有 Graph 節點的 id。
+6. 對 source-context 審查,必須讓每條候選事實出現在 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/session。當 `source_raw_memory_ids` 包含多次獨立寫入時,一個合併後的 L2 事實也可以滿足門檻。
+8. 單條明確的身分、健康狀態、裝置使用、隸屬關係、專案或偏好不要建立 L6;這些由 canonical 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"
+ "- Graph Schema 總數: {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} 條 anchored therapy Schema。"
+ "優先聯合不同 raw/session 中的持久 trigger/background、"
+ "反覆出現的 emotional response 和使用者已實際使用的 coping resource/decision constraint。"
+ "證據不足時輸出 []。\n"
+ ),
+ "companion_header": "**獨立來源 companion 提示(只是候選,不是結論):**",
+ "unclustered_header": "### 未聚類事實(補充,次要)\n",
+ "unclustered_hint": "以下事實未進入上述任一聚類,可在完成聚類主題處理後酌情審視;優先順序低於聚類結果。\n",
+ "forward_header": "### 相關 Graph 節點(透過 cluster centroid 向量召回,共 {count} 條)\n",
+ "graph_empty": "### 既有 Graph 節點\n目前 Graph 為空,這是首次認知處理。無需搜尋 Graph,直接根據聚類結果建立 Schema。\n",
+ "graph_no_recall": (
+ "### 既有 Graph 節點\n"
+ "Graph 中共有 {graph_total} 個 Schema,"
+ "但 centroid 向量召回未命中相關節點。請根據聚類結果判斷是否需要建立新的 Schema。\n"
+ ),
+ "reverse_header": "### Graph 反向引用(既有 Schema 引用的 VDB 事實)\n",
+ "tags_header": "### 既有標籤(請優先從中選擇,避免建立同義標籤)\n",
+ "closing": (
+ "請分析以上材料,輸出操作 JSON 陣列。"
+ "決定是否需要建立新的 Schema,或為既有 Schema 追加 evidence。"
+ "如果資料不足以得出可靠結論,輸出空陣列 `[]`。"
+ "加標籤時請優先使用既有標籤清單中的標籤。"
+ ),
+}
diff --git a/hy_memory/server.py b/hy_memory/server.py
index e18ccab..5234b4a 100644
--- a/hy_memory/server.py
+++ b/hy_memory/server.py
@@ -21,6 +21,11 @@ API Endpoints:
GET /healthz — Health check (static, process alive)
GET /health — Liveness probe (pings internal event loop; 503 if loop blocked)
GET /info — Server info
+
+/add and /add_extracted accept an optional "language" (en, zh-Hans, zh-Hant, ja,
+es, de, pt, fr, ko, ru, id, or an alias such as zh-CN / zh-TW / pt-BR). An
+unknown code returns 400. /search has no language option: the search-time
+judge / rewrite prompts are English-only and keep the query's own language.
"""
import asyncio
@@ -100,6 +105,20 @@ def _get_client():
return _client
+def _language_arg(handler: BaseHTTPRequestHandler, body: Dict, kwargs: Dict) -> bool:
+ """Validate optional ``language`` and add it to kwargs; False after a 400 reply."""
+ if body.get("language") in (None, ""):
+ return True
+ from .prompts import normalize_language
+
+ try:
+ kwargs["language"] = normalize_language(body["language"])
+ except ValueError as e:
+ _json_response(handler, 400, {"error": str(e)})
+ return False
+ return True
+
+
def _json_response(handler: BaseHTTPRequestHandler, status: int, data: Any):
"""Send a JSON response."""
body = json.dumps(data, ensure_ascii=False, default=str).encode("utf-8")
@@ -436,6 +455,9 @@ class MemoryHTTPHandler(BaseHTTPRequestHandler):
kwargs["memory_at"] = datetime.fromisoformat(body["memory_at"])
except Exception:
pass
+ # language: explicit prompt / memory language (see HyMemoryClient.add)
+ if not _language_arg(self, body, kwargs):
+ return
result = client.add(data, **kwargs)
_json_response(self, 200, result)
@@ -462,6 +484,8 @@ class MemoryHTTPHandler(BaseHTTPRequestHandler):
kwargs["memory_at"] = datetime.fromisoformat(body["memory_at"])
except Exception:
pass
+ if not _language_arg(self, body, kwargs):
+ return
result = client.add_extracted(contents, **kwargs)
_json_response(self, 200, result)
diff --git a/tests/coding/test_prompt_language_routing.py b/tests/coding/test_prompt_language_routing.py
index 7168fd8..2d52780 100644
--- a/tests/coding/test_prompt_language_routing.py
+++ b/tests/coding/test_prompt_language_routing.py
@@ -137,7 +137,7 @@ def test_extractor_routes_chinese_new_user_message_to_chinese_prompt(scene, zh_p
ChatMessage(role="tool", content="Traceback: TypeError at line 100"),
])
expected = zh_prompts["extract_coding" if scene == "coding" else "extract"]
- assert language == "zh"
+ assert language == "zh-Hans"
assert template is expected
@@ -165,7 +165,7 @@ def test_experience_reconcile_routes_from_new_drafts_not_candidates():
solution="Use the legacy retry helper",
)]]
prompt, language = build_experience_reconcile_prompt(drafts, candidates)
- assert language == "zh"
+ assert language == "zh-Hans"
assert prompt.startswith("你")
@@ -191,7 +191,7 @@ def test_fact_reconcile_routes_from_new_fact_statement():
statement="The previous session inspected retry behavior.",
)]]
prompt, language = build_fact_reconcile_prompt(drafts, candidates)
- assert language == "zh"
+ assert language == "zh-Hans"
assert prompt.startswith("你")
@@ -203,7 +203,7 @@ def test_chain_summary_routes_from_current_statement():
"(now) 用户继续修复 timeout,并完成验证。",
current_statement="用户继续修复 timeout,并完成验证。",
)
- assert language == "zh"
+ assert language == "zh-Hans"
assert prompt == CHAIN_SUMMARY_PROMPT_ZH.format(
chain_block=(
"(2026-10-11) The previous session inspected timeout behavior.\n"
diff --git a/tests/test_prompt_language_selection.py b/tests/test_prompt_language_selection.py
new file mode 100644
index 0000000..f43bebd
--- /dev/null
+++ b/tests/test_prompt_language_selection.py
@@ -0,0 +1,535 @@
+"""Explicit prompt language: validation, precedence and threading.
+
+With no language the existing zh/en auto-detection runs unchanged; with an
+explicit language every LLM call of the request uses that language's prompt
+plus its OUTPUT_LANGUAGE_DIRECTIVE.
+"""
+
+import asyncio
+from unittest.mock import AsyncMock
+
+import pytest
+
+from hy_memory.agent.extractor import Extractor, _system_prompt_without_intention
+from hy_memory.agent.llm_provider import LLMResponse
+from hy_memory.agent.reconciler import build_reconcile_prompt, build_search_query_prompt
+from hy_memory.coding.extractor import CodingMemoryExtractor
+from hy_memory.coding.fact_reconciler import (
+ build_chain_summary_prompt,
+ build_fact_reconcile_prompt,
+)
+from hy_memory.coding.reconciler import build_experience_reconcile_prompt
+from hy_memory.coding.types import CodingMemoryDraft, WorkingFactDraft
+from hy_memory.config import LLMConfig, MemoryConfig
+from hy_memory.pipelines.base import (
+ ChatMessage,
+ WriteRequest,
+ parse_user_name_line,
+ render_user_name_line,
+)
+from hy_memory.prompts import (
+ SUPPORTED_LANGUAGES,
+ get_prompt,
+ normalize_language,
+ resolve_language,
+)
+
+from tests.coding._helpers import MockLLMProvider
+
+ZH_INPUT = "我叫小明,住在北京,喜欢喝美式咖啡。"
+EN_INPUT = "My name is Bob, I live in Seattle and I love hiking."
+
+
+def run(coro):
+ loop = asyncio.new_event_loop()
+ try:
+ return loop.run_until_complete(coro)
+ finally:
+ loop.close()
+
+
+def _directive(code):
+ return get_prompt("OUTPUT_LANGUAGE_DIRECTIVE", code)
+
+
+# ── codes, aliases, validation ──
+
[email protected]("value,expected", [
+ ("en", "en"), ("zh-Hans", "zh-Hans"), ("zh-Hant", "zh-Hant"), ("ja", "ja"),
+ ("ZH-hans", "zh-Hans"), ("zh_Hant", "zh-Hant"), (" ko ", "ko"),
+ ("zh", "zh-Hans"), ("zh-CN", "zh-Hans"), ("zh-cn", "zh-Hans"),
+ ("zh-TW", "zh-Hant"), ("zh-HK", "zh-Hant"), ("pt-BR", "pt"),
+ (None, None), ("", None),
+])
+def test_normalize_language_accepts_codes_and_aliases(value, expected):
+ assert normalize_language(value) == expected
+
+
[email protected]("value", ["xx", "english", "zh-XX", "pt_BR_x", 3])
+def test_unknown_language_raises_value_error_listing_supported_codes(value):
+ with pytest.raises(ValueError) as exc:
+ normalize_language(value)
+ for code in SUPPORTED_LANGUAGES:
+ assert code in str(exc.value)
+
+
+def test_resolve_language_falls_back_to_zh_en_detection_only():
+ assert resolve_language(None, ZH_INPUT) == "zh-Hans"
+ assert resolve_language(None, EN_INPUT) == "en"
+ # auto-detection never picks the other languages
+ assert resolve_language(None, "ユーザーはコーヒーが好きです") in ("zh-Hans", "en")
+ assert resolve_language(None, "Der Nutzer mag Kaffee.") == "en"
+ assert resolve_language("de", ZH_INPUT) == "de"
+
+
+# ── config + client precedence ──
+
+def test_memory_config_language_from_env_and_dict(monkeypatch):
+ monkeypatch.setenv("MEMORY_LANGUAGE", "zh-TW")
+ assert MemoryConfig().language == "zh-Hant"
+ monkeypatch.setenv("MEMORY_LANGUAGE", "")
+ assert MemoryConfig().language is None
+ assert MemoryConfig.from_dict({"language": "pt-BR"}).language == "pt"
+ assert MemoryConfig(language="FR").language == "fr"
+ monkeypatch.setenv("MEMORY_LANGUAGE", "klingon")
+ with pytest.raises(ValueError):
+ MemoryConfig()
+
+
+def test_client_per_call_language_overrides_config(monkeypatch):
+ from hy_memory.client import HyMemoryClient
+
+ monkeypatch.delenv("MEMORY_LANGUAGE", raising=False)
+ client = HyMemoryClient.__new__(HyMemoryClient)
+ client._config = MemoryConfig(language="ja")
+ assert client._resolve_language(None) == "ja"
+ assert client._resolve_language("zh-CN") == "zh-Hans"
+ client._config = MemoryConfig()
+ assert client._resolve_language(None) is None
+ with pytest.raises(ValueError):
+ client._resolve_language("xx")
+
+
+async def test_async_add_threads_language_and_rejects_unknown_before_claim():
+ from hy_memory.client import HyMemoryClient
+
+ client = HyMemoryClient.__new__(HyMemoryClient)
+ client._config = MemoryConfig(language="es")
+ client._claim_write_outcome = AsyncMock(return_value=None)
+ client._finish_write_outcome = AsyncMock()
+ client._async_add_impl = AsyncMock(return_value={"success": True})
+
+ await HyMemoryClient.async_add.__wrapped__(client, "hola", user_id="u1")
+ assert client._async_add_impl.await_args.kwargs["language"] == "es"
+ await HyMemoryClient.async_add.__wrapped__(
+ client, "hi", user_id="u1", language="zh-HK",
+ )
+ assert client._async_add_impl.await_args.kwargs["language"] == "zh-Hant"
+
+ client._claim_write_outcome.reset_mock()
+ with pytest.raises(ValueError):
+ await HyMemoryClient.async_add.__wrapped__(
+ client, "hi", user_id="u1", language="xx",
+ )
+ client._claim_write_outcome.assert_not_awaited()
+
+
+async def test_async_add_extracted_threads_language():
+ from hy_memory.client import HyMemoryClient
+
+ client = HyMemoryClient.__new__(HyMemoryClient)
+ client._config = MemoryConfig()
+ client._claim_write_outcome = AsyncMock(return_value=None)
+ client._finish_write_outcome = AsyncMock()
+ client._async_add_extracted_impl = AsyncMock(return_value={"success": True})
+ await HyMemoryClient.async_add_extracted.__wrapped__(
+ client, ["a fact"], user_id="u1", language="ru",
+ )
+ assert client._async_add_extracted_impl.await_args.kwargs["language"] == "ru"
+ await HyMemoryClient.async_add_extracted.__wrapped__(
+ client, ["a fact"], user_id="u1",
+ )
+ assert client._async_add_extracted_impl.await_args.kwargs["language"] is None
+
+
+# ── chat extraction ──
+
+class _CapturingLLM:
+ def __init__(self):
+ self.last_messages = None
+
+ async def complete_messages(self, *, messages, max_tokens, temperature=None,
+ tools=None, tool_choice=None, **kwargs):
+ self.last_messages = messages
+ return LLMResponse(
+ content='{"memory": [], "intentions": [], "basic_info": {}}',
+ tokens_used=1, prompt_tokens=1, completion_tokens=0, tool_calls=None,
+ )
+
+ def role(self, role):
+ return next(m["content"] for m in self.last_messages if m["role"] == role)
+
+
+def _extract(content, language=None, **cfg):
+ llm = _CapturingLLM()
+ run(Extractor(llm, LLMConfig(**cfg)).extract(
+ content=content, current_time="2026-07-01", language=language,
+ ))
+ return llm
+
+
+def test_extract_without_language_keeps_auto_detection_byte_identical():
+ assert _extract(ZH_INPUT).role("system") == get_prompt("EXTRACT_SYSTEM_PROMPT", "zh-Hans")
+ assert _extract(EN_INPUT).role("system") == get_prompt("EXTRACT_SYSTEM_PROMPT", "en")
+
+
[email protected]("code", SUPPORTED_LANGUAGES)
+def test_extract_with_explicit_language_uses_that_prompt_and_directive(code):
+ llm = _extract(ZH_INPUT, language=code)
+ assert llm.role("system") == (
+ get_prompt("EXTRACT_SYSTEM_PROMPT", code) + _directive(code)
+ )
+ assert llm.role("user") == get_prompt("EXTRACT_PROMPT", code).format(
+ content=ZH_INPUT, current_date=_today(),
+ memory_at="2026-07-01", last_messages="(none)",
+ )
+
+
+def _today():
+ from datetime import date
+
+ return date.today().isoformat()
+
+
+def test_extract_alias_and_few_shot_follow_explicit_language():
+ llm = _extract(EN_INPUT, language="zh-TW", few_shot_enabled=True)
+ assert llm.role("system").startswith(
+ get_prompt("EXTRACT_SYSTEM_PROMPT", "zh-Hant")
+ + get_prompt("EXTRACT_FEW_SHOT", "zh-Hant")
+ )
+
+
+def test_custom_system_prompt_still_applies_to_its_own_language_only():
+ llm = _extract(EN_INPUT, language="en", extract_system_prompt_en="CUSTOM EN")
+ assert llm.role("system") == "CUSTOM EN" + _directive("en")
+ llm = _extract(EN_INPUT, language="de", extract_system_prompt_en="CUSTOM EN")
+ assert llm.role("system").startswith(get_prompt("EXTRACT_SYSTEM_PROMPT", "de"))
+
+
[email protected]("code", SUPPORTED_LANGUAGES)
+def test_no_intention_rewrite_works_for_every_language(code):
+ import re
+
+ base = get_prompt("EXTRACT_SYSTEM_PROMPT", code)
+ out = _system_prompt_without_intention(base, lang=code)
+ assert get_prompt("NO_INTENTION_MEMORY_SECTION", code) in out
+ assert not re.search(get_prompt("NO_INTENTION_SECTION_PATTERN", code), out, re.S)
+ assert out.endswith(get_prompt("INTENTION_DISABLED_NOTE", code))
+
+
+# ── chat reconcile ──
+
+def _reconcile(memories, language=None):
+ return build_reconcile_prompt(
+ new_memories=memories, new_memories_block="NEW", existing_memories_block="OLD",
+ current_date="2026-07-01 10:00", few_shot_enabled=True,
+ structure_metadata_enabled=True, language=language,
+ )
+
+
+def test_reconcile_without_language_keeps_auto_detection():
+ zh = _reconcile([ZH_INPUT])
+ assert zh.startswith(get_prompt("RECONCILE_PROMPT", "zh-Hans")[:40])
+ assert zh.endswith(get_prompt("RECONCILE_STRUCTURE_METADATA_PROMPT", "zh-Hans"))
+ en = _reconcile([EN_INPUT])
+ assert en.endswith(get_prompt("RECONCILE_STRUCTURE_METADATA_PROMPT", "en"))
+
+
[email protected]("code", ["fr", "zh-Hant", "id"])
+def test_reconcile_and_search_query_use_explicit_language(code):
+ prompt = _reconcile([ZH_INPUT], language=code)
+ expected = get_prompt("RECONCILE_PROMPT", code).format(
+ current_date="2026-07-01 10:00", new_memories="NEW", existing_memories="OLD",
+ few_shot_section="\n" + get_prompt("RECONCILE_FEW_SHOT", code) + "\n",
+ ) + get_prompt("RECONCILE_STRUCTURE_METADATA_PROMPT", code) + _directive(code)
+ assert prompt == expected
+ sq = build_search_query_prompt([ZH_INPUT], language=code)
+ assert sq.endswith(_directive(code))
+ assert sq.startswith(get_prompt("SEARCH_QUERY_PROMPT", code)[:20])
+ assert build_search_query_prompt([ZH_INPUT]) == get_prompt(
+ "SEARCH_QUERY_PROMPT", "zh-Hans",
+ ).format(new_memories=f"1. {ZH_INPUT}")
+
+
+# ── working / coding path ──
+
[email protected]("scene,name", [
+ ("working", "CODING_EXTRACT_PROMPT"), ("coding", "CODING_EXTRACT_PROMPT_CODING"),
+])
+def test_coding_extractor_template_follows_explicit_language(scene, name):
+ extractor = CodingMemoryExtractor(MockLLMProvider("{}"), scene=scene)
+ messages = [ChatMessage(role="user", content="请修复 api_client.py 的 timeout")]
+ template, code = extractor._select_prompt_template(messages, "ko")
+ assert code == "ko" and template is get_prompt(name, "ko")
+ template, code = extractor._select_prompt_template(messages)
+ assert code == "zh-Hans" and template is get_prompt(name, "zh-Hans")
+
+
+def test_coding_extract_call_uses_language_for_labels_and_directive():
+ llm = MockLLMProvider('{"experiences": [], "fact": null}')
+ extractor = CodingMemoryExtractor(llm, scene="working")
+ run(extractor.extract(
+ [ChatMessage(role="user", content="Fix the timeout"),
+ ChatMessage(role="tool", content="ok")],
+ user_id="u1", language="ja",
+ ))
+ prompt = llm.calls[-1]["prompt"]
+ assert prompt.endswith(_directive("ja"))
+ empty = get_prompt("CODING_EMPTY_BLOCK", "ja")
+ head = get_prompt("CODING_CONVERSATION_BLOCK", "ja").split("{history}")[0]
+ assert head + empty in prompt
+
+
+def test_coding_extract_without_language_is_unchanged():
+ llm = MockLLMProvider('{"experiences": [], "fact": null}')
+ extractor = CodingMemoryExtractor(llm, scene="working")
+ run(extractor.extract(
+ [ChatMessage(role="user", content="Fix the timeout"),
+ ChatMessage(role="tool", content="ok")],
+ user_id="u1",
+ ))
+ prompt = llm.calls[-1]["prompt"]
+ assert "LAST 5 USER TURNS (CONTEXT ONLY; do not extract them again):\n(none)" in prompt
+ assert _directive("en") not in prompt
+
+
+def test_coding_reconcilers_follow_explicit_language():
+ drafts = [CodingMemoryDraft(task="修复搜索超时", solution="改 timeout", user_id="u1")]
+ prompt, code = build_experience_reconcile_prompt(drafts, [[]], language="es")
+ assert code == "es" and prompt.endswith(_directive("es"))
+ assert prompt.startswith(get_prompt("CODING_RECONCILE_PROMPT", "es")[:30])
+ _, code = build_experience_reconcile_prompt(drafts, [[]])
+ assert code == "zh-Hans"
+
+ facts = [WorkingFactDraft(subject="api.py", statement="修复了 timeout")]
+ prompt, code = build_fact_reconcile_prompt(facts, [[]], language="pt-BR")
+ assert code == "pt" and prompt.endswith(_directive("pt"))
+
+ prompt, code = build_chain_summary_prompt(
+ "(now) fixed", current_statement="fixed", language="ru",
+ )
+ assert code == "ru"
+ assert prompt == get_prompt("CODING_CHAIN_SUMMARY_PROMPT", "ru").format(
+ chain_block="(now) fixed",
+ ) + _directive("ru")
+
+
+async def test_coding_writer_threads_language_to_every_step():
+ from hy_memory.coding.writer import CodingWriter
+
+ writer = CodingWriter.__new__(CodingWriter)
+ writer.store = type("S", (), {})()
+ writer.store.config = type("C", (), {
+ "coding": type("CC", (), {"tool_result_max_bytes": 2048})(),
+ "extractor": type("E", (), {"history_turns": 5})(),
+ })()
+ writer.store.get_recent_trace_messages = AsyncMock(return_value=[])
+ writer.store.append_trace = AsyncMock()
+ draft = CodingMemoryDraft(task="t", solution="s", user_id="u1")
+ fact = WorkingFactDraft(subject="x", statement="y")
+ writer.extractor = type("X", (), {})()
+ writer.extractor.extract = AsyncMock(return_value=([draft], [fact]))
+ writer.reconciler = type("R", (), {})()
+ writer.reconciler.reconcile = AsyncMock(return_value=[])
+ writer.fact_reconciler = type("F", (), {})()
+ writer.fact_reconciler.reconcile = AsyncMock(return_value=([], []))
+ writer._crosslink = AsyncMock()
+ writer.cache = None
+ writer.variant = "working"
+
+ await writer.write([ChatMessage(role="user", content="hi")], user_id="u1",
+ language="de")
+ assert writer.extractor.extract.await_args.kwargs["language"] == "de"
+ assert writer.reconciler.reconcile.await_args.kwargs["language"] == "de"
+ assert writer.fact_reconciler.reconcile.await_args.kwargs["language"] == "de"
+
+
+# ── summaries ──
+
+async def test_episode_and_topic_summary_prompts_follow_language():
+ from hy_memory.agent import episode_summary
+ from hy_memory.pipelines._graph import topic_summary
+
+ llm = MockLLMProvider("summary")
+ _, prompt, _ = await episode_summary._generate(
+ llm_provider=llm, memories=["用户喜欢咖啡"], language="ja",
+ )
+ assert prompt == get_prompt("EPISODE_SUMMARY_PROMPT", "ja").format(
+ memories="- 用户喜欢咖啡",
+ ) + _directive("ja")
+ _, prompt, _ = await episode_summary._generate(
+ llm_provider=llm, memories=["用户喜欢咖啡"],
+ )
+ assert prompt == get_prompt("EPISODE_SUMMARY_PROMPT", "zh-Hans").format(
+ memories="- 用户喜欢咖啡",
+ )
+ _, prompt, _ = await topic_summary._generate(
+ llm_provider=llm, topic_name="coffee", memories=["likes coffee"],
+ language="fr",
+ )
+ assert prompt.endswith(_directive("fr"))
+ assert prompt.startswith(get_prompt("TOPIC_SUMMARY_PROMPT", "fr")[:20])
+
+
+# ── System 2 ──
+
[email protected]("code", SUPPORTED_LANGUAGES)
+def test_system2_prompts_follow_language(code):
+ from hy_memory.pipelines import system2_agent as s2
+
+ system_prompt = s2._build_single_call_system_prompt(code)
+ assert system_prompt.endswith(get_prompt("SYSTEM2_OUTPUT_INSTRUCTIONS", code))
+ first_old = get_prompt("SYSTEM2_SINGLE_CALL_REPLACEMENTS", code)[0][0]
+ assert first_old not in system_prompt
+ message = s2._build_materials_message(
+ {"stats": {"graph_total_schemas": 0}, "clusters": []}, lang=code,
+ )
+ materials = get_prompt("SYSTEM2_MATERIALS", code)
+ assert message.startswith(materials["title"])
+ assert message.endswith(materials["closing"])
+
+
+async def test_system2_agent_uses_explicit_language(monkeypatch):
+ from hy_memory.pipelines import system2_agent as s2
+
+ seen = {}
+
+ class _Provider:
+ def __init__(self, config):
+ pass
+
+ async def complete_messages(self, messages, **kwargs):
+ seen["messages"] = messages
+ return LLMResponse(content="```json\n[]\n```", tokens_used=1)
+
+ monkeypatch.setattr("hy_memory.agent.llm_provider.LLMProvider", _Provider)
+ materials = {"stats": {}, "clusters": [{"facts": [
+ {"layer": "L2", "content": "用户每天跑步", "node_id": "f1"}], "centroid_text": "跑步"}]}
+ async def _run(**kwargs):
+ # Only the prompt sent to the model matters here; executing the
+ # (empty) operation list needs a real tool executor.
+ try:
+ await s2.run_system2_agent(
+ materials, tool_executor=None, config=MemoryConfig(), **kwargs,
+ )
+ except AttributeError:
+ pass
+
+ await _run(language="de")
+ system = seen["messages"][0]["content"]
+ assert system.startswith(get_prompt("SYSTEM2_AGENT_PROMPT", "de")[:30])
+ assert system.endswith(_directive("de"))
+ assert seen["messages"][1]["content"].startswith(
+ get_prompt("SYSTEM2_MATERIALS", "de")["title"]
+ )
+
+ await _run()
+ system = seen["messages"][0]["content"]
+ assert system == s2._build_single_call_system_prompt("zh")
+
+
+async def test_sweeper_llm_call_gets_output_language_rule(monkeypatch):
+ from hy_memory.pipelines import system2_writer
+
+ prompts = []
+
+ class _Sweeper:
+ def __init__(self, *, llm_call, **kwargs):
+ self.llm_call = llm_call
+
+ async def sweep(self):
+ await self.llm_call("Task: abstract")
+ return {}
+
+ async def llm_call(prompt):
+ prompts.append(prompt)
+ return "{}"
+
+ monkeypatch.setattr(system2_writer, "_SWEEPER_ENABLED", True)
+ monkeypatch.setattr(
+ "hy_memory.pipelines.cross_domain_sweeper.CrossDomainSweeper", _Sweeper,
+ )
+ writer = system2_writer.System2Writer.__new__(system2_writer.System2Writer)
+ writer._writer = type("W", (), {"embed_service": None})()
+ writer._graph_store = None
+ writer._cache = None
+ await writer._run_cross_domain_sweeper("u1", "a1", llm_call, language="ko")
+ await writer._run_cross_domain_sweeper("u1", "a1", llm_call)
+ assert prompts == ["Task: abstract" + _directive("ko"), "Task: abstract"]
+
+
+# ── basic profile name line + write request ──
+
[email protected]("code", SUPPORTED_LANGUAGES)
+def test_user_name_line_round_trips_in_every_language(code):
+ line = render_user_name_line("Tim", language=code)
+ assert line == get_prompt("USER_NAME_LINE", code).format(name="Tim")
+ assert parse_user_name_line(line) == "Tim"
+
+
+def test_write_request_name_line_uses_explicit_language():
+ msgs = [ChatMessage(role="user", content="我喜欢咖啡", name="Tim")]
+ assert WriteRequest(messages=msgs).get_flat_content().startswith("用户名叫Tim")
+ assert WriteRequest(messages=msgs, language="ja").get_flat_content().startswith(
+ get_prompt("USER_NAME_LINE", "ja").format(name="Tim")
+ )
+
+
+async def test_mem_agent_passes_language_to_extractor():
+ from hy_memory.agent.mem_agent import MemAgent
+
+ agent = MemAgent.__new__(MemAgent)
+ agent.extractor = type("X", (), {})()
+ agent.extractor.extract = AsyncMock(side_effect=RuntimeError("stop"))
+ await agent.process_add(content="hi", context={}, language="id")
+ assert agent.extractor.extract.await_args.kwargs["language"] == "id"
+
+
+# ── server ──
+
+def test_server_language_arg_validates_and_normalizes():
+ from hy_memory import server
+
+ sent = {}
+ original = server._json_response
+ server._json_response = lambda handler, status, data: sent.update(
+ status=status, data=data,
+ )
+ try:
+ kwargs = {}
+ assert server._language_arg(None, {"language": "zh-TW"}, kwargs)
+ assert kwargs == {"language": "zh-Hant"}
+ kwargs = {}
+ assert server._language_arg(None, {}, kwargs) and kwargs == {}
+ assert not server._language_arg(None, {"language": "xx"}, {})
+ assert sent["status"] == 400 and "zh-Hans" in sent["data"]["error"]
+ finally:
+ server._json_response = original
+
+
+ "使用者", "ユーザー", "사용자", "El usuario", "Der Nutzer", "O usuário",
+ "L'utilisateur", "Пользователь", "Pengguna",
+])
+def test_localized_user_placeholders_never_become_a_name(value):
+ from hy_memory.agent.tools.basic_profile import is_placeholder_value
+
+ assert is_placeholder_value("name", value)
+ assert not is_placeholder_value("name", "Tim")
diff --git a/tests/test_prompt_registry.py b/tests/test_prompt_registry.py
new file mode 100644
index 0000000..0f27ebd
--- /dev/null
+++ b/tests/test_prompt_registry.py
@@ -0,0 +1,202 @@
+"""Prompt registry contracts: every language defines every prompt correctly.
+
+en and zh-Hans are pinned by sha256 to the strings shipped before the
+registry existed, so existing users see byte-identical prompts.
+"""
+
+import hashlib
+import json
+import re
+from string import Formatter
+
+import pytest
+
+from hy_memory.prompts import (
+ FORMAT_FIELDS,
+ PROMPT_NAMES,
+ SUPPORTED_LANGUAGES,
+ SYSTEM2_MATERIALS_FIELDS,
+ get_prompt,
+)
+
+_PINNED_SHA256 = {
+ "en": {
+ "EXTRACT_SYSTEM_PROMPT": "2e362cbeb2d2ed5cb71a830979b645c56460e95afe00ad3238bf986c0d631936",
+ "STRUCTURE_METADATA_PROMPT": "b64b3d33484240d1ac8b7db2488864a166beb9d677a9270c3701f0fb0ce55987",
+ "EXTRACT_FEW_SHOT": "c6c3b5ce137e5d18bfd492c5d36ad170e0c29e1755a94b29cc705edeee14d3f1",
+ "EXTRACT_PROMPT": "d72586990e9b8cce115cc9092da7ac9bccc47ad990b9d7fe81250dcb45671276",
+ "EXTRACT_PROMPT_NO_INTENTION": "26a2c2efcd32551a424d21d1c0ff6677951f97edeac68db7eec4bb714cc30ea6",
+ "NO_INTENTION_SECTION_PATTERN": "b45f2d33cd009d7b7f25085dcf384ac7a4da2e8fde42f823c9eec9f661cd7d02",
+ "NO_INTENTION_MEMORY_SECTION": "702b1fc9811acaf502a1c99184e1c406470187b351b2643395776c6bce3c9f25",
+ "NO_INTENTION_REPLACEMENTS": "63b0f145520cbc1480ae4f9f4c5d1692e6c3e56a662cb6c47e468e21bf09ea40",
+ "INTENTION_DISABLED_NOTE": "3979b55177eda6748239a37b8eb522fb1051ea240836118f4a5d972121839af2",
+ "USER_NAME_LINE": "5bc710c0a52712aa8ace10555de186a87f7051787ed61971c461acd81e6cb7e8",
+ "SEARCH_QUERY_PROMPT": "90617660bb4c20460e295802dc2ff1ab7447d51e3e6ef5ac77b9d10594696de5",
+ "RECONCILE_PROMPT": "bb3dcc2cc65a315d4ce52195a681efbd32527a81d085c61f0fb052799d1a3a85",
+ "RECONCILE_STRUCTURE_METADATA_PROMPT": "9fe65cb30b08a9de47e5db5ba512bace739b5c85a36395e61b2cebb02d3d7f5b",
+ "RECONCILE_FEW_SHOT": "0fbe1b979b86e4ca133d15b24607284a19ab4523010e770c51a5d865b9cc8528",
+ "CODING_EXTRACT_PROMPT": "53a056cfb1deabd613a23ea26058e821d52c4f863f89b706547a974aeca008ac",
+ "CODING_EXTRACT_PROMPT_CODING": "3e987f1b6cfb7a17cfec11f4918729fc3fe118268471ca46d57e84fd3de9e6b4",
+ "CODING_CONVERSATION_BLOCK": "c0d2bb215e8a02f0590f586d81daa7955d39a94bed9e37657d2b922d81b29e7d",
+ "CODING_EMPTY_BLOCK": "552e423045fcbd949252397b4bee754f0b8f99b1bbbe41edc9b25dbfc81b146a",
+ "CODING_RECONCILE_PROMPT": "00bca0e7f44f421470363c3a6d35a3da8df1993c685f514a8d5ae93023427c75",
+ "CODING_FACT_RECONCILE_PROMPT": "1db547157bce2910030772cbf2286b77ddefa4936ff3e4ed05ff2088019110be",
+ "CODING_CHAIN_SUMMARY_PROMPT": "dac479310ce51dbea8f0c25f00de6060d65a524af1f3a1c686a5df19c29724df",
+ "EPISODE_SUMMARY_PROMPT": "d93e2d2fcf9f424c3de524ac82d36a41ad5c3bf4c702a0e487085e856f65ef5e",
+ "TOPIC_SUMMARY_PROMPT": "a5bb0a74491f382139a52fee46a055c22efa694ab03fc148cb894d08961a1d2d",
+ "SYSTEM2_AGENT_PROMPT": "c2254e94d0bc239ccda9cbd79b98508128417bb224d27792f2ea89b837c5e05e",
+ "SYSTEM2_OUTPUT_INSTRUCTIONS": "cbbd0786c4f3ff8b69f69a46a7476a6037ec722801718579392f2e6e26c8c2e7",
+ "SYSTEM2_SCHEMA_EVIDENCE_GATE": "6e858894061a9f2107a21f8b6cd547d42deaac69a40d59e11d338cbf2de892e4",
+ "SYSTEM2_SINGLE_CALL_REPLACEMENTS": "7879edaf5a3681b0ddfaeb65cf76fed305ab88914c05fb0fffe5d5dfd51cf21d",
+ "SYSTEM2_MATERIALS": "3ff1546a7a3ca150f1bae324d94939ce864de229b29e0245692621084b04e52a",
+ },
+ "zh-Hans": {
+ "EXTRACT_SYSTEM_PROMPT": "fc8de8505c744091fcdc24a2cfd7a4e6f62a1332c18fa39d191a7f39aa0a7f4a",
+ "STRUCTURE_METADATA_PROMPT": "dac3aca6671dc5ca0766425df1463c01a516ed515c7b38a7925c1b53ffb115a6",
+ "EXTRACT_FEW_SHOT": "6e2ad8bb1f054cc32f3501e42cdc865b246934ecb660d9572e342be8d900f244",
+ "EXTRACT_PROMPT": "2e065893433ba2af68b55d41c3dc7e056f630dd4b41ed431e557751101e51be5",
+ "EXTRACT_PROMPT_NO_INTENTION": "66adb01ad790a46ad0c13ff2b30aa79c0e29bcbb2e191bc3cf3e544fe6e4956b",
+ "NO_INTENTION_SECTION_PATTERN": "27110fb7913b57e205372ede892a1656682a2635e77e119952a68a864cfdf646",
+ "NO_INTENTION_MEMORY_SECTION": "1d698eb697aa0e079d33bcc450ec0036dbafc600b1ec30ca80a6a18def6894f6",
+ "NO_INTENTION_REPLACEMENTS": "211f2bacfbc1852fc3f11dfb67acdd44c534f703b1612dfc59d1c569ff3a39b2",
+ "INTENTION_DISABLED_NOTE": "50fe78d881568a3a17a0cd3c993836eceafd719f762cfb37c7884b448b74b174",
+ "USER_NAME_LINE": "9f702915ddcd42d5c16ed7a0da3256e69d33991f4b88b14c2d3c04cc22c95150",
+ "SEARCH_QUERY_PROMPT": "91b760eec1d2ed2bc02f1688acb911b0786cadd06eea88645722db9691baf25c",
+ "RECONCILE_PROMPT": "32f5162b496c07fec643a96158eae87aa12c1dfae0ffd2084f5aa71b71377869",
+ "RECONCILE_STRUCTURE_METADATA_PROMPT": "720640c185bd2c4e1b0c1694e1236b23e1923b7a02d948282a049de7dd4dfb8a",
+ "RECONCILE_FEW_SHOT": "c96ffff49ac71bf52ccef0d1173ea8dfba31c1542f3cfeab939b4a906e037e58",
+ "CODING_EXTRACT_PROMPT": "b87d5df66ef153baaf38f32a59ec0641e6f3bac4f0014056b37f61278d176c59",
+ "CODING_EXTRACT_PROMPT_CODING": "1d6bb3c538dd31f310b3d123617bf73ee5a1c4474f3176f042d9f2af62c3d997",
+ "CODING_CONVERSATION_BLOCK": "3253e7c9d81136475b435d07f47f7cf5fe315d1c9d8b8b31ed15da8db7829d72",
+ "CODING_EMPTY_BLOCK": "c7bcc6d27f3abaaa5410e40c17f0c5ca79781a74e176695193c22aa4a8064d62",
+ "CODING_RECONCILE_PROMPT": "4b62e6e214b70403e6e041e0d00cd7d5545100759beda9c2b6d5a5a6235452dc",
+ "CODING_FACT_RECONCILE_PROMPT": "74ed3b045f11a4aeb29fcaf43407e3f814c4e25f0469d7f3c3b4f57e5973431c",
+ "CODING_CHAIN_SUMMARY_PROMPT": "2d1445b2ade72102750920644ff2e086416dd58152419fd5d43114e75a35d270",
+ "EPISODE_SUMMARY_PROMPT": "999bd17d779380248681e6e992fad0daa5e785e7476898a28888f6e51fef42ec",
+ "TOPIC_SUMMARY_PROMPT": "a4b96d5f3e317e0b5c4b047d9fbbe5c3378c55c5814dc5765201ea15d5c7beee",
+ "SYSTEM2_AGENT_PROMPT": "7c681573ca35dca00bd79dd81b56cfb4e820db76c7bedcea620f15394a42cf48",
+ "SYSTEM2_OUTPUT_INSTRUCTIONS": "2d6da105e45e333494122c03c4416a5a9ad90cdce3603ace7251731e1acafcc4",
+ "SYSTEM2_SCHEMA_EVIDENCE_GATE": "cdfefe924a0d504593a04466cc48009c4583d9f6771fe8770a62e56f9ff4be1c",
+ "SYSTEM2_SINGLE_CALL_REPLACEMENTS": "bac38a8ad4a03037d59b33360ad3b7de4729f454c3b5291f20a1d5cb8893043b",
+ "SYSTEM2_MATERIALS": "0780c720db4f30bec96028353056e03b9fb60c8805cca7d74ff127566353ca15",
+ },
+}
+
+
+_NEW_ONLY = {"OUTPUT_LANGUAGE_DIRECTIVE", "LANGUAGE_NAME"}
+_TRANSLATED = [code for code in SUPPORTED_LANGUAGES if code not in ("en", "zh-Hans")]
+
+_JSON_KEY_RE = re.compile(r'"([A-Za-z_][A-Za-z0-9_]*)"\s*:')
+_ENUM_RE = re.compile(r'"([A-Z][A-Z0-9_]+)"')
+
+
+def _sha(value) -> str:
+ if not isinstance(value, str):
+ value = json.dumps(value, ensure_ascii=False, sort_keys=True)
+ return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def _fields(template: str) -> set:
+ return {name for _, name, _, _ in Formatter().parse(template) if name is not None}
+
+
[email protected]("language", ["en", "zh-Hans"])
+def test_en_and_zh_hans_are_byte_identical_to_previous_release(language):
+ pins = _PINNED_SHA256[language]
+ assert set(pins) == set(PROMPT_NAMES) - _NEW_ONLY
+ changed = [name for name, digest in pins.items()
+ if _sha(get_prompt(name, language)) != digest]
+ assert changed == []
+
+
+def test_legacy_names_still_point_at_registry_strings():
+ from hy_memory.agent import extractor, prompts_zh, reconciler
+ from hy_memory.coding import extractor as coding_extractor
+ from hy_memory.coding import prompts_zh as coding_zh
+
+ assert extractor.EXTRACT_SYSTEM_PROMPT is get_prompt("EXTRACT_SYSTEM_PROMPT", "en")
+ assert extractor.EXTRACT_FEW_SHOT_EN is get_prompt("EXTRACT_FEW_SHOT", "en")
+ assert reconciler.RECONCILE_PROMPT is get_prompt("RECONCILE_PROMPT", "en")
+ assert prompts_zh.EXTRACT_SYSTEM_PROMPT_ZH is get_prompt("EXTRACT_SYSTEM_PROMPT", "zh-Hans")
+ assert prompts_zh.RECONCILE_FEW_SHOT_ZH is get_prompt("RECONCILE_FEW_SHOT", "zh-Hans")
+ assert coding_extractor.EXTRACT_PROMPT_CODING is get_prompt("CODING_EXTRACT_PROMPT_CODING", "en")
+ assert coding_zh.CHAIN_SUMMARY_PROMPT_ZH is get_prompt("CODING_CHAIN_SUMMARY_PROMPT", "zh-Hans")
+
+
[email protected]("language", SUPPORTED_LANGUAGES)
+def test_language_defines_every_prompt(language):
+ for name in PROMPT_NAMES:
+ value = get_prompt(name, language)
+ en = get_prompt(name, "en")
+ assert type(value) is type(en), name
+ if isinstance(value, str):
+ assert value.strip(), name
+
+
[email protected]("language", SUPPORTED_LANGUAGES)
+def test_format_prompts_keep_en_placeholders_and_render(language):
+ for name, expected in FORMAT_FIELDS.items():
+ template = get_prompt(name, language)
+ assert _fields(template) == set(expected), name
+ assert _fields(get_prompt(name, "en")) == set(expected), name
+ rendered = template.format(**{field: f"<{field}>" for field in expected})
+ for field in expected:
+ assert f"<{field}>" in rendered, (name, field)
+
+
[email protected]("language", SUPPORTED_LANGUAGES)
+def test_json_keys_and_enum_values_match_en(language):
+ for name in PROMPT_NAMES:
+ value, en = get_prompt(name, language), get_prompt(name, "en")
+ if not isinstance(value, str):
+ continue
+ assert set(_JSON_KEY_RE.findall(value)) == set(_JSON_KEY_RE.findall(en)), name
+ assert set(_ENUM_RE.findall(value)) == set(_ENUM_RE.findall(en)), name
+
+
[email protected]("language", SUPPORTED_LANGUAGES)
+def test_system2_materials_entries(language):
+ materials = get_prompt("SYSTEM2_MATERIALS", language)
+ assert set(materials) == set(SYSTEM2_MATERIALS_FIELDS)
+ for key, expected in SYSTEM2_MATERIALS_FIELDS.items():
+ template = materials[key]
+ assert _fields(template) == set(expected), key
+ template.format(**{field: 1 for field in expected})
+
+
[email protected]("language", SUPPORTED_LANGUAGES)
+def test_no_intention_fragments_match_their_own_prompt(language):
+ system_prompt = get_prompt("EXTRACT_SYSTEM_PROMPT", language)
+ pattern = get_prompt("NO_INTENTION_SECTION_PATTERN", language)
+ assert re.search(pattern, system_prompt, flags=re.S), language
+ for old, new in get_prompt("NO_INTENTION_REPLACEMENTS", language):
+ assert isinstance(old, str) and isinstance(new, str)
+ assert get_prompt("NO_INTENTION_REPLACEMENTS", language)[0][0] in system_prompt
+
+
[email protected]("language", SUPPORTED_LANGUAGES)
+def test_system2_single_call_replacements_match_their_own_prompt(language):
+ base = get_prompt("SYSTEM2_AGENT_PROMPT", language)
+ pairs = get_prompt("SYSTEM2_SINGLE_CALL_REPLACEMENTS", language)
+ assert pairs and pairs[0][0] in base
+ if language not in ("en", "zh-Hans"):
+ missing = [old for old, _ in pairs if old not in base]
+ assert missing == []
+
+
[email protected]("language", _TRANSLATED)
+def test_translated_languages_are_not_copies(language):
+ for name in ("EXTRACT_SYSTEM_PROMPT", "RECONCILE_PROMPT", "CODING_EXTRACT_PROMPT",
+ "SYSTEM2_AGENT_PROMPT", "OUTPUT_LANGUAGE_DIRECTIVE"):
+ value = get_prompt(name, language)
+ assert value != get_prompt(name, "en"), name
+ assert value != get_prompt(name, "zh-Hans"), name
+
+
+def test_zh_hant_uses_traditional_script():
+ hant = get_prompt("EXTRACT_SYSTEM_PROMPT", "zh-Hant")
+ # 记/记忆/对话 are Simplified-only forms; the Traditional prompt uses 記/對.
+ for simplified in ("记忆", "对话", "用户"):
+ assert simplified not in hant
+ for traditional in ("記憶", "對話"):
+ assert traditional in hant