Drop optional lightningcss entries from the frontend lockfile

npm install（npm 11 / Node 24）を実行した際の再解決で、lightningcss と
その各プラットフォーム向けバイナリ、detect-libc のエントリが外れた。
いずれも vite の optional な peer 依存で、実際には使われていない。

package.json は変更しておらず、追加・バージョン更新も無い（286行の削除のみ）。
この状態で npm run type-check（vue-tsc）が通ることは確認済み。

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

CLAUDE.md

@@ -59,21 +59,49 @@ Copy-Item .env.example .env
 frontend (Vue3 + Pinia, :5173)
     ↕ REST + SSE (Vite proxy)
 backend (FastAPI, :8000)
-    ├── app/api/     チャット・メモリ・ログ のルーター
-    ├── app/core/    LLM ラッパー・メモリロジック・設定
-    └── app/db/      SQLAlchemy モデル・DB 接続
+    ├── app/api/           チャット・メモリ・ノート・ログ・設定 のルーター
+    ├── app/core/          LLM ラッパー・共有ノート・設定
+    │   ├── memory_kb/     コンテキスト管理（要約・蓄積知識・ローカルKB・タグ付け）
+    │   ├── search/        Tavily Web 検索
+    │   └── discord/       Discord Bot・定期通知
+    └── app/db/            SQLAlchemy モデル・DB 接続
     ↕
 SQLite (playchat.db) + LiteLLM → 任意の LLM
 ```
 
-### メモリ機構
+### コンテキスト管理
 
-- **短期**: セッション内の全メッセージをコンテキストに含める
-- **長期**: メッセージ数が `MEMORY_SUMMARIZE_THRESHOLD`（デフォルト 20）を超えると古い半分を LLM で要約 → `memories` テーブルに保存 → 次回以降のシステムプロンプトに注入
+LLM に渡すコンテキストは `app/core/memory_kb/memory.py` の `get_context_messages()` が毎リクエスト組み立てる。
+以下の順に system メッセージを積み、最後に会話履歴を連結する（詳細は `docs/architecture.md`）。
+
+1. **蓄積知識** (`memory_kb/knowledge.py`): 過去の Web 検索で得た `knowledge_entries` の**見出し一覧のみ**（`- 「クエリ」: 一行要約`）。本文と出典は含めず、必要なら `read_knowledge` ツールで読み出す。最新 `KNOWLEDGE_CONTEXT_LIMIT`（既定 15）件。セッションを横断する
+2. **共有ノート** (`core/notes.py`): タイトル一覧＋本文先頭 40 文字のプレビューのみ
+3. **ローカル KB** (`memory_kb/local_knowledge.py`): `backend/knowledge_base/**.md` のうち、直近ユーザー発言と埋め込みコサイン類似度が高い上位 `LOCAL_KB_TOP_K`（既定 3）件かつ `LOCAL_KB_MIN_SCORE`（既定 0.75）以上を**全文**注入。プロンプト上は Web 検索結果より優先する扱い
+4. **長期メモリ**: `memories` の要約を全件連結。上限なし
+5. **短期メモリ**: セッション内の `messages` 全件（要約で削除された分を除く）
+
+**要約**: `maybe_summarize()` がアシスタント応答の保存直後に走り、メッセージ数が `MEMORY_SUMMARIZE_THRESHOLD`（既定 20）以上になると古い半分を LLM で要約して `memories` に保存する。**要約した元メッセージは `archived_at` を立ててアーカイブされる**（物理削除はしない）。アーカイブ済みメッセージは `get_context_messages()` と要約の閾値判定の両方から除外されるため LLM には渡らないが、DB には残り、履歴表示・エクスポートからは参照できる。`memory_id` にどの要約に取り込まれたかを保持する。
+
+**遅延読み込み**: 重い情報は目次だけ注入し、`llm.resolve_tool_calls()` が本番生成の前にツール（`web_search` / `read_note` / `write_note` / `read_knowledge`、最大 2 ラウンド）を解決する。Web 検索の結果は構造化要約にされ `knowledge_entries` と `knowledge_base/web_search/*.md` の両方に保存されるため、次回以降は層 1・層 3 として自動的に効いてくる。
+
+**付随機能**: `memory_kb/tagging.py` が各メッセージ・要約にバックグラウンドでタグを 3 つ付ける（コンテキストには注入せず、Discord 雑談 Bot の話題選びに使う）。`memory_kb/word_memory.py` は Janome で抽出した名詞を `deque(maxlen=200)` にプロセス内保持する（DB 非永続。起動時に直近 200 件から再シード）。
+
+**変更時の注意**: トークン数ベースの制御は一切なく、すべて件数・文字数ベース。またツールを使わない会話でも `resolve_tool_calls()` がフルコンテキストを 1 回投げるため、1 応答あたり LLM 呼び出しは最低 2 回になる。
+
+### 共有ノート
+
+ユーザーと AI が共同編集するノート。`note_pages` テーブルに 1 ページ 1 行で保存し、UI ではタブとして切り替える。
+
+- **モデルから見える範囲**: システムプロンプトに入るのは**ページのタイトル一覧**（と本文の先頭 40 文字程度のプレビュー）だけ。本文全体は含めない
+- **モデルによる読み書き**: `read_note` / `write_note` ツール（`app/core/notes.py`）で行う。`write_note` は存在しないタイトルを指定するとページを新規作成し、`mode` が `append`（既定）なら追記、`replace` なら全置換
+- **ツール実行の流れ**: `llm.resolve_tool_calls()` が本番の応答生成前にツール呼び出しを解決する。`web_search` と共通の仕組みで、ノート系ツールは `db` が渡されたときだけモデルに提示される
+- **UI への反映**: AI がノートを書き換えた場合、SSE で `notes_updated` を送ってフロント側のノートパネルを再読み込みさせる
+- **編集の衝突回避**: フロントは未保存の編集があるページ（`dirtyIds`）をサーバーの値で上書きしない
+- **セクションによるグルーピング**: `note_pages.section` にセクション名を持たせ、同じセクションのページは `position` 上で常に連続させる（`core/notes.set_section()` が割り当て時に並べ替える）。タブバーは `position` 順に描画し、隣接して同じ `section` が続く区間を1グループとして表示する。`get_notes_context()` はセクションごとに `## セクション名` の見出しを付けてタイトル一覧を出す。セクション名の一括変更は `POST /api/notes/sections/rename`（`core/notes.rename_section()`）
 
 ### SSE ストリーミング
 
-`POST /chat/stream` が SSE を返す。イベント種別: `session_id`（新規セッション ID）/ `chunk`（テキスト断片）/ `done`（完了）/ `error`（エラー）。  
+`POST /chat/stream` が SSE を返す。イベント種別: `session_id`（新規セッション ID）/ `chunk`（テキスト断片）/ `sources`（Web 検索の出典）/ `notes_updated`（AI が共有ノートを更新）/ `done`（完了）/ `error`（エラー）。  
 フロントは `src/api/client.ts` の `streamChat()` で fetch + ReadableStream により受信し、`messages.value[msgIdx]` を reactive proxy 経由で更新する。
 
 ### Markdown レンダリング
@@ -99,13 +127,23 @@ SQLite (playchat.db) + LiteLLM → 任意の LLM
 
 | 変数 | デフォルト | 説明 |
 |---|---|---|
-| `DEFAULT_MODEL` | `gpt-5.4` | デフォルト LLM モデル |
+| `DEFAULT_MODEL` | `gpt-4o` | デフォルト LLM モデル（`.env.example` では `gpt-5.4`） |
 | `DATABASE_URL` | `sqlite:///./playchat.db` | DB 接続先 |
 | `MEMORY_SUMMARIZE_THRESHOLD` | `20` | 長期メモリ化するメッセージ数の閾値 |
+| `KNOWLEDGE_CONTEXT_LIMIT` | `15` | 蓄積知識をシステムプロンプトに注入する最大件数 |
+| `TAVILY_API_KEY` | — | Tavily Web 検索の API キー（未設定なら `web_search` は空を返す） |
+| `SEARCH_SUMMARY_MODEL` | — | Web 検索結果の要約に使うモデル（未設定なら `DEFAULT_MODEL`） |
+| `TAGGING_MODEL` | — | メッセージの自動タグ付けに使うモデル（未設定なら `DEFAULT_MODEL`） |
+| `LOCAL_KB_DIR` | `knowledge_base` | ローカル Markdown ナレッジベースのディレクトリ |
+| `LOCAL_KB_EMBEDDING_MODEL` | `text-embedding-3-small` | ローカル KB の埋め込みモデル（GUI 設定画面から実行時変更可） |
+| `LOCAL_KB_TOP_K` | `3` | ローカル KB から注入する最大ファイル数 |
+| `LOCAL_KB_MIN_SCORE` | `0.75` | ローカル KB を注入するコサイン類似度の下限 |
 | `CORS_ORIGINS` | `http://localhost:5173` | 許可する CORS オリジン |
 | `DEBUG` | `false` | LiteLLM デバッグログの有効化 |
 | `OPENAI_API_KEY` | — | OpenAI API キー |
 | `ANTHROPIC_API_KEY` | — | Anthropic API キー |
 | `OLLAMA_API_BASE` | `http://localhost:11434` | Ollama エンドポイント |
+| `NOTES_TOOL_CONTENT_LIMIT` | `4000` | `read_note` が 1 回に返す本文の最大文字数 |
+| `KNOWLEDGE_TOOL_CONTENT_LIMIT` | `4000` | `read_knowledge` が 1 回に返す本文の最大文字数 |
 | `SITE_PASSWORD` | — | サイト全体を保護する共有パスワード（未設定なら無認証） |
 | `SESSION_SECRET_KEY` | 起動毎に自動生成 | ログインセッション Cookie の署名鍵 |

backend/Dockerfile

@@ -1,5 +1,10 @@
 FROM python:3.12-slim
 
+# slim イメージには /usr/share/zoneinfo が無く、TZ を設定してもUTCのままになるため入れる。
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends tzdata \
+    && rm -rf /var/lib/apt/lists/*
+
 RUN pip install --no-cache-dir uv
 
 WORKDIR /app

backend/app/api/chat.py

@@ -2,16 +2,17 @@ import asyncio
 import uuid
 from datetime import datetime, timezone
 from fastapi import APIRouter, Depends, HTTPException
-from fastapi.responses import StreamingResponse
+from fastapi.responses import StreamingResponse, JSONResponse
 from pydantic import BaseModel
 from sqlalchemy.orm import Session as DBSession
 
 from app.db.database import get_db
-from app.db.models import Session, Message
+from app.db.models import Session, Message, MessageTag
 from app.core.memory_kb import memory as mem
 from app.core import llm
 from app.core.memory_kb import knowledge
 from app.core.memory_kb import local_knowledge
+from app.core.notes import NOTE_TOOLS
 from app.core.search.websearch import WEB_SEARCH_TOOL
 from app.core.config import DEFAULT_MODEL
 from app.core.memory_kb.tagging import tag_message_by_id
@@ -41,12 +42,34 @@ class MessageResponse(BaseModel):
     role: str
     content: str
     created_at: datetime
+    # 要約に取り込まれ、LLMには渡らなくなったメッセージ。人間の履歴確認用に残してある。
+    archived_at: datetime | None = None
     tags: list[str] = []
 
     class Config:
         from_attributes = True
 
 
+class ImportMessage(BaseModel):
+    role: str
+    content: str
+    created_at: datetime | None = None
+    archived_at: datetime | None = None
+    tags: list[str] = []
+
+
+class ImportSessionMeta(BaseModel):
+    title: str | None = None
+    model: str | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+
+class ImportRequest(BaseModel):
+    session: ImportSessionMeta = ImportSessionMeta()
+    messages: list[ImportMessage]
+
+
 @router.get("/sessions", response_model=list[SessionResponse])
 def list_sessions(db: DBSession = Depends(get_db)):
     return db.query(Session).order_by(Session.updated_at.desc()).all()
@@ -63,12 +86,81 @@ def get_messages(session_id: str, db: DBSession = Depends(get_db)):
             role=m.role,
             content=m.content,
             created_at=m.created_at,
+            archived_at=m.archived_at,
             tags=[t.tag for t in m.tags],
         )
         for m in session.messages
     ]
 
 
+@router.get("/sessions/{session_id}/export")
+def export_session(session_id: str, db: DBSession = Depends(get_db)):
+    """セッションのメタデータと全メッセージをJSONファイルとしてダウンロードする。"""
+    session = db.get(Session, session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    data = {
+        "session": {
+            "id": session.id,
+            "title": session.title,
+            "model": session.model,
+            "created_at": session.created_at.isoformat(),
+            "updated_at": session.updated_at.isoformat(),
+        },
+        "messages": [
+            {
+                "id": m.id,
+                "role": m.role,
+                "content": m.content,
+                "created_at": m.created_at.isoformat(),
+                "archived_at": m.archived_at.isoformat() if m.archived_at else None,
+                "tags": [t.tag for t in m.tags],
+            }
+            for m in session.messages
+        ],
+    }
+    return JSONResponse(
+        content=data,
+        headers={"Content-Disposition": f'attachment; filename="session_{session.id}.json"'},
+    )
+
+
+@router.post("/sessions/import", response_model=SessionResponse, status_code=201)
+def import_session(req: ImportRequest, db: DBSession = Depends(get_db)):
+    """export で出力したJSON（またはその形式に沿ったJSON）から新規セッションを作成する。"""
+    if not req.messages:
+        raise HTTPException(status_code=400, detail="messages is empty")
+    for m in req.messages:
+        if m.role not in ("user", "assistant", "system"):
+            raise HTTPException(status_code=400, detail=f"invalid role: {m.role}")
+
+    title = req.session.title or req.messages[0].content[:40]
+    session = Session(
+        id=str(uuid.uuid4()),
+        title=title,
+        model=req.session.model or DEFAULT_MODEL,
+    )
+    if req.session.created_at:
+        session.created_at = req.session.created_at
+    session.updated_at = req.session.updated_at or datetime.now(timezone.utc)
+    db.add(session)
+    db.flush()
+
+    for m in req.messages:
+        msg = Message(session_id=session.id, role=m.role, content=m.content, archived_at=m.archived_at)
+        if m.created_at:
+            msg.created_at = m.created_at
+        db.add(msg)
+        db.flush()
+        for tag in m.tags:
+            db.add(MessageTag(message_id=msg.id, tag=tag))
+
+    db.commit()
+    db.refresh(session)
+    return session
+
+
 @router.delete("/sessions/{session_id}", status_code=204)
 def delete_session(session_id: str, db: DBSession = Depends(get_db)):
     session = db.get(Session, session_id)
@@ -124,9 +216,12 @@ async def stream_chat(req: ChatRequest, db: DBSession = Depends(get_db)):
         used_model = req.model or session.model
         full_response = []
         try:
-            resolved_context, searches = await llm.resolve_web_search(
-                context, model=used_model, session_id=session.id,
+            resolved_context, searches, notes_changed = await llm.resolve_tool_calls(
+                context, model=used_model, session_id=session.id, db=db,
             )
+            if notes_changed:
+                # AIがノートを書き換えたので、フロントのノートパネルを再読み込みさせる
+                yield sse({"type": "notes_updated"})
             if searches:
                 sources = [
                     {"title": r["title"], "url": r["url"]}
@@ -134,14 +229,15 @@ async def stream_chat(req: ChatRequest, db: DBSession = Depends(get_db)):
                 ]
                 yield sse({"type": "sources", "value": sources})
                 for s in searches:
-                    summary = await knowledge.summarize_results(s["query"], s["results"])
+                    headline, summary = await knowledge.summarize_results(s["query"], s["results"])
                     if summary:
-                        knowledge.save_knowledge(db, s["query"], summary, s["results"])
+                        knowledge.save_knowledge(db, s["query"], summary, s["results"], headline=headline)
                         local_knowledge.save_search_result(s["query"], summary, s["results"])
 
-            search_tools = [WEB_SEARCH_TOOL] if len(resolved_context) > len(context) else None
+            # 履歴にtool_callsが含まれる場合、最終呼び出しにも同じツール定義を渡す必要がある
+            used_tools = [WEB_SEARCH_TOOL, *NOTE_TOOLS] if len(resolved_context) > len(context) else None
             async for chunk in llm.stream_chat(
-                resolved_context, model=used_model, session_id=session.id, tools=search_tools,
+                resolved_context, model=used_model, session_id=session.id, tools=used_tools,
             ):
                 full_response.append(chunk)
                 yield sse({"type": "chunk", "value": chunk})

backend/app/api/notes.py

@@ -0,0 +1,110 @@
+from datetime import datetime
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from sqlalchemy.orm import Session as DBSession
+
+from app.core.notes import next_position, reorder, rename_section, set_section
+from app.db.database import get_db
+from app.db.models import NotePage
+
+router = APIRouter(prefix="/api/notes", tags=["notes"])
+
+
+class NotePageResponse(BaseModel):
+    id: int
+    title: str
+    content: str
+    position: int
+    section: str | None
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class NotePageCreate(BaseModel):
+    title: str = "新しいページ"
+    content: str = ""
+    section: str | None = None
+
+
+class NotePageUpdate(BaseModel):
+    title: str | None = None
+    content: str | None = None
+    section: str | None = None
+
+
+class SectionRenameRequest(BaseModel):
+    old_name: str
+    new_name: str | None = None
+
+
+class ReorderRequest(BaseModel):
+    page_id: int
+    section: str | None = None
+    order: list[int]
+
+
+@router.get("", response_model=list[NotePageResponse])
+def list_pages(db: DBSession = Depends(get_db)):
+    return db.query(NotePage).order_by(NotePage.position, NotePage.id).all()
+
+
+@router.post("", response_model=NotePageResponse, status_code=201)
+def create_page(req: NotePageCreate, db: DBSession = Depends(get_db)):
+    title = req.title.strip() or "新しいページ"
+    page = NotePage(title=title, content=req.content, position=next_position(db))
+    db.add(page)
+    db.commit()
+    db.refresh(page)
+    if req.section is not None and req.section.strip():
+        page = set_section(db, page.id, req.section)
+    return page
+
+
+@router.post("/sections/rename")
+def rename_section_endpoint(req: SectionRenameRequest, db: DBSession = Depends(get_db)):
+    """old_name セクションに属する全ページを new_name セクションへ一括で付け替える。new_name が空ならグループ解除。"""
+    count = rename_section(db, req.old_name, req.new_name)
+    return {"renamed": count}
+
+
+@router.post("/reorder")
+def reorder_pages(req: ReorderRequest, db: DBSession = Depends(get_db)):
+    """タブのドラッグ&ドロップによる並べ替え。order は全ページIDを新しい順序で並べたもの。"""
+    ok = reorder(db, req.page_id, req.section, req.order)
+    if not ok:
+        raise HTTPException(status_code=400, detail="order must contain exactly the current page ids")
+    return {"reordered": len(req.order)}
+
+
+@router.patch("/{page_id}", response_model=NotePageResponse)
+def update_page(page_id: int, req: NotePageUpdate, db: DBSession = Depends(get_db)):
+    page = db.get(NotePage, page_id)
+    if not page:
+        raise HTTPException(status_code=404, detail="Note page not found")
+    if req.title is not None:
+        title = req.title.strip()
+        if not title:
+            raise HTTPException(status_code=400, detail="title is empty")
+        page.title = title
+    if req.content is not None:
+        page.content = req.content
+    db.commit()
+    db.refresh(page)
+
+    # section はページの並び順にも影響するため、変更があれば専用ロジックで反映する
+    if "section" in req.model_fields_set:
+        page = set_section(db, page_id, req.section)
+
+    return page
+
+
+@router.delete("/{page_id}", status_code=204)
+def delete_page(page_id: int, db: DBSession = Depends(get_db)):
+    page = db.get(NotePage, page_id)
+    if not page:
+        raise HTTPException(status_code=404, detail="Note page not found")
+    db.delete(page)
+    db.commit()

backend/app/core/config.py

@@ -37,6 +37,13 @@ LOCAL_KB_EMBEDDING_MODEL: str = os.getenv("LOCAL_KB_EMBEDDING_MODEL", "text-embe
 LOCAL_KB_TOP_K: int = int(os.getenv("LOCAL_KB_TOP_K", "3"))
 LOCAL_KB_MIN_SCORE: float = float(os.getenv("LOCAL_KB_MIN_SCORE", "0.75"))
 
+# 共有ノート（ユーザーとAIが共同編集するノート）
+# read_note ツールが1回に返す本文の最大文字数
+NOTES_TOOL_CONTENT_LIMIT: int = int(os.getenv("NOTES_TOOL_CONTENT_LIMIT", "4000"))
+
+# read_knowledge ツールが1回に返す蓄積知識の本文の最大文字数
+KNOWLEDGE_TOOL_CONTENT_LIMIT: int = int(os.getenv("KNOWLEDGE_TOOL_CONTENT_LIMIT", "4000"))
+
 # Amazon Bedrock
 # 以下はすべて LiteLLM(boto3) が os.environ から直接読み取るため、.env に書くだけで自動的に有効になる。
 # IAM経由（推奨）: AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY を設定する。

backend/app/core/llm.py

@@ -2,13 +2,17 @@ import json
 import logging
 import time
 import traceback
-from typing import AsyncIterator, AsyncGenerator
+from typing import TYPE_CHECKING, AsyncIterator, AsyncGenerator
 from contextlib import asynccontextmanager
 
 import litellm
 from app.core.config import DEFAULT_MODEL, DEBUG
+from app.core.notes import NOTE_TOOLS, execute_note_tool
 from app.core.search.websearch import WEB_SEARCH_TOOL, search_web
 
+if TYPE_CHECKING:
+    from sqlalchemy.orm import Session as DBSession
+
 litellm.drop_params = True
 if DEBUG:
     litellm._turn_on_debug()
@@ -103,32 +107,42 @@ async def embed(texts: list[str], model: str) -> list[list[float]]:
     return [item["embedding"] for item in response.data]
 
 
-async def resolve_web_search(
+async def resolve_tool_calls(
     messages: list[dict],
     model: str | None = None,
     session_id: str | None = None,
+    db: "DBSession | None" = None,
     max_rounds: int = 2,
-) -> tuple[list[dict], list[dict]]:
-    """必要に応じてLLMにweb_searchツールを呼ばせ、検索結果を会話に組み込んだ上でメッセージ列を返す。
+) -> tuple[list[dict], list[dict], bool]:
+    """必要に応じてLLMにツールを呼ばせ、その結果を会話に組み込んだ上でメッセージ列を返す。
 
-    モデルがtool callingに対応していない場合は何もせず元のmessagesをそのまま返す。
-    戻り値: (拡張後のmessages, 実際に検索したクエリと結果のリスト)
+    扱うツールは web_search、共有ノート（read_note / write_note）、蓄積知識（read_knowledge）。
+    DBを見るものは db が渡されたときだけ提示する。モデルがtool callingに対応していない場合は
+    何もせず元のmessagesをそのまま返す。
+    戻り値: (拡張後のmessages, 実際に検索したクエリと結果のリスト, ノートを変更したか)
     """
+    # app.core.memory_kb.knowledge は app.core.llm を import しているため、
+    # モジュールレベルで読むと循環 import になる（_save_log と同じ理由で関数内 import する）。
+    from app.core.memory_kb.knowledge import KNOWLEDGE_TOOLS, execute_knowledge_tool
+
     used_model = model or DEFAULT_MODEL
     working_messages = list(messages)
     searches: list[dict] = []
+    notes_changed = False
+
+    tools = [WEB_SEARCH_TOOL] + (NOTE_TOOLS + KNOWLEDGE_TOOLS if db is not None else [])
 
     for _ in range(max_rounds):
         try:
             response = await litellm.acompletion(
                 model=used_model,
                 messages=working_messages,
-                tools=[WEB_SEARCH_TOOL],
+                tools=tools,
                 tool_choice="auto",
             )
         except Exception:
-            logger.info("Model %s does not support tool calling; skipping web search", used_model)
-            return messages, searches
+            logger.info("Model %s does not support tool calling; skipping tools", used_model)
+            return messages, searches, notes_changed
 
         choice_message = response.choices[0].message
         tool_calls = getattr(choice_message, "tool_calls", None)
@@ -153,13 +167,21 @@ async def resolve_web_search(
                 args = json.loads(tc.function.arguments or "{}")
             except json.JSONDecodeError:
                 args = {}
-            query = args.get("query", "")
-            results = await search_web(query)
-            if results:
-                tool_text = "\n\n".join(f"[{r['title']}]({r['url']})\n{r['content']}" for r in results)
-                searches.append({"query": query, "results": results})
+
+            name = tc.function.name
+            if name in ("read_note", "write_note") and db is not None:
+                tool_text, changed = execute_note_tool(db, name, args)
+                notes_changed = notes_changed or changed
+            elif name == "read_knowledge" and db is not None:
+                tool_text = execute_knowledge_tool(db, name, args)
             else:
-                tool_text = "検索結果が見つかりませんでした。"
+                query = args.get("query", "")
+                results = await search_web(query)
+                if results:
+                    tool_text = "\n\n".join(f"[{r['title']}]({r['url']})\n{r['content']}" for r in results)
+                    searches.append({"query": query, "results": results})
+                else:
+                    tool_text = "検索結果が見つかりませんでした。"
 
             working_messages.append({
                 "role": "tool",
@@ -167,4 +189,4 @@ async def resolve_web_search(
                 "content": tool_text,
             })
 
-    return working_messages, searches
+    return working_messages, searches, notes_changed

backend/app/core/memory_kb/knowledge.py

@@ -7,7 +7,11 @@ import trafilatura
 from sqlalchemy.orm import Session as DBSession
 
 from app.core import llm
-from app.core.config import KNOWLEDGE_CONTEXT_LIMIT, SEARCH_SUMMARY_MODEL
+from app.core.config import (
+    KNOWLEDGE_CONTEXT_LIMIT,
+    KNOWLEDGE_TOOL_CONTENT_LIMIT,
+    SEARCH_SUMMARY_MODEL,
+)
 from app.core.memory_kb import local_knowledge
 from app.db.models import KnowledgeEntry, KnowledgeSource
 
@@ -19,6 +23,9 @@ _HTML_TAG_RE = re.compile(r"<[^>]+>")
 _SUMMARY_PROMPT = (
     "以下はWeb検索「{query}」で得られた複数の検索結果です。"
     "これらの内容を整理し、Markdown形式で構造的にまとめてください。\n"
+    "- 1行目は「要約: 」で始まる60文字以内の一文にする"
+    "（何についての知識かが一目で分かる見出し。システムプロンプトにはこの行だけを載せる）\n"
+    "- 2行目以降を本文とし、以下の要領でまとめる\n"
     "- 検索結果間で重複する情報はまとめ、矛盾する情報があれば併記する\n"
     "- 見出し（##）やトピックごとの箇条書きを使い、要点が一目で分かるようにする\n"
     "- 各項目の末尾に (出典: サイト名) を付ける\n"
@@ -27,15 +34,46 @@ _SUMMARY_PROMPT = (
 )
 
 
-async def summarize_results(query: str, results: list[dict], model: str | None = None) -> str:
+_HEADLINE_MARKERS = ("要約:", "要約：")
+
+
+def _split_headline(text: str) -> tuple[str, str]:
+    """LLMの出力を (一行要約, 本文) に分ける。1行目が想定の形式でなければ見出しは空で返す。"""
+    lines = text.strip().splitlines()
+    if not lines:
+        return "", ""
+    first = lines[0].strip().lstrip("#").lstrip("-*").strip().strip("*").strip()
+    for marker in _HEADLINE_MARKERS:
+        if not first.startswith(marker):
+            continue
+        headline = first[len(marker):].strip().strip("*").strip()
+        body = "\n".join(lines[1:]).strip()
+        if headline and body:
+            return headline[:120], body
+        break
+    return "", text.strip()
+
+
+def derive_headline(query: str, summary: str) -> str:
+    """headline を持たないエントリ（この機能より前に保存されたもの）のための代替の見出し。"""
+    for line in summary.splitlines():
+        stripped = line.strip().lstrip("#").lstrip("-*").strip().strip("*").strip()
+        if stripped:
+            return stripped[:120]
+    return query
+
+
+async def summarize_results(query: str, results: list[dict], model: str | None = None) -> tuple[str, str]:
     """Web検索結果（title/url/content のリスト）をLLMで構造的なMarkdown要約にまとめる。
 
-    要約に失敗した場合は空文字を返す（生のスクレイピング結果を未加工のままファイルに
+    戻り値は (一行要約, 本文)。一行要約はシステムプロンプトに並べる見出しとして使い、
+    本文はDBとローカルナレッジベースに保存する。
+    要約に失敗した場合は ("", "") を返す（生のスクレイピング結果を未加工のままファイルに
     書き込むと、ページに残ったスクリプト断片等がセキュリティソフトに誤検知されることがあるため、
     フォールバックとして生テキストを書き出すことはしない）。
     """
     if not results:
-        return ""
+        return "", ""
 
     raw = "\n\n".join(
         f"### {r.get('title') or r['url']}\n{r.get('content', '')[:1500]}"
@@ -43,17 +81,20 @@ async def summarize_results(query: str, results: list[dict], model: str | None =
         if r.get("content")
     )
     if not raw:
-        return ""
+        return "", ""
 
     prompt = _SUMMARY_PROMPT.format(query=query, results=raw)
     try:
-        return await llm.complete(
+        text = await llm.complete(
             [{"role": "user", "content": prompt}],
             model=model or SEARCH_SUMMARY_MODEL,
         )
     except Exception:
         logger.exception("Failed to summarize search results for query=%r", query)
-        return ""
+        return "", ""
+
+    headline, body = _split_headline(text)
+    return headline or derive_headline(query, body), body
 
 
 def _strip_tags(html: str) -> str:
@@ -111,12 +152,13 @@ async def regenerate_from_sources(db: DBSession) -> int:
         if not results:
             continue
 
-        new_summary = await summarize_results(entry.query, results)
+        new_headline, new_summary = await summarize_results(entry.query, results)
         if not new_summary:
             continue
 
         old_summary = entry.summary
         entry.summary = new_summary
+        entry.headline = new_headline or derive_headline(entry.query, new_summary)
         db.commit()
 
         local_knowledge.delete_search_result_file(entry.query, old_summary)
@@ -129,9 +171,11 @@ async def regenerate_from_sources(db: DBSession) -> int:
     return count
 
 
-def save_knowledge(db: DBSession, query: str, summary: str, sources: list[dict]) -> KnowledgeEntry:
+def save_knowledge(
+    db: DBSession, query: str, summary: str, sources: list[dict], headline: str = "",
+) -> KnowledgeEntry:
     """Web検索で得た知見をDBに保存する。"""
-    entry = KnowledgeEntry(query=query, summary=summary)
+    entry = KnowledgeEntry(query=query, summary=summary, headline=headline or derive_headline(query, summary))
     db.add(entry)
     db.flush()
     for src in sources:
@@ -143,8 +187,80 @@ def save_knowledge(db: DBSession, query: str, summary: str, sources: list[dict])
     return entry
 
 
+READ_KNOWLEDGE_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "read_knowledge",
+        "description": "過去のWeb検索で蓄積した知識の本文を読み出す。システムプロンプトに提示された"
+        "「調べた事柄の一覧」の中に今の話題に関係しそうな項目があり、その本文がまだ提示されていないときに使う。"
+        "ここで読めるならWeb検索をやり直す必要はない。",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "読み出す項目のクエリ（一覧の「」内に載っているもの）"},
+            },
+            "required": ["query"],
+        },
+    },
+}
+
+KNOWLEDGE_TOOLS = [READ_KNOWLEDGE_TOOL]
+
+
+def _find_entry(db: DBSession, query: str) -> KnowledgeEntry | None:
+    """クエリで蓄積知識を探す。完全一致 → 大文字小文字・前後空白を無視した一致 → 部分一致 の順に試す。
+
+    同じクエリで複数回検索されている場合は、最も新しいものを返す。
+    """
+    entries = db.query(KnowledgeEntry).order_by(KnowledgeEntry.created_at.desc()).all()
+    for entry in entries:
+        if entry.query == query:
+            return entry
+    normalized = query.strip().casefold()
+    for entry in entries:
+        if entry.query.strip().casefold() == normalized:
+            return entry
+    for entry in entries:
+        if normalized and normalized in entry.query.strip().casefold():
+            return entry
+    return None
+
+
+def read_knowledge(db: DBSession, query: str) -> str:
+    """蓄積知識の本文をツール結果用のテキストとして返す。"""
+    entry = _find_entry(db, query)
+    if not entry:
+        available = ", ".join(
+            e.query
+            for e in db.query(KnowledgeEntry).order_by(KnowledgeEntry.created_at.desc()).limit(KNOWLEDGE_CONTEXT_LIMIT)
+        )
+        return f"「{query}」に一致する知識はありません。読み出せる項目: {available or '(なし)'}"
+
+    content = entry.summary
+    if len(content) > KNOWLEDGE_TOOL_CONTENT_LIMIT:
+        content = content[:KNOWLEDGE_TOOL_CONTENT_LIMIT] + "\n…(以下省略)"
+    urls = ", ".join(s.url for s in entry.sources) or "出典不明"
+    return f"「{entry.query}」について調べた内容:\n\n{content}\n\n(出典: {urls})"
+
+
+def execute_knowledge_tool(db: DBSession, name: str, args: dict) -> str:
+    """蓄積知識のツールを実行する。ノート系と違いDBを変更しないため、戻り値はテキストのみ。"""
+    try:
+        if name == "read_knowledge":
+            return read_knowledge(db, args.get("query", ""))
+    except Exception as e:
+        logger.exception("Knowledge tool %s failed", name)
+        return f"知識の読み出しに失敗しました: {e}"
+    return f"未知のツールです: {name}"
+
+
 def get_knowledge_context(db: DBSession) -> str | None:
-    """蓄積された知識を、システムプロンプトに注入できる形のテキストにして返す。"""
+    """蓄積された知識の「見出し一覧」を、システムプロンプトに注入できる形のテキストにして返す。
+
+    本文（summary）はここには含めない。同じ内容が knowledge_base/web_search/ 配下にも
+    Markdownとして保存されており、話題に関連していればローカルナレッジベース側が
+    全文を注入するため、ここで全件の本文を積むと同じ情報を二重に渡すことになる。
+    """
     entries = (
         db.query(KnowledgeEntry)
         .order_by(KnowledgeEntry.created_at.desc())
@@ -154,12 +270,14 @@ def get_knowledge_context(db: DBSession) -> str | None:
     if not entries:
         return None
 
-    blocks = []
-    for entry in reversed(entries):
-        urls = ", ".join(s.url for s in entry.sources) or "出典不明"
-        blocks.append(f"- 「{entry.query}」について: {entry.summary}\n  (出典: {urls})")
+    blocks = [
+        f"- 「{entry.query}」: {entry.headline or derive_headline(entry.query, entry.summary)}"
+        for entry in reversed(entries)
+    ]
 
     return (
-        "以下はこれまでのWeb検索で得た知識です。関連する話題が出たら活用してください。"
-        "ただしローカルナレッジベースの資料が別途提示されている場合は、そちらを優先してください:\n\n" + "\n".join(blocks)
+        "以下はこれまでのWeb検索で調べた事柄の一覧です（見出しのみで、本文は含みません）。\n"
+        "関連する話題が出たときは、まず本文がローカルナレッジベースの資料として別途提示されていないか確認し、"
+        "あればそれを本文として使ってください。提示されていない場合は read_knowledge ツールで読み出せます。"
+        "いずれかで足りるならWeb検索をやり直す必要はありません:\n\n" + "\n".join(blocks)
     )

backend/app/core/memory_kb/memory.py

@@ -1,3 +1,5 @@
+from datetime import datetime, timezone
+
 from sqlalchemy.orm import Session as DBSession
 from app.db.models import Memory, Message, Session
 from app.core.config import MEMORY_SUMMARIZE_THRESHOLD
@@ -5,12 +7,19 @@ from app.core import llm
 from app.core.memory_kb import knowledge
 from app.core.memory_kb import local_knowledge
 from app.core.memory_kb.tagging import tag_memory
+from app.core import notes
 
 
 async def get_context_messages(db: DBSession, session_id: str) -> list[dict]:
     """蓄積知識・長期メモリ（要約）・短期メモリ（最近のメッセージ）を結合してコンテキストを返す。"""
     memories = db.query(Memory).filter(Memory.session_id == session_id).order_by(Memory.created_at).all()
-    messages = db.query(Message).filter(Message.session_id == session_id).order_by(Message.created_at).all()
+    # アーカイブ済み（要約に取り込まれた）メッセージは、その内容が長期メモリ側に入っているため除外する。
+    messages = (
+        db.query(Message)
+        .filter(Message.session_id == session_id, Message.archived_at.is_(None))
+        .order_by(Message.created_at)
+        .all()
+    )
 
     context: list[dict] = []
 
@@ -18,6 +27,11 @@ async def get_context_messages(db: DBSession, session_id: str) -> list[dict]:
     if knowledge_context:
         context.append({"role": "system", "content": knowledge_context})
 
+    # 共有ノートは「タイトル一覧」だけを常時見せ、本文は read_note ツールで読ませる
+    notes_context = notes.get_notes_context(db)
+    if notes_context:
+        context.append({"role": "system", "content": notes_context})
+
     if messages:
         latest_user_message = next((m.content for m in reversed(messages) if m.role == "user"), "")
         local_kb_context = await local_knowledge.get_local_kb_context(db, latest_user_message)
@@ -36,8 +50,18 @@ async def get_context_messages(db: DBSession, session_id: str) -> list[dict]:
 
 
 async def maybe_summarize(db: DBSession, session: Session) -> None:
-    """メッセージ数が閾値を超えたら古いメッセージを要約してMemoryに保存し、元メッセージを削除する。"""
-    messages = db.query(Message).filter(Message.session_id == session.id).order_by(Message.created_at).all()
+    """メッセージ数が閾値を超えたら古いメッセージを要約してMemoryに保存し、元メッセージをアーカイブする。
+
+    アーカイブしたメッセージはLLMに渡すコンテキストからは外れるが、人間が後から履歴を
+    確認できるようDBには残す（物理削除はしない）。閾値の判定もアーカイブ済みを除いた
+    件数で行うため、一度要約した分が再び対象になることはない。
+    """
+    messages = (
+        db.query(Message)
+        .filter(Message.session_id == session.id, Message.archived_at.is_(None))
+        .order_by(Message.created_at)
+        .all()
+    )
     if len(messages) < MEMORY_SUMMARIZE_THRESHOLD:
         return
 
@@ -54,8 +78,12 @@ async def maybe_summarize(db: DBSession, session: Session) -> None:
 
     memory = Memory(session_id=session.id, summary=summary_text)
     db.add(memory)
+    db.flush()  # どの要約に取り込まれたかをメッセージ側に持たせるためIDを確定させる
+
+    archived_at = datetime.now(timezone.utc)
     for msg in to_summarize:
-        db.delete(msg)
+        msg.archived_at = archived_at
+        msg.memory_id = memory.id
     db.commit()
     db.refresh(memory)
 

backend/app/core/memory_kb/tagging.py

@@ -185,10 +185,16 @@ async def backfill_tags(db: DBSession, model: str | None = None, limit: int | No
     単体スクリプト・APIエンドポイントの両方から呼べるようにここに切り出している。
     戻り値: タグ付けしたメッセージ数
     """
+    # アーカイブ済み（要約に取り込まれた）メッセージは対象外。話題選びには要約側のタグを使うため、
+    # 過去ログ全体にLLMを走らせる意味が薄い。
     query = (
         db.query(Message)
         .outerjoin(MessageTag, MessageTag.message_id == Message.id)
-        .filter(Message.role.in_(["user", "assistant"]), MessageTag.id.is_(None))
+        .filter(
+            Message.role.in_(["user", "assistant"]),
+            MessageTag.id.is_(None),
+            Message.archived_at.is_(None),
+        )
         .order_by(Message.created_at.asc())
     )
     if limit:

backend/app/core/notes.py

@@ -0,0 +1,240 @@
+"""ユーザーとAIが共同で編集する共有ノート。
+
+システムプロンプトにはページの「タイトル一覧」だけを注入し、本文はモデルが
+read_note ツールで必要なときだけ読み出す。書き込みは write_note ツールで行う。
+"""
+import logging
+import re
+
+from sqlalchemy.orm import Session as DBSession
+
+from app.core.config import NOTES_TOOL_CONTENT_LIMIT
+from app.db.models import NotePage
+
+logger = logging.getLogger(__name__)
+
+
+READ_NOTE_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "read_note",
+        "description": "共有ノートの特定ページの本文を読み出す。システムプロンプトに提示されたタイトル一覧の中から、"
+        "今の会話に関係しそうなページがあるときに使う。",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "title": {"type": "string", "description": "読み出すページのタイトル（タイトル一覧に載っているもの）"},
+            },
+            "required": ["title"],
+        },
+    },
+}
+
+WRITE_NOTE_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "write_note",
+        "description": "共有ノートのページに書き込む。ユーザーからノートへの記録・追記・整理を頼まれたときに使う。"
+        "存在しないタイトルを指定した場合は新しいページを作成する。"
+        "既存ページを replace で上書きすると元の内容は失われるので、追記でよい場合は必ず append を使うこと。",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "title": {"type": "string", "description": "書き込む対象のページタイトル"},
+                "content": {"type": "string", "description": "書き込む本文（Markdown可）"},
+                "mode": {
+                    "type": "string",
+                    "enum": ["append", "replace"],
+                    "description": "append=末尾に追記（既定） / replace=ページ全体を置き換え",
+                },
+            },
+            "required": ["title", "content"],
+        },
+    },
+}
+
+NOTE_TOOLS = [READ_NOTE_TOOL, WRITE_NOTE_TOOL]
+
+
+def _find_page(db: DBSession, title: str) -> NotePage | None:
+    """タイトルでページを探す。完全一致 → 大文字小文字・前後空白を無視した一致 の順に試す。"""
+    pages = db.query(NotePage).order_by(NotePage.position, NotePage.id).all()
+    for page in pages:
+        if page.title == title:
+            return page
+    normalized = title.strip().casefold()
+    for page in pages:
+        if page.title.strip().casefold() == normalized:
+            return page
+    return None
+
+
+def next_position(db: DBSession) -> int:
+    """新規ページを末尾に置くための position を返す。"""
+    last = db.query(NotePage).order_by(NotePage.position.desc()).first()
+    return (last.position + 1) if last else 0
+
+
+def set_section(db: DBSession, page_id: int, section: str | None) -> NotePage | None:
+    """ページの所属セクションを変更し、同じセクションのページ群の直後に連続配置し直す。
+
+    タブバーはposition順に描画され、隣接して同じsectionが続く区間を1つのグループとして
+    まとめて表示する（app.api.notes / フロントのグルーピング表示を参照）。そのため
+    セクションを変更したページは、常に同じセクションの最後のページの直後に移動する。
+    """
+    page = db.get(NotePage, page_id)
+    if not page:
+        return None
+
+    normalized = (section or "").strip() or None
+    ordered = [p for p in db.query(NotePage).order_by(NotePage.position, NotePage.id).all() if p.id != page_id]
+
+    if normalized is None:
+        insert_at = len(ordered)
+    else:
+        matching = [i for i, p in enumerate(ordered) if p.section == normalized]
+        insert_at = (matching[-1] + 1) if matching else len(ordered)
+
+    ordered.insert(insert_at, page)
+    page.section = normalized
+    for i, p in enumerate(ordered):
+        p.position = i
+    db.commit()
+    db.refresh(page)
+    return page
+
+
+def reorder(db: DBSession, page_id: int, section: str | None, order: list[int]) -> bool:
+    """タブのドラッグ&ドロップによる並べ替えを反映する。
+
+    order にはドラッグ後の全ページIDを新しい順序で渡す（フロント側で計算する）。
+    page_id のページには先に section を設定し、その後 order の順に position を振り直す。
+    こうすることで、別セクションのタブの前後にドロップした場合はそのセクションへの
+    移動を兼ね、同じセクション内でのドロップなら単純な並べ替えになる。
+
+    order が現在の全ページIDの集合と一致しない場合は何もせず False を返す。
+    """
+    pages = {p.id: p for p in db.query(NotePage).all()}
+    if page_id not in pages or set(order) != set(pages.keys()):
+        return False
+
+    pages[page_id].section = (section or "").strip() or None
+    for i, pid in enumerate(order):
+        pages[pid].position = i
+    db.commit()
+    return True
+
+
+def rename_section(db: DBSession, old_name: str, new_name: str | None) -> int:
+    """あるセクションに属する全ページのセクション名を一括で変更する。new_name が空ならグループ解除になる。
+
+    戻り値: 変更したページ数。
+    """
+    normalized_new = (new_name or "").strip() or None
+    pages = db.query(NotePage).filter(NotePage.section == old_name).order_by(NotePage.position, NotePage.id).all()
+    for page in pages:
+        page.section = normalized_new
+    db.commit()
+    return len(pages)
+
+
+def get_notes_context(db: DBSession) -> str | None:
+    """共有ノートのタイトル一覧をシステムプロンプト用のテキストとして返す。セクションごとに見出しを付ける。"""
+    pages = db.query(NotePage).order_by(NotePage.position, NotePage.id).all()
+
+    lines = [
+        "【共有ノート】",
+        "ユーザーとあなたが共同で編集できるノートです。以下のページがあります"
+        "（セクションはページをグループ化する見出しで、あれば併記します）。",
+        "",
+    ]
+    if pages:
+        current_section = "__unset__"  # どのページのsectionとも一致しない番兵
+        for page in pages:
+            if page.section != current_section:
+                current_section = page.section
+                if current_section:
+                    lines.append(f"## {current_section}")
+            preview = " ".join(page.content.split())[:40]
+            suffix = f" — {preview}…" if preview else " — (空)"
+            lines.append(f"- {page.title}{suffix}")
+    else:
+        lines.append("- (まだページがありません)")
+    lines += [
+        "",
+        "本文はここには含まれていません。内容が必要なときは read_note ツールで読み出してください。",
+        "ノートへの記録・追記を頼まれたときは write_note ツールで書き込んでください"
+        "（新しいタイトルを指定すればページが新規作成されます）。",
+        "ユーザーが明示的に頼んでいないのに勝手に書き込まないこと。",
+    ]
+    return "\n".join(lines)
+
+
+def read_note(db: DBSession, title: str) -> str:
+    """ページ本文をツール結果用のテキストとして返す。"""
+    page = _find_page(db, title)
+    if not page:
+        available = ", ".join(p.title for p in db.query(NotePage).order_by(NotePage.position, NotePage.id).all())
+        return f"「{title}」というページはありません。現在のページ: {available or '(なし)'}"
+    if not page.content.strip():
+        return f"ページ「{page.title}」は空です。"
+    content = page.content
+    if len(content) > NOTES_TOOL_CONTENT_LIMIT:
+        content = content[:NOTES_TOOL_CONTENT_LIMIT] + "\n…(以下省略)"
+    return f"ページ「{page.title}」の本文:\n\n{content}"
+
+
+_LIST_ITEM = re.compile(r"^\s*([-*+]|\d+[.)])\s")
+
+
+def _append(existing: str, addition: str) -> str:
+    """既存本文に追記する。箇条書き同士をつなぐ場合だけ空行を挟まない。"""
+    if not existing.strip():
+        return addition
+    body = existing.rstrip()
+    last_line = body.rsplit("\n", 1)[-1]
+    first_line = addition.lstrip("\n").split("\n", 1)[0]
+    separator = "\n" if _LIST_ITEM.match(last_line) and _LIST_ITEM.match(first_line) else "\n\n"
+    return f"{body}{separator}{addition}"
+
+
+def write_note(db: DBSession, title: str, content: str, mode: str = "append") -> str:
+    """ページに書き込む。存在しなければ新規作成する。"""
+    if not title.strip():
+        return "タイトルが空のため書き込めませんでした。"
+
+    page = _find_page(db, title)
+    if page is None:
+        page = NotePage(title=title.strip(), content=content, position=next_position(db))
+        db.add(page)
+        db.commit()
+        return f"新しいページ「{page.title}」を作成し、本文を書き込みました。"
+
+    if mode == "replace":
+        page.content = content
+        result = f"ページ「{page.title}」の内容を置き換えました。"
+    else:
+        page.content = _append(page.content, content)
+        result = f"ページ「{page.title}」に追記しました。"
+    db.commit()
+    return result
+
+
+def execute_note_tool(db: DBSession, name: str, args: dict) -> tuple[str, bool]:
+    """ノート系ツールを実行する。戻り値: (ツール結果テキスト, ノートを変更したか)。"""
+    try:
+        if name == "read_note":
+            return read_note(db, args.get("title", "")), False
+        if name == "write_note":
+            result = write_note(
+                db,
+                args.get("title", ""),
+                args.get("content", ""),
+                args.get("mode", "append"),
+            )
+            return result, True
+    except Exception as e:
+        db.rollback()
+        logger.exception("Note tool %s failed", name)
+        return f"ノート操作に失敗しました: {e}", False
+    return f"未知のツールです: {name}", False

backend/app/core/weather/weather_cache.py

@@ -1,5 +1,5 @@
 """直近で取得した「明日の天気」データをメモリ上にキャッシュする。"""
-from datetime import datetime
+from datetime import datetime, timezone
 
 _latest: dict | None = None
 
@@ -11,7 +11,8 @@ def set_latest(weather: str, pop: int | None, judgement: str, reason: str) -> No
         "pop": pop,
         "judgement": judgement,
         "reason": reason,
-        "fetched_at": datetime.now().isoformat(),
+        # オフセット付きで返す（フロントの new Date() がローカル時刻と誤解しないようにするため）
+        "fetched_at": datetime.now(timezone.utc).isoformat(),
     }
 
 

backend/app/db/database.py

@@ -1,4 +1,4 @@
-from sqlalchemy import create_engine
+from sqlalchemy import create_engine, text
 from sqlalchemy.orm import sessionmaker, DeclarativeBase
 from app.core.config import DATABASE_URL
 
@@ -18,6 +18,27 @@ def get_db():
         db.close()
 
 
+# 既存DBに後から追加されたカラム: (テーブル名, カラム名, 型)
+_ADDED_COLUMNS = [
+    ("note_pages", "section", "VARCHAR"),
+    ("knowledge_entries", "headline", "VARCHAR"),
+    ("messages", "archived_at", "DATETIME"),
+    ("messages", "memory_id", "INTEGER"),
+]
+
+
+def _add_missing_columns() -> None:
+    """マイグレーションフレームワークを使っていないため、既存DBに後から追加されたカラムを
+    ここで簡易的に補う。create_all() は既存テーブルへのカラム追加は行わないので必要。"""
+    with engine.connect() as conn:
+        for table, column, column_type in _ADDED_COLUMNS:
+            existing = {row[1] for row in conn.execute(text(f"PRAGMA table_info({table})"))}
+            if existing and column not in existing:
+                conn.execute(text(f"ALTER TABLE {table} ADD COLUMN {column} {column_type}"))
+                conn.commit()
+
+
 def init_db():
     from app.db import models  # noqa: F401
     Base.metadata.create_all(bind=engine)
+    _add_missing_columns()

backend/app/db/models.py

@@ -1,7 +1,8 @@
 from datetime import datetime, timezone
-from sqlalchemy import String, Text, DateTime, ForeignKey, Integer, Float
+from sqlalchemy import String, Text, ForeignKey, Integer, Float
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from app.db.database import Base
+from app.db.types import UtcDateTime
 
 
 class Session(Base):
@@ -10,8 +11,8 @@ class Session(Base):
     id: Mapped[str] = mapped_column(String, primary_key=True)
     title: Mapped[str] = mapped_column(String, default="New Chat")
     model: Mapped[str] = mapped_column(String, default="")
-    created_at: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc))
-    updated_at: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+    created_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
 
     messages: Mapped[list["Message"]] = relationship(back_populates="session", cascade="all, delete-orphan", order_by="Message.created_at")
     memories: Mapped[list["Memory"]] = relationship(back_populates="session", cascade="all, delete-orphan")
@@ -24,7 +25,14 @@ class Message(Base):
     session_id: Mapped[str] = mapped_column(ForeignKey("sessions.id", ondelete="CASCADE"))
     role: Mapped[str] = mapped_column(String)  # "user" | "assistant" | "system"
     content: Mapped[str] = mapped_column(Text)
-    created_at: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc))
+    # 要約されて長期メモリに移ったメッセージ。LLMに渡すコンテキストからは外れるが、
+    # 人間が後から履歴を確認できるようDBには残す（app.core.memory_kb.memory.maybe_summarize を参照）。
+    archived_at: Mapped[datetime | None] = mapped_column(UtcDateTime, nullable=True)
+    # どの要約に取り込まれたか。要約を削除してもメッセージ自体は残す（SET NULL）。
+    memory_id: Mapped[int | None] = mapped_column(
+        ForeignKey("memories.id", ondelete="SET NULL"), nullable=True,
+    )
 
     session: Mapped["Session"] = relationship(back_populates="messages")
     tags: Mapped[list["MessageTag"]] = relationship(back_populates="message", cascade="all, delete-orphan")
@@ -36,7 +44,7 @@ class MessageTag(Base):
     id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
     message_id: Mapped[int] = mapped_column(ForeignKey("messages.id", ondelete="CASCADE"))
     tag: Mapped[str] = mapped_column(String)
-    created_at: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc))
 
     message: Mapped["Message"] = relationship(back_populates="tags")
 
@@ -48,7 +56,7 @@ class Memory(Base):
     session_id: Mapped[str] = mapped_column(ForeignKey("sessions.id", ondelete="CASCADE"))
     summary: Mapped[str] = mapped_column(Text)
     embedding_json: Mapped[str | None] = mapped_column(Text, nullable=True)  # 将来のベクトル検索用
-    created_at: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc))
 
     session: Mapped["Session"] = relationship(back_populates="memories")
     tags: Mapped[list["MemoryTag"]] = relationship(back_populates="memory", cascade="all, delete-orphan")
@@ -60,7 +68,7 @@ class MemoryTag(Base):
     id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
     memory_id: Mapped[int] = mapped_column(ForeignKey("memories.id", ondelete="CASCADE"))
     tag: Mapped[str] = mapped_column(String)
-    created_at: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc))
 
     memory: Mapped["Memory"] = relationship(back_populates="tags")
 
@@ -72,7 +80,10 @@ class KnowledgeEntry(Base):
     id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
     query: Mapped[str] = mapped_column(String)
     summary: Mapped[str] = mapped_column(Text)
-    created_at: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc))
+    # システムプロンプトには本文ではなくこの一行要約だけを並べる（app.core.memory_kb.knowledge を参照）。
+    # このカラム追加より前に作られた行では None になるため、表示側で summary から導出する。
+    headline: Mapped[str | None] = mapped_column(String, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc))
 
     sources: Mapped[list["KnowledgeSource"]] = relationship(back_populates="entry", cascade="all, delete-orphan")
 
@@ -101,7 +112,24 @@ class LocalKnowledgeDoc(Base):
     title: Mapped[str] = mapped_column(String)
     content_hash: Mapped[str] = mapped_column(String)
     embedding_json: Mapped[str] = mapped_column(Text)
-    updated_at: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+    updated_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+
+
+class NotePage(Base):
+    """ユーザーとAIが共同で編集する共有ノートの1ページ。UIではタブとして表示する。
+
+    ページのタイトル一覧は毎回システムプロンプトに注入され、本文はモデルが
+    read_note ツールで読み出す（app.core.notes を参照）。
+    """
+    __tablename__ = "note_pages"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    title: Mapped[str] = mapped_column(String)
+    content: Mapped[str] = mapped_column(Text, default="")
+    position: Mapped[int] = mapped_column(Integer, default=0)  # タブの並び順（セクションでまとめる際、同じセクションのページは連続させる）
+    section: Mapped[str | None] = mapped_column(String, nullable=True)  # タブをグループ化するセクション名。未設定なら未分類
+    created_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
 
 
 class AppSetting(Base):
@@ -110,7 +138,7 @@ class AppSetting(Base):
 
     key: Mapped[str] = mapped_column(String, primary_key=True)
     value: Mapped[str] = mapped_column(Text)
-    updated_at: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+    updated_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
 
 
 class ModelPreset(Base):
@@ -120,7 +148,7 @@ class ModelPreset(Base):
     id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
     label: Mapped[str] = mapped_column(String)
     value: Mapped[str] = mapped_column(String, unique=True)
-    created_at: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc))
 
 
 class ApiLog(Base):
@@ -133,4 +161,4 @@ class ApiLog(Base):
     response_text: Mapped[str | None] = mapped_column(Text, nullable=True)
     error: Mapped[str | None] = mapped_column(Text, nullable=True)
     latency_ms: Mapped[float | None] = mapped_column(Float, nullable=True)
-    created_at: Mapped[datetime] = mapped_column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_at: Mapped[datetime] = mapped_column(UtcDateTime, default=lambda: datetime.now(timezone.utc))

backend/app/db/types.py

@@ -0,0 +1,38 @@
+"""タイムゾーンを保ったまま日時を扱うためのカラム型。"""
+from datetime import datetime, timezone
+
+from sqlalchemy import DateTime
+from sqlalchemy.types import TypeDecorator
+
+
+class UtcDateTime(TypeDecorator):
+    """常に UTC の aware な datetime として読み書きする DateTime。
+
+    SQLite の DATETIME は tzinfo を保存できず、`DateTime(timezone=True)` を指定しても
+    バインド時に黙って捨てられる（＝naive な値が返ってくる）。そのままだと API のレスポンスが
+    オフセット無しの ISO 文字列になり、フロントの `new Date()` がローカル時刻として
+    解釈してしまうため、この型で入口と出口を揃える。
+
+    - 書き込み: aware な値は UTC に変換し、naive な値は UTC とみなす。いずれも naive な UTC として格納する
+    - 読み出し: 格納値を UTC の aware な datetime として返す
+
+    格納フォーマットは素の DateTime と同じ（naive な UTC）なので、
+    既存DBのデータはそのまま正しく解釈でき、マイグレーションは不要。
+    """
+
+    impl = DateTime
+    cache_ok = True
+
+    def process_bind_param(self, value: datetime | None, dialect) -> datetime | None:
+        if value is None:
+            return None
+        if value.tzinfo is None:
+            return value
+        return value.astimezone(timezone.utc).replace(tzinfo=None)
+
+    def process_result_value(self, value: datetime | None, dialect) -> datetime | None:
+        if value is None:
+            return None
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value.astimezone(timezone.utc)

backend/app/main.py

@@ -5,7 +5,7 @@ from fastapi import Depends, FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
 from app.api import auth as auth_api
-from app.api import chat, logs, memory, system
+from app.api import chat, logs, memory, notes, system
 from app.api import models as models_api
 from app.api import settings as settings_api
 from app.core import settings_store
@@ -93,6 +93,7 @@ app.add_middleware(
 app.include_router(auth_api.router)
 app.include_router(chat.router, dependencies=[Depends(require_site_session)])
 app.include_router(memory.router, dependencies=[Depends(require_site_session)])
+app.include_router(notes.router, dependencies=[Depends(require_site_session)])
 app.include_router(logs.router, dependencies=[Depends(require_site_session)])
 app.include_router(system.router, dependencies=[Depends(require_site_session)])
 app.include_router(settings_api.router, dependencies=[Depends(require_site_session)])

docker-compose.yml

@@ -8,6 +8,10 @@ services:
     environment:
       # SQLite ファイルと知識ベースを永続ボリュームに置く（.env の値を上書き）
       DATABASE_URL: sqlite:////app/data/playchat.db
+      # コンテナのタイムゾーン。未設定だとUTCになり、天気通知のcron時刻・深夜スキップ判定・
+      # 「明日」の日付計算がすべて9時間ずれる。プロセス起動前に効かせる必要があるため
+      # .env ではなくここで指定する（後から os.environ に入れても libc には反映されない）。
+      TZ: Asia/Tokyo
     volumes:
       - backend_data:/app/data
       - backend_knowledge_base:/app/knowledge_base

docs/api.md

@@ -24,6 +24,7 @@ SSE でストリーミング応答を返す。
 |---|---|---|
 | `session_id` | セッション UUID | 新規セッション作成直後 |
 | `chunk` | テキスト断片 | LLM トークン生成ごと |
+| `notes_updated` | — | AI が共有ノートを書き換えた直後 |
 | `done` | — | 正常完了 |
 | `error` | エラーメッセージ | 例外発生時 |
 
@@ -47,13 +48,15 @@ SSE でストリーミング応答を返す。
 ---
 
 ### GET /chat/sessions/{session_id}/messages
-セッションのメッセージ一覧を `created_at` 昇順で返す。
+セッションのメッセージ一覧を `created_at` 昇順で返す。要約に取り込まれた（アーカイブ済みの）
+メッセージも含めて返し、`archived_at` で区別する。アーカイブ済みのものは LLM に渡す
+コンテキストには入らないが、履歴としては残っている。
 
 **レスポンス**
 ```json
 [
-  { "id": 1, "role": "user", "content": "...", "created_at": "..." },
-  { "id": 2, "role": "assistant", "content": "...", "created_at": "..." }
+  { "id": 1, "role": "user", "content": "...", "created_at": "...", "archived_at": "2026-08-20T04:00:00+00:00", "tags": [] },
+  { "id": 2, "role": "assistant", "content": "...", "created_at": "...", "archived_at": null, "tags": [] }
 ]
 ```
 
@@ -88,6 +91,100 @@ SSE でストリーミング応答を返す。
 
 ---
 
+## 共有ノート
+
+ユーザーと AI が共同編集するノート。ページのタイトル一覧は毎回システムプロンプトに注入され、
+本文は AI が `read_note` / `write_note` ツールで読み書きする。
+`section` を設定すると、同じセクション名のページはタブバー上で常に連続してグループ表示される。
+
+### GET /api/notes
+全ページを `position` 昇順で返す。同じ `section` のページは常に連続する（隣接＝同一グループとして扱われる）。
+
+**レスポンス**
+```json
+[
+  {
+    "id": 1,
+    "title": "買い物リスト",
+    "content": "- 牛乳
+- 卵",
+    "position": 0,
+    "section": "生活",
+    "updated_at": "2026-08-19T12:00:00"
+  }
+]
+```
+
+---
+
+### POST /api/notes
+ページを新規作成し、`201 Created` で作成したページを返す。
+`section` を指定すると、作成直後にそのセクションの末尾へ配置される（他ページの `position` も再採番される）。
+
+**リクエスト**
+```json
+{ "title": "新しいページ", "content": "", "section": null }
+```
+
+---
+
+### PATCH /api/notes/{page_id}
+ページのタイトル・本文・セクションを更新する。指定したフィールドだけが変更される。
+タイトルを空文字にしようとした場合は `400`、ページが存在しない場合は `404` を返す。
+
+`section` はリクエストボディに**キーとして含まれているかどうか**で判定する（`null` を明示的に送るとグループ解除）。
+セクションを変更すると、そのページは新しいセクションの末尾（該当ページが無ければ末尾）へ移動し、
+全ページの `position` が振り直される。
+
+**リクエスト**
+```json
+{ "content": "更新後の本文", "section": "生活" }
+```
+
+---
+
+### POST /api/notes/sections/rename
+`old_name` セクションに属する全ページを `new_name` セクションへ一括で付け替える。
+`new_name` を空文字/未指定にすると、そのセクションの全ページのグループを解除する。
+ページの並び順（`position`）は変更しない。
+
+**リクエスト**
+```json
+{ "old_name": "生活", "new_name": "生活雑貨" }
+```
+
+**レスポンス**
+```json
+{ "renamed": 2 }
+```
+
+---
+
+### POST /api/notes/reorder
+タブのドラッグ&ドロップによる並べ替えを反映する。`order` には**全ページID**をドラッグ後の
+新しい順序で渡す（サーバー側では計算しない。フロントが `store.pages` から算出する）。
+`page_id` のページには先に `section` を設定してから、`order` の順に `position` を振り直す。
+別セクションのタブの前後にドロップした場合は、そのセクションへの移動も兼ねる。
+
+`order` が現在の全ページIDの集合と一致しない場合は `400` を返す。
+
+**リクエスト**
+```json
+{ "page_id": 3, "section": "生活", "order": [1, 3, 2, 4] }
+```
+
+**レスポンス**
+```json
+{ "reordered": 4 }
+```
+
+---
+
+### DELETE /api/notes/{page_id}
+ページを削除。`204 No Content` を返す。
+
+---
+
 ## ログ
 
 ### GET /logs

docs/architecture.md

@@ -21,18 +21,35 @@
 ```
 backend/
 ├── app/
-│   ├── main.py          # FastAPI インスタンス、CORS、ルーター登録、DB初期化
+│   ├── main.py              # FastAPI インスタンス、CORS、ルーター登録、DB初期化、起動時シード
 │   ├── api/
-│   │   ├── chat.py      # チャット・セッション関連エンドポイント
-│   │   ├── memory.py    # 長期メモリ参照・削除
-│   │   └── logs.py      # API ログ参照・削除
+│   │   ├── chat.py          # チャット・セッション関連エンドポイント（SSE / export / import）
+│   │   ├── memory.py        # 長期メモリ参照・削除
+│   │   ├── notes.py         # 共有ノート CRUD
+│   │   ├── models.py        # モデルプリセット CRUD
+│   │   ├── settings.py      # GUI 設定画面（APIキー等）
+│   │   ├── system.py        # タグ backfill・ワードプール参照などの運用系
+│   │   ├── auth.py          # サイトログイン
+│   │   └── logs.py          # API ログ参照・削除
 │   ├── core/
-│   │   ├── config.py    # .env 読み込み・定数定義
-│   │   ├── llm.py       # LiteLLM ラッパー（ストリーミング・ログ記録）
-│   │   └── memory.py    # メモリ読み書きロジック（要約・コンテキスト生成）
+│   │   ├── config.py        # .env 読み込み・定数定義
+│   │   ├── llm.py           # LiteLLM ラッパー（ストリーミング・埋め込み・ツール解決・ログ記録）
+│   │   ├── notes.py         # 共有ノート（タイトル一覧の注入 / read_note・write_note ツール）
+│   │   ├── memory_kb/       # コンテキスト管理まわり一式
+│   │   │   ├── memory.py            # コンテキスト合成・要約（旧 core/memory.py）
+│   │   │   ├── knowledge.py         # Web検索で得た知識の蓄積・要約・再生成
+│   │   │   ├── local_knowledge.py   # ローカル Markdown KB の埋め込み・類似検索
+│   │   │   ├── tagging.py           # メッセージ・要約への自動タグ付け
+│   │   │   └── word_memory.py       # 形態素解析による単語プール（Discord Bot 用）
+│   │   ├── search/
+│   │   │   └── websearch.py         # Tavily による web_search ツール
+│   │   ├── discord/         # Discord Bot・定期通知
+│   │   ├── settings_store.py        # GUI 設定を os.environ へ反映
+│   │   └── auth.py / site_auth.py    # 設定画面パスワード・サイトログイン
 │   └── db/
-│       ├── database.py  # SQLite 接続・セッションファクトリ・テーブル自動作成
-│       └── models.py    # SQLAlchemy モデル定義
+│       ├── database.py      # SQLite 接続・セッションファクトリ・テーブル自動作成
+│       └── models.py        # SQLAlchemy モデル定義
+├── knowledge_base/          # ローカルナレッジベース（Markdown。web_search/ 配下は自動生成）
 └── pyproject.toml
 ```
 
@@ -42,27 +59,95 @@ backend/
 |---|---|---|
 | `sessions` | id (UUID), title, model, created_at, updated_at | チャットセッション |
 | `messages` | id, session_id, role, content, created_at | 会話メッセージ（短期メモリ） |
+| `message_tags` | id, message_id, tag, created_at | メッセージへの自動タグ |
 | `memories` | id, session_id, summary, embedding_json, created_at | 要約による長期メモリ |
+| `memory_tags` | id, memory_id, tag, created_at | 要約への自動タグ |
+| `knowledge_entries` | id, query, summary, created_at | Web 検索で得た知識（セッション横断） |
+| `knowledge_sources` | id, entry_id, title, url | 上記知識の出典 URL |
+| `local_knowledge_docs` | id, path, title, content_hash, embedding_json, updated_at | ローカル Markdown KB の埋め込みキャッシュ |
+| `note_pages` | id, title, content, position, section, created_at, updated_at | ユーザーと AI が共同編集する共有ノートのページ（`section` でタブをグループ化） |
+| `app_settings` | key, value, updated_at | GUI 設定画面から編集した接続情報 |
+| `model_presets` | id, label, value, created_at | モデル選択プルダウンの選択肢 |
 | `api_logs` | id, session_id, model, request_json, response_text, error, latency_ms, created_at | LLM API 呼び出しログ |
 
-### メモリ機構（`core/memory.py`）
+### コンテキスト管理（`core/memory_kb/`）
 
-1. **短期メモリ**: セッション内の全 `messages` をコンテキストとして送信
-2. **長期メモリ**: メッセージ数が `MEMORY_SUMMARIZE_THRESHOLD`（デフォルト 20）を超えると、古い半分を LLM で要約して `memories` に保存しメッセージを削除
-3. **コンテキスト合成**: `get_context_messages()` が `memories` の要約をシステムメッセージとして先頭に付加し、残存メッセージと結合して返す
+LLM に渡すコンテキストは `memory_kb/memory.py` の `get_context_messages()` が毎リクエスト組み立てる。
+以下の順に system メッセージを積み、最後に会話履歴を連結する。
+
+| # | 層 | 中身 | 実装 | 量の制御 |
+|---|---|---|---|---|
+| 1 | 蓄積知識 | 過去の Web 検索で得た `knowledge_entries` の**見出し一覧のみ**（本文・出典は含めない） | `knowledge.get_knowledge_context()` | 最新 `KNOWLEDGE_CONTEXT_LIMIT`（既定 15）件 |
+| 2 | 共有ノート | ページの**タイトル一覧＋本文先頭 40 文字**のみ | `notes.get_notes_context()` | 全ページ（本文は入れない） |
+| 3 | ローカル KB | `knowledge_base/**.md` から選ばれた**ファイル全文** | `local_knowledge.get_local_kb_context()` | 直近ユーザー発言との cos 類似度上位 `LOCAL_KB_TOP_K`（既定 3）件、かつ `LOCAL_KB_MIN_SCORE`（既定 0.75）以上 |
+| 4 | 長期メモリ | `memories` の要約を全件連結 | `memory.get_context_messages()` | 上限なし |
+| 5 | 短期メモリ | セッション内の `messages` 全件（要約済みで削除された分を除く） | 同上 | 上限なし（要約で間接的に制御） |
+
+層 3 のプロンプトは「Web 検索結果より優先度が高い」「これで答えられるなら検索するな」と明示しており、層 1 より優先される。
+
+#### 要約（長期メモリ化）
+
+`maybe_summarize()` がアシスタント応答の保存直後に走る。
+
+1. メッセージ数が `MEMORY_SUMMARIZE_THRESHOLD`（既定 20）以上になったら発火
+2. 古い側の半分（既定 10 件）を LLM で要約し `memories` に 1 行保存
+3. **要約した元メッセージは `archived_at` / `memory_id` を立ててアーカイブ**する（物理削除はしない）。LLM に渡すコンテキストからも、次回以降の要約対象からも外れるが、DB には残るため履歴表示・エクスポートからは読める
+4. 保存した要約に `tagging.tag_memory()` でタグを付ける
+
+#### ツール経由の遅延読み込み
+
+常時注入すると重い情報は、システムプロンプトに目次だけ置いてツールで取りに行かせる。
+`llm.resolve_tool_calls()` が本番のストリーミング生成の**前に**別途 LLM を呼んでツール呼び出しを解決する（最大 2 ラウンド）。
+
+- `read_note` / `write_note` … 共有ノート本文の読み書き（`db` を渡したときだけモデルに提示）
+- `read_knowledge` … 層 1 の見出し一覧に出ている知識の本文を読む（同上）。層 3 として本文が既に注入されていれば呼ぶ必要はない
+- `web_search` … Tavily 検索。結果は `knowledge.summarize_results()` で構造化要約にされ、
+  `knowledge_entries` と `knowledge_base/web_search/*.md` の両方に保存される。
+  → 次回以降の層 1・層 3 に自動的に効いてくる
+
+#### 自動タグ付け・ワードプール
+
+- `tagging.py` … 各メッセージに `asyncio.create_task()` でバックグラウンドにタグを 3 つ生成する。
+  コンテキスト注入には使わず、Discord 雑談 Bot の話題選び（`find_related_tag()`）に使う
+- `word_memory.py` … Janome で名詞を抽出し `deque(maxlen=200)` にプロセス内保持する。
+  **DB に永続化されず再起動で消える**（起動時に直近 200 件のメッセージから再シードされる）
+
+#### 設計上の注意点
+
+- トークン数ベースの制御は無く、すべて件数・文字数ベース。層 3（Markdown 全文 ×3）は会話が短くても
+  コンテキストを大きく押し上げる（層 1 は見出しのみなので件数を増やしても軽い）
+- ツールを使わない会話でも `resolve_tool_calls()` が必ず 1 回フルコンテキストを投げるため、**LLM 呼び出しは最低 2 回**になる
+- 層 4（長期メモリ）に上限が無く、長いセッションでは要約が積み上がる（要約の再要約はしない）
+- `get_local_kb_context()` が毎リクエストで `sync_local_kb()`（ディレクトリスキャン）と埋め込み API 呼び出しを 1 回行う
 
 ### LLM 呼び出し（`core/llm.py`）
 
-- `stream_chat()` / `complete()` が LiteLLM を薄くラップ
-- `_log_context` で呼び出しを囲み、成功・失敗どちらも `api_logs` テーブルに記録
+- `stream_chat()` / `complete()` / `embed()` が LiteLLM を薄くラップ
+- `resolve_tool_calls()` が `web_search` / `read_note` / `write_note` / `read_knowledge` を解決し、結果を組み込んだメッセージ列を返す
+- `_log_context` で呼び出しを囲み、成功・失敗どちらも `api_logs` テーブルに記録（`embed()` は対象外）
 - `DEBUG=true` で `litellm._turn_on_debug()` が有効になり詳細ログが出力される
 
+### 共有ノート（`core/notes.py` / `api/notes.py`）
+
+ユーザーと AI が共同編集するノート。`note_pages` の 1 行が UI の 1 タブに対応する。
+利用者向けの操作方法は `docs/notes-guide.md` を参照。
+
+- `get_notes_context()` が**タイトル一覧のみ**をシステムメッセージとして生成し、`get_context_messages()` が会話コンテキストに差し込む（本文は含めない）。セクションがあれば `## セクション名` の見出しでグループ化して提示する
+- 本文の読み書きはツール経由: `read_note`（本文取得）/ `write_note`（追記・置換・新規作成）
+- `llm.resolve_tool_calls()` が `web_search` と同じループでこれらを解決する。ノート系ツールは `db` を渡したときのみモデルに提示される
+- REST（`/api/notes`）はフロントのノートパネル用。GET 一覧 / POST 作成 / PATCH 更新 / DELETE 削除 / `POST /api/notes/sections/rename`（セクション名の一括変更）/ `POST /api/notes/reorder`（ドラッグ&ドロップの並べ替え）
+- **セクションによるグルーピング**: `note_pages.section` に名前を持たせ、同じセクションのページは常に `position` 上で連続させる。`notes.set_section()` がページのセクションを変更するたびに全ページを再採番し、同じセクションの末尾に挿入し直す（隣接＝同一グループという前提をタブ描画側・システムプロンプト側の両方が使っている）。`notes.rename_section()` は既に連続しているページ群のラベルだけを一括で書き換える
+- **ドラッグ&ドロップの並べ替え**: `notes.reorder()` は `set_section()` と違い、位置の計算をサーバー側ではなくフロント（`NotePanel.vue`）に任せる。フロントがドラッグ後の全ページIDの順序を計算し、`{ page_id, section, order }` として一括送信、サーバーは検証（`order` が現在の全ページID集合と一致するか）した上でそのまま `position` に反映する。ドロップ先タブの `section` を渡すことで、並べ替えと同時にセクション間移動も1リクエストで完結する
+- 既存 DB への追加カラムは Alembic 等の仕組みを使っておらず、`db/database.py` の `_add_missing_columns()` が起動時に `PRAGMA table_info` を見て `ALTER TABLE ... ADD COLUMN` を素朴に実行する（SQLite 専用の簡易マイグレーション）
+
 ### SSE ストリーミング（`api/chat.py`）
 
 `POST /chat/stream` は `StreamingResponse` で以下のイベントを順番に送出する:
 
 ```
 data: {"type":"session_id","value":"<uuid>"}   # 新規セッション時のみ
+data: {"type":"notes_updated"}                  # AIが共有ノートを更新した時のみ
+data: {"type":"sources","value":[{...}]}        # Web検索した時のみ（出典の title/url）
 data: {"type":"chunk","value":"テキスト断片"}   # 0回以上
 data: {"type":"done"}                           # 正常完了
 data: {"type":"error","value":"エラー内容"}     # 例外発生時

docs/features.md

@@ -0,0 +1,189 @@
+# 機能一覧
+
+このリポジトリにあるアプリ（PlayChat）が「何ができるか」を機能単位でまとめたもの。
+内部設計は [architecture.md](architecture.md)、エンドポイント仕様は [api.md](api.md)、
+Discord 連携は [discord-bot.md](discord-bot.md)、ノートの操作方法は [notes-guide.md](notes-guide.md)、
+デプロイ手順は [deploy-lightsail.md](deploy-lightsail.md) を参照。
+
+## これは何か
+
+個人用の LLM チャットアプリ。FastAPI（Python）＋ Vue 3（TypeScript）で、会話・記憶・ノートを
+すべて手元の SQLite に持つ。LLM は LiteLLM 経由なので OpenAI / Anthropic / Ollama / Amazon Bedrock を
+同じ画面のプルダウンで切り替えられる。単なるチャット UI ではなく、
+
+- 会話が長くなったら勝手に要約して長期記憶に落とす
+- 知らないことは自分で Web 検索して、その結果を次回以降も使える知識として溜める
+- ユーザーと AI が同じノートを共同編集する
+- Discord 側にも住んでいて、天気を知らせたり雑談に乗ったりする
+
+といった「動き続ける」部分を持つのが特徴。
+
+## 機能サマリ
+
+| # | 機能 | 概要 | 主な実装 |
+|---|---|---|---|
+| 1 | チャット（SSE ストリーミング） | 逐次表示・Markdown 描画・セッション管理 | `api/chat.py` / `ChatWindow.vue` |
+| 2 | セッションの書き出し / 取り込み | 会話を JSON でダウンロード・復元 | `api/chat.py` / `SessionList.vue` |
+| 3 | 5 層コンテキスト管理 | 蓄積知識・ノート・ローカル KB・長期／短期メモリを毎回合成 | `core/memory_kb/memory.py` |
+| 4 | 自動要約による長期記憶 | 一定件数を超えたら古い会話を要約して圧縮 | `memory_kb/memory.py` |
+| 5 | Web 検索と知識の蓄積 | Tavily で検索 →要約 → DB とローカル KB に保存 | `core/search/` / `memory_kb/knowledge.py` |
+| 6 | ローカル Markdown ナレッジベース | 話題に近いファイルを埋め込み類似度で選んで全文注入 | `memory_kb/local_knowledge.py` |
+| 7 | 共有ノート | タブ／セクション付きノートを人と AI の両方が編集 | `core/notes.py` / `NotePanel.vue` |
+| 8 | 自動タグ付け | 発言・要約にタグを 3 つ付与（話題選びに使う） | `memory_kb/tagging.py` |
+| 9 | ワードプール | 直近の名詞をインメモリに保持しタグクラウド表示 | `memory_kb/word_memory.py` / `WordPool.vue` |
+| 10 | Discord Bot | メンションに返信。天気・雑談キーワードに反応 | `core/discord/discord_bot.py` |
+| 11 | 定期通知 | 毎日の洗濯天気通知と、定期的な「どうでもいい豆知識」 | `core/discord/scheduler.py` |
+| 12 | 天気予報（気象庁 API） | 明日の天気・降水確率から洗濯指数を判定 | `core/weather/` / `Clock.vue` |
+| 13 | モデル切替とプリセット管理 | 選択肢を DB で管理し画面から追加・編集・削除 | `api/models.py` / `SettingsPanel.vue` |
+| 14 | GUI 設定画面 | API キー等を再起動なしで変更（許可リスト制・マスク表示） | `core/settings_store.py` |
+| 15 | API ログビューア | LLM 呼び出しの成功／失敗・レイテンシ・リクエスト全文 | `api/logs.py` / `LogViewer.vue` |
+| 16 | システムモニタ | CPU・メモリ・GPU 使用率を 10 秒ごとに表示 | `api/system.py` / `MemoryMonitor.vue` |
+| 17 | サイト認証 | 共有パスワード 1 つでサイト全体を保護 | `core/site_auth.py` / `LoginGate.vue` |
+| 18 | Docker 一式 | Caddy + nginx + FastAPI で HTTPS 公開 | `docker-compose.yml` / `Caddyfile` |
+
+---
+
+## 1. チャット
+
+- `POST /chat/stream` が SSE を返し、フロントは fetch + ReadableStream で受けて 1 文字ずつ描画する。
+  イベントは `session_id` / `chunk` / `sources` / `notes_updated` / `done` / `error` の 6 種。
+- アシスタントの発言は `marked` + `DOMPurify` で描画する。ストリーミング途中で閉じていないコードフェンスは
+  自動で補完してから描画するので、生成中でもレイアウトが崩れない。
+- セッションは左サイドバーの一覧から切り替え・削除できる。タイトルは最初の発言の先頭 40 文字。
+- Web 検索が走った応答には出典（`sources`）が、各メッセージには自動生成されたタグが添えて表示される。
+- 失敗時は赤いバブルとトースト通知の両方で知らせる。
+
+## 2. セッションの書き出し / 取り込み
+
+- `GET /chat/sessions/{id}/export` がセッションのメタ情報と全メッセージ（タグ込み）を JSON で返す。
+- `POST /chat/sessions/import` は同じ形式の JSON から**新しいセッションを作成**する（上書きではない）。
+  サイドバーの ⭱ ボタンからファイルを選ぶだけで取り込める。
+- 要約済み（アーカイブ済み）のメッセージも `archived_at` 付きでそのまま書き出され、取り込み時もアーカイブ状態を保つ。
+
+## 3. コンテキスト管理（5 層）
+
+毎リクエスト `get_context_messages()` が以下の順に system メッセージを積み、最後に会話履歴を連ねる。
+
+| 層 | 中身 | 量の制御 |
+|---|---|---|
+| 1 蓄積知識 | 過去の Web 検索結果の**見出し一覧のみ**（本文は `read_knowledge` で読む） | 最新 `KNOWLEDGE_CONTEXT_LIMIT`（既定 15）件 |
+| 2 共有ノート | ページのタイトル一覧＋本文先頭 40 文字 | 全ページ（本文は入れない） |
+| 3 ローカル KB | 選ばれた Markdown の**全文** | 類似度上位 `LOCAL_KB_TOP_K`（既定 3）件かつ `LOCAL_KB_MIN_SCORE`（既定 0.75）以上 |
+| 4 長期メモリ | 要約を全件連結 | 上限なし |
+| 5 短期メモリ | セッション内の全メッセージ | 上限なし（要約で間接的に制御） |
+
+重い情報（ノート本文・蓄積知識の本文・Web 検索）は目次だけを渡し、本体はツール（`read_note` / `write_note` / `read_knowledge` / `web_search`）で
+取りに行かせる遅延読み込み方式。`llm.resolve_tool_calls()` が本番生成の前に最大 2 ラウンドでこれを解決する。
+
+## 4. 自動要約による長期記憶
+
+- メッセージ数が `MEMORY_SUMMARIZE_THRESHOLD`（既定 20）を超えると、古い側の半分を LLM が要約して
+  `memories` に 1 行として保存する。
+- **要約した元メッセージはアーカイブされる**（物理削除はしない）。LLM に渡るコンテキストからは外れるが、チャット画面では薄く表示され、区切り線から先だけがモデルに渡ることが分かるようになっている。
+- 保存した要約にもタグが付き、Discord Bot の話題選びの材料になる。
+- 溜まった要約は `GET /memory/{session_id}` で確認、`DELETE /memory/{id}` で個別削除できる（API のみ。専用の画面は無い）。
+
+## 5. Web 検索と知識の蓄積
+
+- LLM が必要と判断したときだけ `web_search` ツールが走る（Tavily。`TAVILY_API_KEY` 未設定なら空振り）。
+- 結果は `SEARCH_SUMMARY_MODEL` で構造化要約にされ、**2 か所**に保存される。
+  - `knowledge_entries` / `knowledge_sources` テーブル → 次回以降、層 1 として全セッションに効く
+  - `knowledge_base/web_search/*.md` → 層 3 の類似度検索の対象になる
+- `POST /chat/knowledge/regenerate` で、既存の知識エントリを出典 URL から取り直して要約し直せる。
+
+## 6. ローカル Markdown ナレッジベース
+
+- `backend/knowledge_base/**.md` を置いておくだけで、話題が近いときに自動で全文が注入される。
+- 直近のユーザー発言との埋め込みコサイン類似度で選ぶ。埋め込みは `local_knowledge_docs` に
+  内容ハッシュ付きでキャッシュされ、ファイルが変わったときだけ取り直す。
+- プロンプト上は「Web 検索結果より優先。これで答えられるなら検索するな」と明示している。
+
+## 7. 共有ノート
+
+- 1 ページ＝1 タブ。作成・改名・削除・本文編集（入力が止まると自動保存）ができる。
+- **セクション**でページをグループ化でき、同じセクションのタブは常に隣り合って表示される。
+- タブは**ドラッグ&ドロップ**で並べ替えでき、他セクションのタブにドロップすればそのまま移動になる。
+- AI 側はタイトル一覧だけを常に見ており、`read_note` で本文を読み、`write_note` で追記／全置換／新規作成する。
+  AI が書き換えると SSE の `notes_updated` が飛び、開いているノートパネルが自動で最新化される。
+- 自分が編集中（未保存）のページは AI の更新で上書きされない。
+
+## 8-9. 自動タグ付けとワードプール
+
+- 各メッセージと各要約に、バックグラウンドでタグが最大 3 つ付く（応答ストリームはブロックしない）。
+  タグはコンテキストには注入せず、Discord Bot が「近い話題」を選ぶために使う。
+- `POST /api/system/tags/backfill` で、過去の未タグ分をまとめて処理できる。
+- ワードプールは Janome で抽出した名詞を `deque(maxlen=200)` にプロセス内保持するもの。
+  **DB に永続化されず再起動で消える**が、起動時に直近 200 件のメッセージから再シードされる。
+  サイドバーに出現回数に応じた大きさのタグクラウドとして表示される。
+
+## 10-11. Discord Bot と定期通知
+
+- Bot はメンションされたときだけ反応する。本文に天気系キーワード（天気・洗濯・雨など）が含まれれば
+  気象庁データを添えて回答し、雑談系キーワード（どうでもいい・暇など）なら発言からタグを起こして
+  関連する話題の豆知識を即座に投げ返す。
+- APScheduler による定期ジョブが 2 つ。
+  - **洗濯天気通知**: 毎日 `WEATHER_NOTIFY_HOUR` 時（既定 22 時）に、翌日の天気と洗濯指数を配信
+  - **どうでもいい豆知識**: `USELESS_TIPS_ENABLED=true` のときだけ登録され、`USELESS_TIPS_INTERVAL_HOURS`（既定 3 時間）ごとに実行。深夜 3 時台はスキップ
+- どちらも `POST /api/system/weather-notify/test` / `POST /api/system/useless-tip/test` で即時実行して確認できる。
+
+## 12. 天気予報
+
+- 気象庁の無料 JSON API から明日の予報を取り、天気文言と降水確率から洗濯指数を判定する
+  （雨雪なら室内干し、降水確率 30% 以下なら外干し OK、それ以上は室内干し推奨）。
+- 取得した最新データはメモリ上にキャッシュされ、画面右上の時計の横にも表示される（`GET /api/system/weather/latest`）。
+- 対象地域は `WEATHER_AREA_CODE`（既定 120000＝千葉県）と `WEATHER_AREA_KEYWORD`（既定「北西部」）で指定する。
+
+## 13-14. モデル選択と設定画面
+
+- モデルのプルダウンは `model_presets` テーブル由来で、初回起動時に既定の一覧がシードされる。
+  設定画面からラベル／モデル文字列を追加・編集・削除できる（重複は 400 で弾く）。
+- 設定画面では API キー類を**再起動なしで**変更できる。
+  - 変更できるのは許可リストにあるキーだけ（`OPENAI_API_KEY` / `ANTHROPIC_API_KEY` / AWS 系 /
+    `OLLAMA_API_BASE` / `TAVILY_API_KEY` / `LOCAL_KB_EMBEDDING_MODEL`）
+  - 値は末尾 4 文字だけを見せるマスク表示。空欄で保存すると「変更なし」扱い
+  - 保存すると `app_settings` テーブルに入り `os.environ` に反映される。削除すると `.env` 由来の起動時の値に戻る
+
+## 15-16. ログビューアとシステムモニタ
+
+- LLM 呼び出しは成功・失敗どちらも `api_logs` に記録される（モデル・リクエスト全文・応答・
+  レイテンシ・エラー）。ログパネルからセッション別／成功失敗別に絞り込み、個別削除ができる。
+- サイドバーの監視パネルは CPU 使用率・メモリ使用量を 10 秒ごとに更新する。
+  `pynvml` が使える環境なら GPU メモリも表示する（無ければその欄が出ないだけ）。
+
+## 17. 認証
+
+パスワードが 2 種類あり、役割が違う。
+
+| 変数 | 守る対象 | 方式 |
+|---|---|---|
+| `SITE_PASSWORD` | チャット含むサイト全体 | ログイン画面 → HMAC 署名付きセッション Cookie（既定 30 日） |
+| `SETTINGS_PASSWORD` | 設定画面と モデルプリセットの更新系のみ | HTTP Basic（リクエストごとに送る） |
+
+- どちらも未設定時の挙動が逆なので注意。`SITE_PASSWORD` 未設定＝**誰でも使える**、
+  `SETTINGS_PASSWORD` 未設定＝**設定画面は常に 403**（空パスワードでの突破を防ぐため）。
+- `SESSION_SECRET_KEY` を設定しないと起動ごとに鍵が作り直され、再起動のたびに全員ログインし直しになる。
+- ローカルの http 環境でログインが効かない場合のみ `SESSION_COOKIE_SECURE=false` にする。
+
+## 18. デプロイ
+
+- `docker-compose.yml` に backend（FastAPI）/ frontend（nginx で静的配信＋API リバースプロキシ）/
+  caddy（Let's Encrypt 自動取得と HTTPS 終端）の 3 コンテナが定義済み。
+- SQLite と `knowledge_base` は Docker ボリュームに永続化される。
+- フロントは API をすべて相対パスで呼ぶため、同一オリジン配信なら CORS 設定は実質不要。
+
+---
+
+## 制約・注意点
+
+このアプリを触るときに引っかかりやすい点。
+
+- **1 応答あたり LLM 呼び出しは最低 2 回**。ツールを使わない会話でも `resolve_tool_calls()` が
+  フルコンテキストを 1 回投げてから本番生成に入る。
+- **トークン数ベースの制御が一切ない**。すべて件数・文字数ベースなので、層 3（Markdown 全文 ×3）は
+  会話が短くてもコンテキストを大きく押し上げる（層 1 は見出しのみなので軽い）。
+- **長期メモリに上限がない**。長いセッションでは要約が積み上がり続ける（要約の再要約はしない）。
+- **要約自体は不可逆**。アーカイブされた元メッセージは残るが、要約をやり直したり元の状態に戻す手段は無い。
+- **ワードプールは揮発性**。再起動でリセットされ、直近 200 件から作り直される。
+- **DB マイグレーションは簡易実装**。Alembic は依存に入っているが使っておらず、起動時に
+  `PRAGMA table_info` を見て不足カラムを `ALTER TABLE` で足すだけ（SQLite 前提）。
+- **自動テストは無い**。`pytest` は dev 依存に入っているが `backend/tests/` は存在しない。

docs/notes-guide.md

@@ -0,0 +1,58 @@
+# 共有ノートの使い方
+
+ユーザーとAIが同じノートを一緒に編集できる機能。ページをタブで切り替え、関連するページ同士は
+セクションでグループ化できる。実装の詳細は `docs/architecture.md` の「共有ノート」節、
+API 仕様は `docs/api.md` の「共有ノート」節を参照。
+
+## 開き方
+
+画面右上ヘッダーの **「ノート」** ボタンをクリックすると、右側にノートパネルが開く。
+もう一度クリックすると閉じる。
+
+## ページの操作
+
+| 操作 | 方法 |
+|---|---|
+| ページを開く | タブをクリック |
+| ページを新規作成 | タブ列右端の **＋** をクリック（末尾に「新しいページ」が追加される） |
+| タイトルを変更 | タブを**ダブルクリック**すると入力欄になるので書き換えて Enter（または欄外をクリック） |
+| ページを削除 | タブ内の **×** をクリック（確認ダイアログあり） |
+| 本文を編集 | ページを開いた状態で下の編集エリアに直接入力 |
+
+本文は入力を止めてから少し待つと自動保存される。保存待ちの間はタブに **●**（未保存マーク）が付く。
+ページが1つも無い場合は「＋ 最初のページを作成」から始められる。
+
+## セクションでまとめる
+
+複数のページを1つのグループとしてタブ上にまとめられる。
+
+| 操作 | 方法 |
+|---|---|
+| ページをセクションに入れる | タブにマウスを乗せると出てくる **🏷** をクリックし、セクション名を入力 |
+| セクション名を変更する | セクションのラベル（タブ群の左上に表示される名前）をクリックし、新しい名前を入力 |
+| セクションを解除する | 🏷 またはセクションラベルをクリックした際、名前を**空欄**にして確定 |
+
+同じセクションに入れたページは、タブ列上で必ず隣り合って表示される
+（新しくセクションに追加したページは、そのセクションの末尾に自動的に移動する）。
+セクション名を変更すると、そのグループに属する全ページのラベルが一括で変わる。
+
+## タブをドラッグで動かす
+
+タブは**ドラッグ&ドロップ**でも操作できる（🏷 やセクションラベルのクリックと同等の結果になる）。
+
+| 操作 | 方法 |
+|---|---|
+| 同じグループ内で順番を変える | タブを掴んで、移動先のタブの左半分/右半分にドロップ（左=そのタブの前、右=後ろに入る） |
+| 別のセクションへ移動する | 移動先のセクション内のタブにドロップ（そのタブと同じセクションに入る） |
+| セクションから外す | 未分類のタブにドロップ、またはタブ列の一番右（＋ボタンの手前の細い枠）にドロップ |
+
+ドラッグ中はドロップ位置に青い線が表示される。タイトル編集中（ダブルクリックで入力欄になっている間）のタブはドラッグできない。
+
+## AIとの連携
+
+- 全ページの**タイトル一覧**は、会話のたびに自動でAIに渡される（セクションがあれば見出し付きで）。
+  ただし本文はここには含まれない。
+- AIは `read_note` ツールでページ本文を読み、`write_note` ツールで追記・置き換え・新規ページ作成ができる。
+  「ノートに書いておいて」「〇〇について記録して」のように頼むと、AIが該当ページを判断して書き込む。
+- AIがノートを書き換えると、開いているノートパネルは自動的に最新の内容へ更新される。
+- 自分が編集中（未保存）のページは、AIの更新で上書きされない。

frontend/package-lock.json

@@ -1130,18 +1130,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/detect-libc": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
-      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "optional": true,
-      "peer": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/dompurify": {
       "version": "3.4.7",
       "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.4.7.tgz",
@@ -1254,280 +1242,6 @@
         "he": "bin/he"
       }
     },
-    "node_modules/lightningcss": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
-      "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "detect-libc": "^2.0.3"
-      },
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      },
-      "optionalDependencies": {
-        "lightningcss-android-arm64": "1.32.0",
-        "lightningcss-darwin-arm64": "1.32.0",
-        "lightningcss-darwin-x64": "1.32.0",
-        "lightningcss-freebsd-x64": "1.32.0",
-        "lightningcss-linux-arm-gnueabihf": "1.32.0",
-        "lightningcss-linux-arm64-gnu": "1.32.0",
-        "lightningcss-linux-arm64-musl": "1.32.0",
-        "lightningcss-linux-x64-gnu": "1.32.0",
-        "lightningcss-linux-x64-musl": "1.32.0",
-        "lightningcss-win32-arm64-msvc": "1.32.0",
-        "lightningcss-win32-x64-msvc": "1.32.0"
-      }
-    },
-    "node_modules/lightningcss-android-arm64": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz",
-      "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-darwin-arm64": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz",
-      "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-darwin-x64": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz",
-      "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-freebsd-x64": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz",
-      "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-linux-arm-gnueabihf": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz",
-      "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-linux-arm64-gnu": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz",
-      "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-linux-arm64-musl": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz",
-      "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-linux-x64-gnu": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz",
-      "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-linux-x64-musl": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz",
-      "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-win32-arm64-msvc": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz",
-      "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-win32-x64-msvc": {
-      "version": "1.32.0",
-      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz",
-      "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "peer": true,
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
     "node_modules/magic-string": {
       "version": "0.30.21",
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",

frontend/src/App.vue

@@ -6,6 +6,7 @@ import MessageInput from './components/MessageInput.vue'
 import ModelSelector from './components/ModelSelector.vue'
 import LogViewer from './components/LogViewer.vue'
 import SettingsPanel from './components/SettingsPanel.vue'
+import NotePanel from './components/NotePanel.vue'
 import ToastList from './components/ToastList.vue'
 import MemoryMonitor from './components/MemoryMonitor.vue'
 import Clock from './components/Clock.vue'
@@ -15,7 +16,7 @@ import { useAuthStore } from './stores/auth'
 
 const authStore = useAuthStore()
 
-type SidePanel = 'none' | 'logs' | 'settings'
+type SidePanel = 'none' | 'logs' | 'settings' | 'notes'
 const activePanel = ref<SidePanel>('none')
 
 function togglePanel(panel: SidePanel) {
@@ -50,6 +51,9 @@ onUnmounted(() => {
           <span class="title">PlayChat</span>
           <ModelSelector />
           <Clock />
+          <button class="log-toggle" :class="{ active: activePanel === 'notes' }" @click="togglePanel('notes')">
+            ノート
+          </button>
           <button class="log-toggle" :class="{ active: activePanel === 'settings' }" @click="togglePanel('settings')">
             設定
           </button>
@@ -71,6 +75,9 @@ onUnmounted(() => {
           <div v-else-if="activePanel === 'settings'" class="log-pane">
             <SettingsPanel />
           </div>
+          <div v-else-if="activePanel === 'notes'" class="log-pane">
+            <NotePanel />
+          </div>
         </div>
       </div>
     </div>

frontend/src/api/client.ts

@@ -22,7 +22,7 @@ export interface Source {
 }
 
 export interface SSEChunk {
-  type: 'session_id' | 'chunk' | 'done' | 'error' | 'sources'
+  type: 'session_id' | 'chunk' | 'done' | 'error' | 'sources' | 'notes_updated'
   value?: string | Source[]
 }
 
@@ -51,6 +51,8 @@ export interface MessageRecord {
   role: 'user' | 'assistant' | 'system'
   content: string
   created_at: string
+  // 要約に取り込まれたメッセージ。モデルには渡らないが履歴としては残っている
+  archived_at: string | null
   tags: string[]
 }
 
@@ -63,6 +65,40 @@ export async function deleteSession(sessionId: string): Promise<void> {
   await fetch(`${BASE}/chat/sessions/${sessionId}`, { method: 'DELETE' })
 }
 
+export function exportSession(sessionId: string): void {
+  const a = document.createElement('a')
+  a.href = `${BASE}/chat/sessions/${sessionId}/export`
+  a.download = `session_${sessionId}.json`
+  document.body.appendChild(a)
+  a.click()
+  a.remove()
+}
+
+export interface ImportPayload {
+  session?: {
+    title?: string | null
+    model?: string | null
+    created_at?: string | null
+    updated_at?: string | null
+  }
+  messages: {
+    role: string
+    content: string
+    created_at?: string | null
+    archived_at?: string | null
+    tags?: string[]
+  }[]
+}
+
+export async function importSession(payload: ImportPayload): Promise<SessionInfo> {
+  const res = await fetch(`${BASE}/chat/sessions/import`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  })
+  return parseJson<SessionInfo>(res, 'インポート')
+}
+
 export async function fetchLogs(params: {
   session_id?: string
   status?: 'ok' | 'error'
@@ -224,3 +260,70 @@ export function streamChat(
 
   return () => controller.abort()
 }
+
+export interface NotePage {
+  id: number
+  title: string
+  content: string
+  position: number
+  section: string | null
+  updated_at: string
+}
+
+export async function fetchNotePages(): Promise<NotePage[]> {
+  const res = await fetch(`${BASE}/api/notes`)
+  return parseJson<NotePage[]>(res, 'ノート取得')
+}
+
+export async function createNotePage(title: string, section?: string | null): Promise<NotePage> {
+  const res = await fetch(`${BASE}/api/notes`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ title, section: section ?? null }),
+  })
+  return parseJson<NotePage>(res, 'ページ作成')
+}
+
+export async function updateNotePage(
+  pageId: number,
+  patch: { title?: string; content?: string; section?: string | null },
+): Promise<NotePage> {
+  const res = await fetch(`${BASE}/api/notes/${pageId}`, {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(patch),
+  })
+  return parseJson<NotePage>(res, 'ページ更新')
+}
+
+export async function deleteNotePage(pageId: number): Promise<void> {
+  await fetch(`${BASE}/api/notes/${pageId}`, { method: 'DELETE' })
+}
+
+/** section = old のページ全体を section = new へ一括で付け替える。new が空/nullならグループ解除。 */
+export async function renameNoteSection(oldName: string, newName: string | null): Promise<{ renamed: number }> {
+  const res = await fetch(`${BASE}/api/notes/sections/rename`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ old_name: oldName, new_name: newName }),
+  })
+  return parseJson<{ renamed: number }>(res, 'セクション名変更')
+}
+
+/**
+ * タブのドラッグ&ドロップによる並べ替えをサーバーへ反映する。
+ * order には全ページIDをドラッグ後の新しい順序で渡す。pageId のページは section へ移動する
+ * （ドロップ先のタブと同じセクションを渡せば、その場でセクション間の移動を兼ねる）。
+ */
+export async function reorderNotePages(
+  pageId: number,
+  section: string | null,
+  order: number[],
+): Promise<{ reordered: number }> {
+  const res = await fetch(`${BASE}/api/notes/reorder`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ page_id: pageId, section, order }),
+  })
+  return parseJson<{ reordered: number }>(res, 'ノート並べ替え')
+}

frontend/src/components/ChatWindow.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { ref, watch, nextTick } from 'vue'
+import { computed, ref, watch, nextTick } from 'vue'
 import { useChatStore } from '../stores/chat'
 import MarkdownContent from './MarkdownContent.vue'
 import type { Source } from '../api/client'
@@ -7,6 +7,14 @@ import type { Source } from '../api/client'
 const store = useChatStore()
 const scrollEl = ref<HTMLElement | null>(null)
 
+// 要約済みメッセージの最後の位置。ここに「ここから先がモデルに渡る」区切りを描く。
+const lastArchivedIndex = computed(() => {
+  for (let i = store.messages.length - 1; i >= 0; i--) {
+    if (store.messages[i].archived) return i
+  }
+  return -1
+})
+
 function uniqueSources(sources: Source[]): Source[] {
   const seen = new Set<string>()
   return sources.filter((s) => {
@@ -30,10 +38,10 @@ watch(
     <div v-if="store.messages.length === 0" class="empty">
       メッセージを送信してチャットを開始してください
     </div>
+    <template v-for="(msg, i) in store.messages" :key="i">
     <div
-      v-for="(msg, i) in store.messages"
-      :key="i"
-      :class="['message-wrap', msg.role]"
+      :class="['message-wrap', msg.role, { archived: msg.archived }]"
+      :title="msg.archived ? '要約済み: 内容は長期メモリに引き継がれ、この発言自体はモデルに渡りません' : undefined"
     >
       <div :class="['message', msg.role, { error: msg.error }]">
         <div class="bubble">
@@ -65,6 +73,10 @@ watch(
         >{{ src.title || src.url }}</a>
       </div>
     </div>
+    <div v-if="i === lastArchivedIndex" class="archive-divider">
+      <span>ここまでは要約済み — 履歴として残っていますが、モデルには要約だけが渡ります</span>
+    </div>
+    </template>
   </div>
 </template>
 
@@ -85,6 +97,23 @@ watch(
 .message-wrap { display: flex; flex-direction: column; gap: 4px; }
 .message-wrap.user { align-items: flex-end; }
 .message-wrap.assistant { align-items: flex-start; }
+/* 要約済み（モデルには渡らない）メッセージ。読めるが現役の発言と区別できる程度に落とす */
+.message-wrap.archived { opacity: 0.45; }
+.message-wrap.archived:hover { opacity: 0.75; }
+.archive-divider {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 4px 0;
+  color: #777;
+  font-size: 11px;
+}
+.archive-divider::before,
+.archive-divider::after {
+  content: '';
+  flex: 1;
+  border-top: 1px dashed #3a3a3a;
+}
 .message { display: flex; width: 100%; }
 .message.user { justify-content: flex-end; }
 .message.assistant { justify-content: flex-start; }

frontend/src/components/NotePanel.vue

@@ -0,0 +1,366 @@
+<script setup lang="ts">
+import { onMounted, onUnmounted, ref, nextTick, computed } from 'vue'
+import { useNotesStore } from '../stores/notes'
+import type { NotePage } from '../api/client'
+
+interface TabGroup {
+  section: string | null
+  pages: NotePage[]
+}
+
+const store = useNotesStore()
+const renamingId = ref<number | null>(null)
+// ref="renameInput" は入れ子の v-for の中にあるため、Vue 3 では単一要素ではなく配列になる
+const renameInput = ref<HTMLInputElement[]>([])
+
+/** ドラッグ中のページID */
+const draggingId = ref<number | null>(null)
+/** ドラッグ中に今どのタブの前/後にドロップされるかの表示用インジケータ */
+const dropTarget = ref<{ id: number; place: 'before' | 'after' } | null>(null)
+/** タブ列の末尾（＋ボタンの手前）にドロップしようとしているか */
+const dropAtEnd = ref(false)
+
+/** 隣接して同じsectionが続く区間を1グループとして表示する（並び順はサーバー側が保証） */
+const groups = computed<TabGroup[]>(() => {
+  const result: TabGroup[] = []
+  for (const page of store.pages) {
+    const last = result[result.length - 1]
+    if (last && last.section === page.section) {
+      last.pages.push(page)
+    } else {
+      result.push({ section: page.section, pages: [page] })
+    }
+  }
+  return result
+})
+
+async function startRename(id: number) {
+  renamingId.value = id
+  await nextTick()
+  renameInput.value[0]?.select()
+}
+
+function onTitleInput(id: number, e: Event) {
+  store.edit(id, { title: (e.target as HTMLInputElement).value })
+}
+
+function finishRename() {
+  renamingId.value = null
+  store.flush()
+}
+
+function onContentInput(e: Event) {
+  if (store.activeId === null) return
+  store.edit(store.activeId, { content: (e.target as HTMLTextAreaElement).value })
+}
+
+async function confirmRemove(id: number, title: string) {
+  if (!window.confirm(`ページ「${title}」を削除しますか？`)) return
+  await store.removePage(id)
+}
+
+async function assignSection(page: NotePage) {
+  const input = window.prompt('このページが属するセクション名（空にするとグループ解除）', page.section ?? '')
+  if (input === null) return
+  await store.setSection(page.id, input.trim())
+}
+
+async function renameSectionGroup(currentName: string) {
+  const input = window.prompt('セクション名を変更（空にするとグループを解除）', currentName)
+  if (input === null) return
+  await store.renameSection(currentName, input.trim())
+}
+
+function onDragStart(id: number, e: DragEvent) {
+  draggingId.value = id
+  e.dataTransfer?.setData('text/plain', String(id)) // Firefoxはdataが無いとドラッグを許可しない
+  if (e.dataTransfer) e.dataTransfer.effectAllowed = 'move'
+}
+
+function onDragEnd() {
+  draggingId.value = null
+  dropTarget.value = null
+  dropAtEnd.value = false
+}
+
+function onDragOverTab(page: NotePage, e: DragEvent) {
+  if (draggingId.value === null || draggingId.value === page.id) return
+  dropAtEnd.value = false
+  const rect = (e.currentTarget as HTMLElement).getBoundingClientRect()
+  const place: 'before' | 'after' = e.clientX - rect.left < rect.width / 2 ? 'before' : 'after'
+  dropTarget.value = { id: page.id, place }
+}
+
+function onDragOverEnd() {
+  if (draggingId.value === null) return
+  dropTarget.value = null
+  dropAtEnd.value = true
+}
+
+/** ドラッグ後の新しい並びを計算してサーバーへ送る。section にドロップ先タブの所属セクションを渡すと、並べ替えと同時にセクション間の移動も反映される。 */
+async function moveTab(id: number, targetId: number | null, place: 'before' | 'after', section: string | null) {
+  const order = store.pages.map((p) => p.id)
+  const fromIdx = order.indexOf(id)
+  if (fromIdx === -1) return
+  order.splice(fromIdx, 1)
+  const insertAt = targetId === null
+    ? order.length
+    : order.indexOf(targetId) + (place === 'after' ? 1 : 0)
+  order.splice(insertAt, 0, id)
+  await store.reorder(id, section, order)
+}
+
+async function onDropTab(page: NotePage, e: DragEvent) {
+  const id = draggingId.value
+  onDragEnd()
+  if (id === null || id === page.id) return
+  const rect = (e.currentTarget as HTMLElement).getBoundingClientRect()
+  const place: 'before' | 'after' = e.clientX - rect.left < rect.width / 2 ? 'before' : 'after'
+  await moveTab(id, page.id, place, page.section)
+}
+
+async function onDropEnd() {
+  const id = draggingId.value
+  onDragEnd()
+  if (id === null) return
+  await moveTab(id, null, 'after', null)
+}
+
+onMounted(() => {
+  store.load()
+})
+onUnmounted(() => {
+  store.flush()
+})
+</script>
+
+<template>
+  <div class="note-panel">
+    <div class="tabs">
+      <div
+        v-for="group in groups"
+        :key="`${group.section ?? '_'}-${group.pages[0].id}`"
+        class="tab-group"
+        :class="{ named: group.section }"
+      >
+        <button
+          v-if="group.section"
+          class="section-label"
+          :title="`「${group.section}」セクション。クリックで名前変更・解除`"
+          @click="renameSectionGroup(group.section)"
+        >{{ group.section }}</button>
+        <div
+          v-for="page in group.pages"
+          :key="page.id"
+          class="tab"
+          :class="{
+            active: page.id === store.activeId,
+            dragging: draggingId === page.id,
+            'drop-before': dropTarget?.id === page.id && dropTarget.place === 'before',
+            'drop-after': dropTarget?.id === page.id && dropTarget.place === 'after',
+          }"
+          :draggable="renamingId !== page.id"
+          @click="store.selectPage(page.id)"
+          @dblclick="startRename(page.id)"
+          @dragstart="onDragStart(page.id, $event)"
+          @dragend="onDragEnd"
+          @dragover.prevent="onDragOverTab(page, $event)"
+          @drop.prevent="onDropTab(page, $event)"
+        >
+          <input
+            v-if="renamingId === page.id"
+            ref="renameInput"
+            class="tab-rename"
+            :value="page.title"
+            @input="onTitleInput(page.id, $event)"
+            @blur="finishRename"
+            @keydown.enter="finishRename"
+            @keydown.esc="finishRename"
+            @click.stop
+          >
+          <template v-else>
+            <span class="tab-title" :title="page.title">{{ page.title }}</span>
+            <span v-if="store.dirtyIds.has(page.id)" class="dot" title="未保存">●</span>
+            <button class="tab-tag" title="セクションに割り当て" @click.stop="assignSection(page)">🏷</button>
+            <button class="tab-del" title="削除" @click.stop="confirmRemove(page.id, page.title)">×</button>
+          </template>
+        </div>
+      </div>
+      <div
+        v-if="draggingId !== null"
+        class="drop-end"
+        :class="{ active: dropAtEnd }"
+        @dragover.prevent="onDragOverEnd"
+        @drop.prevent="onDropEnd"
+      />
+      <button class="tab-add" title="ページを追加" @click="store.addPage()">＋</button>
+    </div>
+
+    <div v-if="store.error" class="error">⚠ {{ store.error }}</div>
+
+    <textarea
+      v-if="store.activePage"
+      class="editor"
+      :value="store.activePage.content"
+      placeholder="ここに書いた内容はAIと共有されます。AIも read_note / write_note でこのページを読み書きできます。"
+      spellcheck="false"
+      @input="onContentInput"
+      @blur="store.flush()"
+    />
+    <div v-else class="empty">
+      <p>ページがありません。</p>
+      <button class="create-btn" @click="store.addPage()">＋ 最初のページを作成</button>
+    </div>
+
+    <div class="hint">
+      ページのタイトル一覧はAIのシステムプロンプトに常に含まれます。本文はAIが必要に応じて読み出します。
+      🏷 でページをセクションにまとめられます（セクション名をクリックすると変更・解除）。
+      タブはドラッグで並べ替え・他のセクションへの移動ができます。
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.note-panel {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  background: #161616;
+}
+.tabs {
+  display: flex;
+  align-items: flex-end;
+  gap: 2px;
+  padding: 6px 6px 0;
+  overflow-x: auto;
+  flex-shrink: 0;
+  border-bottom: 1px solid #333;
+}
+.tab-group {
+  display: flex;
+  align-items: flex-end;
+  gap: 2px;
+}
+.tab-group.named {
+  background: #161d2e;
+  border: 1px solid #29314a;
+  border-bottom: none;
+  border-radius: 8px 8px 0 0;
+  padding: 3px 3px 0;
+  margin-right: 4px;
+}
+.section-label {
+  background: none;
+  border: none;
+  color: #7fa8e0;
+  font-size: 10px;
+  font-weight: 600;
+  cursor: pointer;
+  padding: 2px 5px 4px;
+  white-space: nowrap;
+  max-width: 90px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.section-label:hover { color: #a8c8f0; text-decoration: underline; }
+.tab {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 5px 8px;
+  background: #1f1f1f;
+  border: 1px solid #333;
+  border-bottom: none;
+  border-radius: 6px 6px 0 0;
+  font-size: 12px;
+  color: #aaa;
+  cursor: pointer;
+  white-space: nowrap;
+  max-width: 160px;
+}
+.tab.active { background: #2a2a2a; color: #fff; border-color: #444; }
+.tab.dragging { opacity: 0.4; }
+.tab.drop-before { box-shadow: inset 2px 0 0 #93c5fd; }
+.tab.drop-after { box-shadow: inset -2px 0 0 #93c5fd; }
+.drop-end {
+  align-self: stretch;
+  width: 14px;
+  flex-shrink: 0;
+  margin: 0 2px;
+  border-radius: 3px;
+}
+.drop-end.active { background: #93c5fd; opacity: 0.5; }
+.tab-title { overflow: hidden; text-overflow: ellipsis; }
+.dot { color: #eab308; font-size: 8px; }
+.tab-tag, .tab-del, .tab-add {
+  background: none;
+  border: none;
+  color: #666;
+  cursor: pointer;
+  font-size: 13px;
+  padding: 0 2px;
+  line-height: 1;
+}
+.tab-tag { font-size: 11px; opacity: 0; transition: opacity 0.15s; }
+.tab:hover .tab-tag, .tab.active .tab-tag { opacity: 0.8; }
+.tab-tag:hover { opacity: 1 !important; }
+.tab-del:hover, .tab-add:hover { color: #f87171; }
+.tab-add { color: #888; padding: 0 8px; align-self: center; }
+.tab-add:hover { color: #93c5fd; }
+.tab-rename {
+  background: #111;
+  border: 1px solid #2563eb;
+  border-radius: 3px;
+  color: #eee;
+  font-size: 12px;
+  padding: 1px 4px;
+  width: 110px;
+}
+.error {
+  padding: 6px 10px;
+  font-size: 11px;
+  color: #fca5a5;
+  background: #2a1414;
+  border-bottom: 1px solid #7f1d1d;
+}
+.editor {
+  flex: 1;
+  resize: none;
+  background: #161616;
+  color: #ddd;
+  border: none;
+  outline: none;
+  padding: 12px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 13px;
+  line-height: 1.6;
+}
+.editor::placeholder { color: #555; }
+.empty {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+  color: #666;
+  font-size: 13px;
+}
+.create-btn {
+  background: #2a2a2a;
+  color: #ccc;
+  border: 1px solid #444;
+  border-radius: 6px;
+  padding: 6px 14px;
+  font-size: 12px;
+  cursor: pointer;
+}
+.hint {
+  flex-shrink: 0;
+  padding: 8px 10px;
+  border-top: 1px solid #2a2a2a;
+  color: #666;
+  font-size: 10px;
+  line-height: 1.5;
+}
+</style>

frontend/src/components/SessionList.vue

@@ -4,6 +4,7 @@ import { useChatStore } from '../stores/chat'
 
 const store = useChatStore()
 const error = ref<string | null>(null)
+const importInput = ref<HTMLInputElement | null>(null)
 
 async function load() {
   error.value = null
@@ -14,6 +15,18 @@ async function load() {
   }
 }
 
+function triggerImport() {
+  importInput.value?.click()
+}
+
+async function onImportFileChange(e: Event) {
+  const input = e.target as HTMLInputElement
+  const file = input.files?.[0]
+  input.value = ''
+  if (!file) return
+  await store.importSessionFromFile(file)
+}
+
 onMounted(load)
 </script>
 
@@ -21,7 +34,17 @@ onMounted(load)
   <aside class="session-list">
     <div class="header">
       <span>チャット履歴</span>
-      <button class="new-btn" @click="store.selectSession(null)">+ 新規</button>
+      <div class="header-actions">
+        <button class="import-btn" title="JSONからインポート" @click="triggerImport">⭱</button>
+        <button class="new-btn" @click="store.selectSession(null)">+ 新規</button>
+      </div>
+      <input
+        ref="importInput"
+        type="file"
+        accept="application/json,.json"
+        class="hidden-file-input"
+        @change="onImportFileChange"
+      >
     </div>
     <div v-if="error" class="api-error" :title="error">⚠ 接続エラー</div>
     <ul>
@@ -32,6 +55,11 @@ onMounted(load)
         @click="store.selectSession(s.id)"
       >
         <span class="title">{{ s.title }}</span>
+        <button
+          class="export-btn"
+          @click.stop="store.downloadSessionLog(s.id)"
+          title="JSONでエクスポート"
+        >⭳</button>
         <button
           class="del-btn"
           @click.stop="store.removeSession(s.id)"
@@ -69,7 +97,13 @@ onMounted(load)
   border-bottom: 1px solid #7f1d1d;
   cursor: default;
 }
-.new-btn {
+.header-actions {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+.new-btn,
+.import-btn {
   background: #2a2a2a;
   color: #ccc;
   border: 1px solid #444;
@@ -78,6 +112,9 @@ onMounted(load)
   font-size: 12px;
   cursor: pointer;
 }
+.hidden-file-input {
+  display: none;
+}
 ul {
   list-style: none;
   margin: 0;
@@ -104,6 +141,7 @@ li.active { background: #333; }
   font-size: 13px;
   color: #ddd;
 }
+.export-btn,
 .del-btn {
   background: none;
   border: none;
@@ -114,5 +152,7 @@ li.active { background: #333; }
   opacity: 0;
   transition: opacity 0.15s;
 }
+.export-btn { font-size: 13px; }
+li:hover .export-btn,
 li:hover .del-btn { opacity: 1; }
 </style>

frontend/src/stores/chat.ts

@@ -1,12 +1,14 @@
 import { defineStore } from 'pinia'
+import { useNotesStore } from './notes'
 import { ref, computed } from 'vue'
-import { fetchSessions, fetchMessages, deleteSession, streamChat, type SessionInfo, type Source } from '../api/client'
+import { fetchSessions, fetchMessages, deleteSession, exportSession, importSession, streamChat, type SessionInfo, type Source, type ImportPayload } from '../api/client'
 
 export interface Message {
   role: 'user' | 'assistant'
   content: string
   pending?: boolean
   error?: boolean
+  archived?: boolean
   tags?: string[]
   sources?: Source[]
 }
@@ -54,7 +56,12 @@ export const useChatStore = defineStore('chat', () => {
       const records = await fetchMessages(sessionId)
       messages.value = records
         .filter((r) => r.role === 'user' || r.role === 'assistant')
-        .map((r) => ({ role: r.role as 'user' | 'assistant', content: r.content, tags: r.tags }))
+        .map((r) => ({
+          role: r.role as 'user' | 'assistant',
+          content: r.content,
+          tags: r.tags,
+          archived: r.archived_at !== null,
+        }))
     } catch (e) {
       pushToast(`メッセージ取得失敗: ${e instanceof Error ? e.message : e}`)
     }
@@ -69,6 +76,32 @@ export const useChatStore = defineStore('chat', () => {
     await loadSessions()
   }
 
+  function downloadSessionLog(sessionId: string): void {
+    exportSession(sessionId)
+  }
+
+  async function importSessionFromFile(file: File): Promise<void> {
+    let payload: ImportPayload
+    try {
+      const parsed = JSON.parse(await file.text())
+      if (!Array.isArray(parsed?.messages)) {
+        throw new Error('messages 配列が見つかりません')
+      }
+      payload = parsed as ImportPayload
+    } catch (e) {
+      pushToast(`インポート失敗: JSONの読み込みに失敗しました (${e instanceof Error ? e.message : e})`)
+      return
+    }
+    try {
+      const session = await importSession(payload)
+      await loadSessions()
+      await selectSession(session.id)
+      pushToast(`「${session.title}」をインポートしました`)
+    } catch (e) {
+      pushToast(`インポート失敗: ${e instanceof Error ? e.message : e}`)
+    }
+  }
+
   function sendMessage(text: string): void {
     if (isStreaming.value || !text.trim()) return
 
@@ -89,6 +122,9 @@ export const useChatStore = defineStore('chat', () => {
           messages.value[msgIdx].content += chunk.value as string
         } else if (chunk.type === 'sources' && chunk.value) {
           messages.value[msgIdx].sources = chunk.value as Source[]
+        } else if (chunk.type === 'notes_updated') {
+          // AIが共有ノートを書き換えたので、開いているノートパネルに反映する
+          useNotesStore().load().catch((e) => pushToast(`ノート更新失敗: ${e.message}`))
         } else if (chunk.type === 'done') {
           messages.value[msgIdx].pending = false
           isStreaming.value = false
@@ -137,6 +173,8 @@ export const useChatStore = defineStore('chat', () => {
     loadSessions,
     selectSession,
     removeSession,
+    downloadSessionLog,
+    importSessionFromFile,
     sendMessage,
     retryMessage,
   }

frontend/src/stores/notes.ts

@@ -0,0 +1,168 @@
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import {
+  fetchNotePages,
+  createNotePage,
+  updateNotePage,
+  deleteNotePage,
+  renameNoteSection,
+  reorderNotePages,
+  type NotePage,
+} from '../api/client'
+
+const SAVE_DEBOUNCE_MS = 800
+
+export const useNotesStore = defineStore('notes', () => {
+  const pages = ref<NotePage[]>([])
+  const activeId = ref<number | null>(null)
+  const error = ref<string | null>(null)
+  /** 未保存の編集があるページID。AIによる更新で上書きしないために使う。 */
+  const dirtyIds = ref<Set<number>>(new Set())
+
+  let saveTimer: number | null = null
+
+  const activePage = computed(() => pages.value.find((p) => p.id === activeId.value) ?? null)
+
+  async function load(): Promise<void> {
+    error.value = null
+    try {
+      const fetched = await fetchNotePages()
+      // 編集中のページはローカルの内容を優先し、サーバーの値で潰さない
+      pages.value = fetched.map((page) => {
+        if (!dirtyIds.value.has(page.id)) return page
+        const local = pages.value.find((p) => p.id === page.id)
+        return local ? { ...page, title: local.title, content: local.content } : page
+      })
+      if (activeId.value === null || !pages.value.some((p) => p.id === activeId.value)) {
+        activeId.value = pages.value[0]?.id ?? null
+      }
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'ノートの取得に失敗しました'
+    }
+  }
+
+  function selectPage(id: number): void {
+    flush()
+    activeId.value = id
+  }
+
+  async function addPage(title = '新しいページ', section: string | null = null): Promise<void> {
+    error.value = null
+    try {
+      const page = await createNotePage(title, section)
+      // サーバー側でセクションの並びに合わせて再配置されている可能性があるため一覧を取り直す
+      await load()
+      activeId.value = page.id
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'ページの作成に失敗しました'
+    }
+  }
+
+  /** ページの所属セクションを変更する。section が空/nullならグループ解除。並び順もサーバー側で調整されるため再取得する。 */
+  async function setSection(id: number, section: string | null): Promise<void> {
+    error.value = null
+    flush()
+    try {
+      await updateNotePage(id, { section })
+      await load()
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'セクションの変更に失敗しました'
+    }
+  }
+
+  /** oldName セクションに属する全ページを newName セクションへ一括で付け替える。newName が空ならグループ解除。 */
+  async function renameSection(oldName: string, newName: string | null): Promise<void> {
+    error.value = null
+    flush()
+    try {
+      await renameNoteSection(oldName, newName)
+      await load()
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'セクション名の変更に失敗しました'
+    }
+  }
+
+  /**
+   * タブのドラッグ&ドロップ用。order には全ページIDをドラッグ後の新しい順序で渡す。
+   * section にドロップ先タブの所属セクションを渡せば、並べ替えと同時にセクション間の移動も反映される。
+   */
+  async function reorder(pageId: number, section: string | null, order: number[]): Promise<void> {
+    error.value = null
+    flush()
+    try {
+      await reorderNotePages(pageId, section, order)
+      await load()
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : '並べ替えに失敗しました'
+    }
+  }
+
+  async function removePage(id: number): Promise<void> {
+    error.value = null
+    try {
+      await deleteNotePage(id)
+      dirtyIds.value.delete(id)
+      pages.value = pages.value.filter((p) => p.id !== id)
+      if (activeId.value === id) activeId.value = pages.value[0]?.id ?? null
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'ページの削除に失敗しました'
+    }
+  }
+
+  /** ローカルの内容を即座に更新し、少し待ってからサーバーへ保存する。 */
+  function edit(id: number, patch: { title?: string; content?: string }): void {
+    const page = pages.value.find((p) => p.id === id)
+    if (!page) return
+    Object.assign(page, patch)
+    dirtyIds.value.add(id)
+
+    if (saveTimer !== null) clearTimeout(saveTimer)
+    saveTimer = window.setTimeout(() => {
+      saveTimer = null
+      void save(id)
+    }, SAVE_DEBOUNCE_MS)
+  }
+
+  async function save(id: number): Promise<void> {
+    const page = pages.value.find((p) => p.id === id)
+    if (!page || !dirtyIds.value.has(id)) return
+    const { title, content } = page
+    try {
+      const saved = await updateNotePage(id, { title, content })
+      // 保存の往復中にさらに編集されていた場合は dirty のままにしておく
+      if (page.title === title && page.content === content) {
+        dirtyIds.value.delete(id)
+        page.updated_at = saved.updated_at
+      }
+      error.value = null
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'ノートの保存に失敗しました'
+    }
+  }
+
+  /** 保留中の保存を直ちに実行する（タブ切替・パネルを閉じる時など）。 */
+  function flush(): void {
+    if (saveTimer !== null) {
+      clearTimeout(saveTimer)
+      saveTimer = null
+    }
+    for (const id of [...dirtyIds.value]) void save(id)
+  }
+
+  return {
+    pages,
+    activeId,
+    activePage,
+    error,
+    dirtyIds,
+    load,
+    selectPage,
+    addPage,
+    removePage,
+    edit,
+    setSection,
+    renameSection,
+    reorder,
+    flush,
+  }
+})