Skip to content
Python
147 KB
Raw Blame
# -*- 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 に証拠を追加するかを判断すること。"
        "信頼できる結論を出すにはデータが不十分な場合は、空の配列 `[]` を出力すること。"
        "タグを付けるときは、上記の既存のタグリストにあるタグの再利用を優先すること。"
    ),
}