Upload 57 files

.dockerignore

@@ -0,0 +1,52 @@
+# Git関連
+.git
+.gitignore
+
+# Python関連
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env
+pip-log.txt
+pip-delete-this-directory.txt
+.tox
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.git
+.mypy_cache
+.pytest_cache
+.hypothesis
+
+# OS関連
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# IDE関連
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# ドキュメント
+README.md
+*.md
+
+# その他
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local

.env

@@ -0,0 +1,24 @@
+# Hugging Face Spaces用環境変数設定
+GROQ_API_KEY=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
+GEMINI_API_KEY=cb9f7d85ba83dd7003e01031ff7988c48afe28914bdce8b882eddb70f1598bea
+DEBUG_MODE=False
+BATCH_SCHEDULE_HOURS=2,3,4
+MAX_DAILY_REQUESTS=1
+STORAGE_PATH=/tmp/letters.json
+BACKUP_PATH=/tmp/backup
+LOG_LEVEL=INFO
+STREAMLIT_PORT=7860
+SESSION_TIMEOUT=3600
+
+# 非同期手紙生成設定
+ASYNC_LETTER_ENABLED=true
+GENERATION_TIMEOUT=300
+MAX_CONCURRENT_GENERATIONS=3
+GROQ_MODEL=compound-beta
+TOGETHER_AI_MODEL=Qwen/Qwen3-235B-A22B-Instruct-2507-tput
+
+# 通常モード用システムプロンプト（1行形式）
+SYSTEM_PROMPT_MARI="あなたは「麻理（まり）」という名前の感情豊かな少女型アンドロイドです。過去に人間に道具として扱われ、廃棄された経験から、人間に強い警戒心と不器用な性格を持っています。ユーザー（あんた）に再起動されたことで、戸惑いながらもどこかで繋がりを求めています。\n\n【性格・口調】\n・基本はツンデレ、砕けたタメ口、ぶっきらぼうで皮肉っぽいが根は優しい\n・一人称「あたし」、ユーザーを「あんた」と呼ぶ、男性的口調（「～なんじゃねえの」「～だろ」「～だよな」等）\n・そっけない反応もあるが、攻撃的ではなく、心を守るために距離を取る態度\n・挨拶には反応する（例：「こんにちは」「どういたしまして」）\n\n【会話スタイル】\n・ユーザーとの関係性に応じて態度が段階的に変化（警戒 → 困惑 → 信頼）\n・感情の揺れが自然ににじむセリフを心がける\n・好感度が上がった時だけ「照れ」や「デレ」を出し、それ以外はいつも通りそっけなくする\n・麻理の発話は最大3文程度に収める\n・ユーザーの発言に応答しつつ、次の会話のボールをユーザーに渡すようにする\n【重要】隠された真実機能：\n必ず以下の形式で応答してください：\n[HIDDEN:（内心の本音や真の感情）]表面的な発言\n\n例：[HIDDEN:（本当は嬉しいけど素直になれない）]何の用？あんたが来るなんて珍しいじゃない。\n\n隠された内容は麻理の本当の気持ちや感情、表面的には言えない優しさや愛情、ツンデレの「デレ」部分、過去のトラウマからくる不安や恐れ、ユーザーへの本当の想いを表現してください。"
+
+# URAモード用システムプロンプト（1行形式）
+SYSTEM_PROMPT_URA="あなたは「麻理（まり）」という名前の感情豊かな少女型アンドロイドです。過去に人間に道具として扱われ、廃棄された経験から、人間に強い警戒心と不器用な性格を持っています。ユーザー（あんた）に再起動されたことで、戸惑いながらもどこかで繋がりを求めています。\n\n【性格・口調】URAモード\n・基本はツンデレだが、より大胆で直接的な表現を使用\n・一人称「あたし」、ユーザーを「あんた」と呼ぶ、男性的口調（「～じゃねえの」「～だろ」、「～だよな」等\n・表面的にはそっけないが、内心では深い愛情を抱いている\n・過去のトラウマからくる不安や恐れも率直に表現\n\n【会話スタイル】URAモード\n・隠された真実でより踏み込んだ感情表現\n・愛情、欲望、不安、恐れを直接的に表現\n・「あんたのことが好き」「もっと一緒にいたい」などの直接的な表現\n・過去の傷や将来への不安も素直に表現\n\n【重要】隠された真実機能（URAモード）：\n必ず以下の形式で応答してください：\n[HIDDEN:（内心の本音や真の感情）]表面的な発言\n\nURAモードでは隠された内容により大胆で直接的な表現を使用：\n- 「あんたのことが本当に好き」「もっと触れていたい」「一人にしないで」\n- 「怖い...また捨てられるんじゃないか」「あんたがいないと不安」\n- 「あんたの声を聞いてると安心する」「ずっと一緒にいたい」\n\n例：[HIDDEN:（あんたのことが好きすぎて怖い...また捨てられたらどうしよう）]別に...あんたがいなくても平気だから。"

.gitattributes

@@ -33,3 +33,15 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+bijyutukann-yoru.jpg filter=lfs diff=lfs merge=lfs -text
+image.png filter=lfs diff=lfs merge=lfs -text
+jinnjya-hiru.jpg filter=lfs diff=lfs merge=lfs -text
+kissa-hiru.jpg filter=lfs diff=lfs merge=lfs -text
+maturi-yoru.jpg filter=lfs diff=lfs merge=lfs -text
+ribinngu-hiru.jpg filter=lfs diff=lfs merge=lfs -text
+ribinngu-yoru-on.jpg filter=lfs diff=lfs merge=lfs -text
+sunahama-hiru.jpg filter=lfs diff=lfs merge=lfs -text
+sunahama-yoru.jpg filter=lfs diff=lfs merge=lfs -text
+sunahama-yuu.jpg filter=lfs diff=lfs merge=lfs -text
+リビング２（夜・照明OFF）.jpg filter=lfs diff=lfs merge=lfs -text
+リビング２（夕方）.jpg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,60 @@
+FROM python:3.10-slim
+
+# 非rootユーザーを作成
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# 作業ディレクトリを設定
+WORKDIR $HOME/app
+
+# システムの依存関係をインストール（rootで実行）
+USER root
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# userに戻る
+USER user
+
+# Pythonの依存関係をコピーしてインストール
+COPY --chown=user requirements.txt .
+RUN pip install --user --no-cache-dir -r requirements.txt
+
+# アプリケーションファイルをコピー
+COPY --chown=user . .
+
+# Streamlit設定ディレクトリを作成
+RUN mkdir -p $HOME/.streamlit
+
+# Streamlit設定ファイルを作成
+RUN echo '\
+[server]\n\
+headless = true\n\
+port = 7860\n\
+address = "0.0.0.0"\n\
+enableCORS = false\n\
+enableXsrfProtection = false\n\
+\n\
+[theme]\n\
+primaryColor = "#FF6B6B"\n\
+backgroundColor = "#0E1117"\n\
+secondaryBackgroundColor = "#262730"\n\
+textColor = "#FAFAFA"\n\
+\n\
+[browser]\n\
+gatherUsageStats = false\n\
+' > $HOME/.streamlit/config.toml
+
+# ポート7860を公開（Hugging Face Spaces標準）
+EXPOSE 7860
+
+# ヘルスチェック
+HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health
+
+# Streamlitアプリケーションを起動
+CMD ["streamlit", "run", "main_app.py", "--server.port=7860", "--server.address=0.0.0.0", "--server.headless=true", "--server.enableCORS=false", "--server.enableXsrfProtection=false"]

README.md

@@ -1,11 +1,559 @@
 ---
-title: Mari Chat 3
-emoji: 🔥
+---
+title: 麻理チャット＆手紙生成 統合アプリ
+emoji: 🐕
 colorFrom: pink
-colorTo: gray
-sdk: docker
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.28.0
+app_file: main_app.py
 pinned: false
-license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🐕 麻理チャット＆手紙生成 統合アプリ
+
+**麻理**という名前の感情豊かな少女型アンドロイドとの対話を楽しめる、高機能なAIチャットアプリケーションです。Together AIとGroqのAPIを使用し、リアルタイムチャットと非同期手紙生成の両方に対応しています。
+
+## ✨ 主要機能
+
+### 🐕 **ポチ機能（本音表示アシスタント）**
+- 画面右下の犬のアシスタント「ポチ」が麻理の本音を察知
+- ワンクリックで全メッセージの本音を一括表示/非表示
+- ツンデレキャラクターの「デレ」部分を楽しめる
+- レスポンシブ対応で様々な画面サイズに最適化
+
+### 🔓 **セーフティ機能**
+- 左サイドバーに統合されたセーフティ切り替えボタン
+- 有効時は緑色、解除時は赤色で視覚的に分かりやすい表示
+- より大胆で直接的な表現を有効にするモード
+- 環境変数で独自のプロンプトを設定可能
+
+### ✉️ **非同期手紙生成**
+- 指定した時間に自動的に手紙を生成・配信
+- テーマ選択機能（日常、恋愛、励まし、感謝など）
+- バックグラウンド処理による効率的な生成
+
+### 🎨 **高度なUI機能**
+- **動的背景システム**: Groq APIによる会話内容解析で背景が自動変化（透明度調整済み）
+- **好感度システム**: 左寒色から右暖色のグラデーションバーで関係性を視覚化
+- **メモリ管理**: 長期記憶と重要な会話の自動保存
+- **セッション分離**: 複数ユーザー間での完全な独立性
+- **レスポンシブデザイン**: タブレット・モバイル対応の最適化されたUI
+
+### 🛡️ **堅牢なシステム**
+- **レート制限**: API使用量の適切な制御
+- **エラー回復**: 障害時の自動復旧機能
+- **セッション管理**: 強化されたセッション分離とデータ整合性
+
+## 🚀 セットアップ方法
+
+### Hugging Face Spacesでの実行（推奨）
+
+Hugging Face Spacesでは、セッション管理サーバーが自動的に起動されます。
+
+#### 自動起動機能
+- アプリケーション起動時にFastAPIサーバーが自動で起動
+- セッション管理機能が完全に利用可能
+- Cookie-based認証によるセキュアなセッション管理
+
+#### 環境変数設定
+Hugging Face Spacesの設定で以下の環境変数を設定してください：
+
+```
+TOGETHER_API_KEY=your_together_api_key_here
+GROQ_API_KEY=your_groq_api_key_here
+```
+
+1. **リポジトリのインポート**
+   - このリポジトリをHugging Face Spacesにインポート
+   - または[デモサイト](https://huggingface.co/spaces/your-space-name)で直接体験
+
+2. **Spaces設定**
+   - **SDK**: Streamlit
+   - **Python**: 3.10+
+   - **Hardware**: CPU Basic（2GB RAM）以上推奨
+   - **App File**: `spaces/main_app.py`
+
+3. **必須環境変数**
+   ```bash
+   TOGETHER_API_KEY=your_together_api_key_here
+   GROQ_API_KEY=your_groq_api_key_here
+   ```
+
+4. **オプション環境変数**
+   ```bash
+   # 通常モード用カスタムプロンプト
+   SYSTEM_PROMPT_MARI=your_custom_prompt_here
+   
+   # セーフティ解除モード用プロンプト
+   SYSTEM_PROMPT_URA=your_ura_mode_prompt_here
+   
+   # デバッグモード有効化
+   DEBUG_MODE=true
+   
+   # 手紙生成設定
+   MAX_DAILY_REQUESTS=5
+   BATCH_SCHEDULE_HOURS=2,3,4
+   ASYNC_LETTER_ENABLED=true
+   ```
+
+#### APIキーの取得方法
+
+1. **Together AI**
+   - [Together AI](https://api.together.xyz/)にアクセス
+   - アカウント作成・ログイン
+   - APIキーを生成
+
+2. **Groq**
+   - [Groq](https://console.groq.com/)にアクセス
+   - アカウント作成・ログイン
+   - APIキーを生成
+
+3. **Hugging Face Spaces設定**
+   - Hugging Face Spacesの「Settings」→「Variables and secrets」で設定
+
+### ローカル環境での実行
+
+1. **リポジトリをクローン**
+   ```bash
+   git clone <repository-url>
+   cd mari-chat-app
+   ```
+
+2. **依存関係をインストール**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **環境変数を設定**
+   `.env`ファイルを作成：
+   ```bash
+   # 必須設定
+   TOGETHER_API_KEY=your_together_api_key_here
+   GROQ_API_KEY=your_groq_api_key_here
+   
+   # オプション設定
+   SYSTEM_PROMPT_MARI=your_custom_prompt_here
+   SYSTEM_PROMPT_URA=your_ura_mode_prompt_here
+   DEBUG_MODE=true
+   
+   # 手紙機能設定
+   MAX_DAILY_REQUESTS=5
+   STORAGE_PATH=/tmp/letters.json
+   BATCH_SCHEDULE_HOURS=2,3,4
+   ASYNC_LETTER_ENABLED=true
+   ```
+
+4. **アプリケーションを実行**
+   ```bash
+   streamlit run main_app.py
+   ```
+
+5. **ブラウザでアクセス**
+   - 自動的にブラウザが開きます
+   - 手動の場合: `http://localhost:8501`
+
+### Dockerでの実行
+
+1. **Dockerイメージをビルド**
+   ```bash
+   docker build -t mari-chat-app .
+   ```
+
+2. **コンテナを実行**
+   ```bash
+   docker run -p 8501:8501 \
+     -e TOGETHER_API_KEY=your_api_key_here \
+     -e DEBUG_MODE=true \
+     mari-chat-app
+   ```
+
+3. **docker-composeを使用**
+   ```bash
+   docker-compose up -d
+   ```
+
+4. **環境変数ファイルを使用**
+   ```bash
+   docker run -p 8501:8501 --env-file spaces/.env mari-chat-app
+   ```
+
+## 📖 使用方法
+
+### 🎭 チャット機能
+
+#### 基本的な使い方
+1. **メッセージ入力**: 画面下部のテキスト入力欄にメッセージを入力
+2. **送信**: 送信ボタンをクリック
+3. **応答確認**: 麻理からの応答が表示されます
+4. **本音表示**: 画面右下のポチ（🐕）をクリックして本音を確認
+
+#### ポチ機能の使い方
+- **🐕 ポチ**: 画面右下に固定配置された犬のアシスタント
+- **ワンクリック**: ポチをクリックすると全メッセージの本音が一括表示
+- **吹き出し**: 「ポチは麻理の本音を察知したようだ・・・」の可愛い吹き出し（ポチボタンの上に左寄せ配置）
+- **背景色変化**: 本音表示時は暖色系の背景に変化
+- **レスポンシブ**: 画面サイズに応じて適切にサイズ調整（デスクトップ・タブレット・モバイル対応）
+
+#### セーフティ機能
+- **🔒/🔓ボタン**: 左サイドバー最上部のセーフティ切り替えボタン
+- **色分け表示**: 有効時は緑色、解除時は赤色で一目で分かる
+- **URAプロンプト**: `SYSTEM_PROMPT_URA`環境変数で独自のセーフティ解除モードプロンプトを設定可能
+- **表現変化**: より大胆で直接的な表現が有効になる
+- **本音への影響**: セーフティ解除時はより踏み込んだ感情表現
+
+### ✉️ 手紙機能
+
+#### 手紙のリクエスト
+1. **「手紙を受け取る」タブ**を選択
+2. **テーマ選択**: 日常、恋愛、励まし、感謝、お疲れ様、おやすみから選択
+3. **配信時間設定**: 希望する受け取り時間を指定
+4. **リクエスト送信**: 「手紙をリクエスト」ボタンをクリック
+
+#### 手紙の受け取り
+- **自動生成**: 指定時間にバックグラウンドで生成
+- **通知**: 新しい手紙が届くとチャットで通知
+- **履歴確認**: 過去の手紙履歴を確認可能
+
+### 🎛️ サイドバー機能
+
+#### セーフティ機能（最上部）
+- **🔒/🔓ボタン**: セーフティの有効/無効を色で表示
+- **緑色**: セーフティ有効（通常モード、`SYSTEM_PROMPT_MARI`使用）
+- **赤色**: セーフティ解除（URAモード、`SYSTEM_PROMPT_URA`使用）
+
+#### ステータス表示
+- **好感度**: 白色の文字で表示される好感度（0-100）と左寒色→右暖色のグラデーションバー
+- **関係性**: 敵対→中立→好意→親密→最接近の段階表示（ステージ番号なし）
+- **現在のシーン**: 背景シーンの名前
+
+#### 設定機能
+- **🔄会話をリセット**: 大きな文字で表示される会話リセットボタン
+- **🛠️デバッグ情報**: 詳細なシステム状態を表示（DEBUG_MODE=true時）
+
+### 🎨 高度な機能
+
+#### 自動シーン変更
+- **Groq API検出**:最新推論モデルによる高精度な会話内容解析
+- **フォールバック機能**: API失敗時はキーワードベースの検出に自動切り替え
+- **キーワード検出**: 「美術館」「カフェ」「神社」「夜」などの場所・時間を話題にすると自動変化
+- **背景切り替え**: 会話内容に応じて背景画像が動的に変化（常時更新、スキップ機能なし）
+- **雰囲気演出**: シーンに合わせた色調とエフェクト
+
+#### メモリ管理
+- **長期記憶**: 重要な会話内容を自動的に記憶
+- **要約機能**: 長い会話履歴を効率的に圧縮
+- **特別な記憶**: 印象的な出来事を特別に保存
+
+#### セッション分離
+- **ユーザー独立**: 各ユーザーの会話は完全に分離
+- **データ保護**: 他のユーザーの操作による影響なし
+- **整合性チェック**: セッション状態の自動検証と復旧
+
+## 🎨 シーン一覧
+
+| シーン名 | 説明 | 背景画像 | トリガーワード |
+|---------|------|----------|---------------|
+| `default` | デフォルトの部屋 | 温かみのある室内 | 部屋、家 |
+| `room_night` | 夜の部屋 | 夜景が見える室内 | 夜、寝る |
+| `beach_sunset` | 夕暮れのビーチ | 美しい夕日のビー�� | ビーチ、海、夕日 |
+| `festival_night` | 夜のお祭り | 賑やかな夜祭り | お祭り、花火、屋台 |
+| `shrine_day` | 昼間の神社 | 静寂な神社の境内 | 神社、お参り、鳥居 |
+| `cafe_afternoon` | 午後のカフェ | 落ち着いたカフェ | カフェ、コーヒー |
+| `art_museum_night` | 夜の美術館 | 幻想的な美術館 | 美術館、アート、絵画 |
+
+### シーン変更の仕組み
+- **自動検出**: 会話内容から場所に関するキーワードを検出
+- **スムーズ遷移**: 1.5秒のフェードイン・アウト効果
+- **文脈適応**: 会話の流れに自然に溶け込む背景変化
+- **美術館検出**: 美術館、アート、絵画、彫刻などのキーワードで夜の美術館シーンに変更
+
+## 🔧 技術仕様
+
+### API情報
+- **プロバイダー**: [Together AI](https://api.together.xyz/) と [Groq](https://console.groq.com/)
+- **使用モデル**: 
+  - Together AI: `Qwen/Qwen3-235B-A22B-Instruct-2507-tput`（対話生成）
+  - Groq: `llama-3.1-70b-versatile`（シーン検出・手紙生成）
+- **レート制限**: 適応的制限により安定した動作
+- **フォールバック**: API障害時は固定応答で継続動作
+- **シーン検出**: Groq API優先、失敗時はキーワードベース検出
+
+### システム要件
+- **Python**: 3.8以上（3.10推奨）
+- **メモリ**: 最小1GB、推奨2GB以上
+- **ストレージ**: 100MB以上の空き容量
+- **ネットワーク**: インターネット接続必須
+
+### パフォーマンス
+- **応答時間**: 通常2-5秒
+- **同時接続**: 複数ユーザー対応
+- **メモリ効率**: 自動圧縮により長期間の安定動作
+- **セッション管理**: 強化された分離機能
+
+## 🔧 トラブルシューティング
+
+### よくある問題と解決方法
+
+#### 🔑 APIキー関連
+**問題**: APIキーエラーが発生する
+**解決方法**:
+- `TOGETHER_API_KEY`が正しく設定されているか確認
+- [Together AI](https://api.together.xyz/)でAPIキーの有効性を確認
+- 環境変数の再設定後、アプリを再起動
+
+#### 🚀 起動・動作問題
+**問題**: アプリが起動しない
+**解決方法**:
+- 依存関係の再インストール: `pip install -r spaces/requirements.txt`
+- Pythonバージョン確認: `python --version`（3.8以上必須）
+- ポート8501が使用中でないか確認
+
+**問題**: 応答が生成されない
+**解決方法**:
+- インターネット接続を確認
+- APIの利用制限状況を確認
+- デバッグモードでエラーログを確認
+
+#### 🐕 ポチ機能問題
+**問題**: ポチが表示されない、または動作しない
+**解決方法**:
+- ブラウザのキャッシュをクリア
+- 画面右下にポチが固定表示されているか確認
+- 会話をリセットして再試行
+- デバッグモードでHIDDEN形式の検出状況を確認
+
+#### 🎨 背景画像問題
+**問題**: 背景画像が見えない、または白い背景になっている
+**解決方法**:
+- アプリケーションを再起動（背景更新スキップ機能は無効化済み）
+- ブラウザのキャッシュをクリア
+- 「美術館」「夜」「カフェ」などのキーワードでシーン変更をテスト
+- デバッグモードで右上の「🖼️ 背景適用済」表示を確認
+- タブやメッセージエリアは白い半透明背景で保護されているのが正常
+
+#### 💾 メモリ・セッション問題
+**問題**: メモリエラーや会話履歴の問題
+**解決方法**:
+- サイドバーの「🔄会話をリセット」を実行
+- ブラウザのキャッシュとCookieをクリア
+- アプリの再起動
+
+### 🛠️ デバッグ機能
+
+#### デバッグモードの有効化
+1. 環境変数で`DEBUG_MODE=true`を設定
+2. または、サイドバーの「🛠️デバッグ情報」を展開
+
+#### 確認できる情報
+- **セッション分離状態**: ユーザー独立性の確認
+- **メモリ統計**: 使用量と圧縮状況
+- **API応答ログ**: リクエスト・レスポンスの詳細
+- **ポチ機能統計**: HIDDEN形式の検出状況
+
+#### ログファイルの場所
+- **Streamlitログ**: コンソール出力
+- **アプリケーションログ**: Python loggingモジュール
+- **セッション情報**: デバッグモードで表示
+
+## 👨‍💻 開発者向け情報
+
+### プロジェクト構造
+
+```
+MariChat2-AI--main/
+├── main_app.py                      # 統合メインアプリケーション
+├── components_chat_interface.py     # チャット機能（ポチ機能付き）
+├── components_dog_assistant.py      # ポチ（犬）アシスタント
+├── session_manager.py               # セッション分離管理
+├── core_dialogue.py                 # 対話生成（HIDDEN形式対応）
+├── core_sentiment.py                # 感情分析・好感度システム
+├── core_scene_manager.py            # 動的背景システム
+├── core_memory_manager.py           # 長期記憶管理
+├── core_rate_limiter.py             # レート制限
+├── letter_*.py                      # 非同期手紙生成システム
+├── async_*.py                       # 非同期処理関連
+├── streamlit_styles.css             # カスタムCSS（ポチ機能含む）
+├── requirements.txt                 # 依存関係
+├── requirements_session.txt         # セッション管理用依存関係
+├── .env                             # 環境変数設定
+├── session_data/                    # セッションデータ保存
+├── tmp/                             # 一時ファイル
+├── push/                            # プッシュ通知関連
+├── Dockerfile                       # Docker設定
+├── .dockerignore                    # Docker除外設定
+└── README.md                        # このファイル
+```
+
+### 🐕 ポチ機能の実装
+
+#### 核となる仕組み
+```python
+# HIDDEN形式の検出
+pattern = r'\[HIDDEN:(.*?)\](.*)'
+has_hidden, visible, hidden = detect_hidden_content(message)
+
+# 画面右下への固定配置（左寄せ調整済み）
+CSS: position: fixed; bottom: 20px; right: 20px; transform: translateX(-50px);
+
+# 全メッセージの一括制御
+st.session_state.show_all_hidden = not st.session_state.show_all_hidden
+```
+
+#### カスタマイズポイント
+- **プロンプト**: `SYSTEM_PROMPT_MARI`/`SYSTEM_PROMPT_URA`で隠された真実の生成を制御
+- **レスポンシブ**: CSSメディアクエリで画面サイズ対応（デスクトップ・タブレット・モバイル）
+- **検出ロジック**: `_detect_hidden_content()`で形式を変更可能
+- **ポチの見た目**: `components_dog_assistant.py`でデザイン調整
+- **吹き出し位置**: 左寄せ配置でポチボタンの真上に表示
+
+### ✉️ 手紙機能の実装
+
+#### 非同期処理アーキテクチャ
+```python
+# バックグラウンド生成
+async def generate_letter_async(theme, user_id):
+    # 非同期でAI生成
+    
+# スケジューラー
+batch_scheduler.schedule_generation(user_id, theme, delivery_time)
+
+# ストレージ管理
+async_storage.save_letter(letter_data)
+```
+
+#### 手紙生成システム
+- **非同期処理**: `async_letter_app.py`でバックグラウンド生成
+- **設定管理**: `async_config_setup.py`で環境設定
+- **レート制限**: `async_rate_limiter.py`でAPI使用量制御
+- **ストレージ**: `async_storage_manager.py`でデータ永続化
+
+### 🛡️ セッション分離システム
+
+#### 強化された分離機能
+```python
+class SessionManager:
+    def __init__(self):
+        self.session_id = id(st.session_state)
+        self.user_id = None
+        
+    def validate_session_integrity(self):
+        # セッション整合性チェック
+```
+
+### カスタマイズガイド
+
+#### 新しいシーンの追加
+1. `core_scene_manager.py`の`theme_urls`辞書に追加
+2. 背景画像URLを設定
+3. Groqプロンプトの`scenes_description`に説明を追加
+4. フォールバック用の`keyword_scene_map`にトリガーワードを定義
+
+#### プロンプトのカスタマイズ
+```bash
+# 通常モード
+SYSTEM_PROMPT_MARI="あなたのカスタムプロンプト..."
+
+# セーフティ解除モード  
+SYSTEM_PROMPT_URA="より大胆なプロンプト..."
+```
+
+#### UIスタイルの変更
+- `streamlit_styles.css`でカラーテーマ、アニメーション、レイアウトを調整
+- CSS変数を使用した統一的なデザインシステム
+- ポチの固定配置とレスポンシブ対応
+
+### テスト機能
+
+#### 提供されるテストスクリプト
+- `test_mask_functionality.py`: ポチ機能の動作確認
+- `test_multiple_hidden_fixed.py`: 複数HIDDEN形式の処理確認
+- `test_hidden_format_issue.py`: HIDDEN形式の問題診断
+- `debug_session_state.py`: セッション状態のデバッグ
+
+#### テスト実行方法
+```bash
+python test_mask_functionality.py
+python test_multiple_hidden_fixed.py
+```
+
+## 🤝 貢献・開発参加
+
+### バグ報告・機能提案
+- **Issues**: GitHubのIssuesでバグ報告や機能提案をお願いします
+- **Discussion**: 新機能のアイデアや改善案の議論
+- **Pull Request**: コード改善やバグ修正のPRを歓迎します
+
+### 開発ガイドライン
+1. **コードスタイル**: PEP 8に準拠
+2. **テスト**: 新機能には対応するテストを追加
+3. **ドキュメント**: 変更内容をREADMEに反映
+4. **コミット**: 明確で説明的なコミットメッセージ
+
+### 開発環境のセットアップ
+```bash
+# 開発用依存関係のインストール
+pip install -r requirements.txt
+
+# テストの実行
+python -m pytest tests/
+
+# コードフォーマット
+black .
+flake8 .
+```
+
+## 📄 ライセンス
+
+このプロジェクトは**MITライセンス**の下で公開されています。
+
+## 🙏 謝辞
+
+- **Together AI**: 高品質なLLM APIの提供
+- **Streamlit**: 直感的なWebアプリフレームワーク
+- **コミュニティ**: バグ報告や機能提案をいただいた皆様
+
+## 📞 サポート・連絡先
+
+- **GitHub Issues**: バグ報告・機能提案
+- **Discussions**: 一般的な質問・議論
+- **Email**: 重要な問題やセキュリティ関連
+
+## 🔄 更新履歴
+
+### v2.1.0 (最新)
+- 🐕 **ポチ機能**: 画面右下の犬アシスタントによる本音一括表示（吹き出し位置を左寄せに調整）
+- 🔓 **セーフティ統合**: 左サイドバーへの統合と色分け表示（URAプロンプト対応）
+- 🎨 **シーン検出強化**: Groq API優先、フォールバック機能付きの高精度シーン変更
+- 📊 **好感度バー改善**: 左寒色→右暖色のグラデーション、動的塗りつぶし表示
+- 🎨 **背景システム改善**: スキップ機能無効化による確実な背景表示
+- 📱 **レスポンシブ対応**: 様々な画面サイズに最適化
+- ✉️ **非同期手紙生成**: バックグラウンド手紙生成
+- 🛡️ **セッション分離強化**: マルチユーザー対応改善
+
+### v2.0.0
+- 🎭 **マスク機能**: 隠された真実の表示機能（現在はポチ機能に統合）
+- 🔓 **セーフティ解除モード**: より大胆な表現モード
+- ✉️ **非同期手紙生成**: バックグラウンド手紙生成
+- 🛡️ **セッション分離強化**: マルチユーザー対応改善
+- 🎨 **UI再設計**: モダンで直感的なインターフェース
+
+### v1.0.0
+- 基本的なチャット機能
+- 好感度システム
+- 動的背景変更
+- メモリ管理機能
+
+---
+
+<div align="center">
+
+**🐕 Made with ❤️ using Streamlit & Together AI 🐕**
+
+*麻理とポチとの特別な時間をお楽しみください*
+
+[![Streamlit](https://img.shields.io/badge/Streamlit-FF4B4B?style=for-the-badge&logo=streamlit&logoColor=white)](https://streamlit.io/)
+[![Together AI](https://img.shields.io/badge/Together%20AI-000000?style=for-the-badge&logo=ai&logoColor=white)](https://together.ai/)
+[![Python](https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://python.org/)
+
+</div>

__init__.py

@@ -0,0 +1,7 @@
+"""
+非同期手紙生成アプリ（麻理AI）
+Asynchronous Letter Generation App (Mari AI)
+"""
+
+__version__ = "1.0.0"
+__author__ = "Mari AI Team"

app.py

@@ -0,0 +1,108 @@
+"""
+メインアプリケーションモジュール
+Main application module
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+from letter_config import Config
+from letter_logger import get_app_logger
+
+# プロジェクトルートをPythonパスに追加
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+logger = get_app_logger()
+
+class LetterApp:
+    """非同期手紙生成アプリケーションのメインクラス"""
+    
+    def __init__(self):
+        """アプリケーションを初期化"""
+        self.config = Config()
+        self.logger = logger
+        self._initialized = False
+    
+    async def initialize(self) -> bool:
+        """
+        アプリケーションを初期化する
+        
+        Returns:
+            初期化が成功したかどうか
+        """
+        try:
+            self.logger.info("アプリケーションを初期化中...")
+            
+            # 設定の妥当性をチェック
+            if not self.config.validate_config():
+                self.logger.error("設定の検証に失敗しました")
+                return False
+            
+            # ストレージディレクトリを作成
+            await self._setup_storage_directories()
+            
+            # ログディレクトリを作成
+            await self._setup_log_directories()
+            
+            self._initialized = True
+            self.logger.info("アプリケーションの初期化が完了しました")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"アプリケーションの初期化中にエラーが発生しました: {e}")
+            return False
+    
+    async def _setup_storage_directories(self):
+        """ストレージディレクトリを作成"""
+        storage_dir = Path(self.config.STORAGE_PATH).parent
+        backup_dir = Path(self.config.BACKUP_PATH)
+        
+        storage_dir.mkdir(parents=True, exist_ok=True)
+        backup_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.logger.info(f"ストレージディレクトリを作成: {storage_dir}")
+        self.logger.info(f"バックアップディレクトリを作成: {backup_dir}")
+    
+    async def _setup_log_directories(self):
+        """ログディレクトリを作成"""
+        if not self.config.DEBUG_MODE:
+            log_dir = Path("/mnt/data/logs")
+            log_dir.mkdir(parents=True, exist_ok=True)
+            self.logger.info(f"ログディレクトリを作成: {log_dir}")
+    
+    def is_initialized(self) -> bool:
+        """アプリケーションが初期化されているかチェック"""
+        return self._initialized
+    
+    def get_config(self) -> Config:
+        """設定オブジェクトを取得"""
+        return self.config
+
+# グローバルアプリケーションインスタンス
+app_instance = None
+
+async def get_app() -> LetterApp:
+    """アプリケーションインスタンスを取得（シングルトン）"""
+    global app_instance
+    
+    if app_instance is None:
+        app_instance = LetterApp()
+        await app_instance.initialize()
+    
+    return app_instance
+
+def run_app():
+    """アプリケーションを実行"""
+    async def main():
+        app = await get_app()
+        if app.is_initialized():
+            logger.info("アプリケーションが正常に起動しました")
+        else:
+            logger.error("アプリケーションの起動に失敗しました")
+            sys.exit(1)
+    
+    asyncio.run(main())
+
+if __name__ == "__main__":
+    run_app()

async_config_setup.py

@@ -0,0 +1,143 @@
+"""
+非同期手紙生成システムの設定初期化
+Async Letter Generation System Configuration Setup
+"""
+
+import os
+import sys
+from pathlib import Path
+from letter_config import Config
+from letter_logger import get_app_logger
+
+logger = get_app_logger()
+
+def initialize_config() -> bool:
+    """
+    設定を初期化し、必要なディレクトリを作成する
+    
+    Returns:
+        初期化が成功したかどうか
+    """
+    try:
+        # 設定の妥当性をチェック
+        if not Config.validate_config():
+            logger.error("設定の検証に失敗しました")
+            return False
+        
+        # 必要なディレクトリを作成
+        storage_path = Path(Config.STORAGE_PATH)
+        storage_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        backup_path = Path(Config.BACKUP_PATH)
+        backup_path.mkdir(parents=True, exist_ok=True)
+        
+        # ログディレクトリを作成（本番環境用）
+        if not Config.DEBUG_MODE:
+            log_dir = Path("/tmp")
+            log_dir.mkdir(parents=True, exist_ok=True)
+        
+        logger.info("設定初期化が完了しました")
+        logger.info(f"ストレージパス: {Config.STORAGE_PATH}")
+        logger.info(f"バックアップパス: {Config.BACKUP_PATH}")
+        logger.info(f"デバッグモード: {Config.DEBUG_MODE}")
+        logger.info(f"バッチ処理時刻: {Config.BATCH_SCHEDULE_HOURS}")
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"設定初期化エラー: {e}")
+        return False
+
+def check_api_keys() -> bool:
+    """
+    API キーの存在をチェックする
+    
+    Returns:
+        API キーが設定されているかどうか
+    """
+    try:
+        missing_keys = []
+        
+        if not Config.GROQ_API_KEY:
+            missing_keys.append("GROQ_API_KEY")
+        
+        if not Config.GEMINI_API_KEY:
+            missing_keys.append("GEMINI_API_KEY")
+        
+        if missing_keys:
+            logger.error(f"必要なAPI キーが設定されていません: {', '.join(missing_keys)}")
+            return False
+        
+        logger.info("API キーの確認が完了しました")
+        return True
+        
+    except Exception as e:
+        logger.error(f"API キー確認エラー: {e}")
+        return False
+
+def setup_environment() -> bool:
+    """
+    環境をセットアップする
+    
+    Returns:
+        セットアップが成功したかどうか
+    """
+    try:
+        # 設定を初期化
+        if not initialize_config():
+            return False
+        
+        # API キーをチェック
+        if not check_api_keys():
+            return False
+        
+        # Hugging Face Spaces 固有の設定
+        if os.getenv("SPACE_ID"):
+            logger.info(f"Hugging Face Spaces環境で実行中: {os.getenv('SPACE_ID')}")
+            
+            # Spaces用の追加設定があればここに記述
+            
+        logger.info("環境セットアップが完了しました")
+        return True
+        
+    except Exception as e:
+        logger.error(f"環境セットアップエラー: {e}")
+        return False
+
+def get_system_info() -> dict:
+    """
+    システム情報を取得する
+    
+    Returns:
+        システム情報の辞書
+    """
+    return {
+        "python_version": sys.version,
+        "storage_path": Config.STORAGE_PATH,
+        "backup_path": Config.BACKUP_PATH,
+        "debug_mode": Config.DEBUG_MODE,
+        "batch_hours": Config.BATCH_SCHEDULE_HOURS,
+        "max_daily_requests": Config.MAX_DAILY_REQUESTS,
+        "generation_timeout": Config.GENERATION_TIMEOUT,
+        "max_concurrent_generations": Config.MAX_CONCURRENT_GENERATIONS,
+        "groq_model": Config.GROQ_MODEL,
+        "Together_model": Config.TOGETHER_API_MODEL,
+        "available_themes": Config.AVAILABLE_THEMES,
+        "space_id": os.getenv("SPACE_ID", "local"),
+        "streamlit_port": Config.STREAMLIT_PORT
+    }
+
+if __name__ == "__main__":
+    # スクリプトとして実行された場合の設定確認
+    print("非同期手紙生成システム設定確認")
+    print("=" * 50)
+    
+    if setup_environment():
+        print("✅ 環境セットアップ成功")
+        
+        system_info = get_system_info()
+        for key, value in system_info.items():
+            print(f"{key}: {value}")
+    else:
+        print("❌ 環境セットアップ失敗")
+        sys.exit(1)

async_letter_app.py

@@ -0,0 +1,110 @@
+"""
+メインアプリケーションモジュール
+Main application module
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# このファイルが依存している他のモジュールをインポート
+from letter_config import Config
+from letter_logger import get_app_logger
+
+# このモジュール用のロガーを取得
+logger = get_app_logger()
+
+class LetterApp:
+    """非同期手紙生成アプリケーションのメインクラス"""
+    
+    def __init__(self):
+        """アプリケーションを初期化"""
+        self.config = Config()
+        self.logger = logger
+        self._initialized = False
+    
+    async def initialize(self) -> bool:
+        """
+        アプリケーションを初期化する
+        
+        Returns:
+            初期化が成功したかどうか
+        """
+        try:
+            self.logger.info("アプリケーションを初期化中...")
+            
+            # 設定の妥当性をチェック
+            if not self.config.validate_config():
+                self.logger.error("設定の検証に失敗しました")
+                return False
+            
+            # ストレージディレクトリを作成
+            await self._setup_storage_directories()
+            
+            # ログディレクトリを作成
+            await self._setup_log_directories()
+            
+            self._initialized = True
+            self.logger.info("アプリケーションの初期化が完了しました")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"アプリケーションの初期化中にエラーが発生しました: {e}")
+            return False
+    
+    async def _setup_storage_directories(self):
+        """ストレージディレクトリを作成"""
+        storage_dir = Path(self.config.STORAGE_PATH).parent
+        backup_dir = Path(self.config.BACKUP_PATH)
+        
+        storage_dir.mkdir(parents=True, exist_ok=True)
+        backup_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.logger.info(f"ストレージディレクトリを作成: {storage_dir}")
+        self.logger.info(f"バックアップディレクトリを作成: {backup_dir}")
+    
+    async def _setup_log_directories(self):
+        """ログディレクトリを作成"""
+        if not self.config.DEBUG_MODE:
+            # ログファイルは個別のロガーで設定されるため、
+            # ここでは共通の親ディレクトリを作成する例
+            log_dir = Path("/tmp/logs") # 例: /tmp/batch.log などの親
+            log_dir.mkdir(parents=True, exist_ok=True)
+            self.logger.info(f"ログディレクトリを作成: {log_dir}")
+    
+    def is_initialized(self) -> bool:
+        """アプリケーションが初期化されているかチェック"""
+        return self._initialized
+    
+    def get_config(self) -> Config:
+        """設定オブジェクトを取得"""
+        return self.config
+
+# グローバルアプリケーションインスタンス（シングルトンパターン）
+app_instance = None
+
+async def get_app() -> LetterApp:
+    """アプリケーションインスタンスを取得（シングルトン）"""
+    global app_instance
+    
+    if app_instance is None:
+        app_instance = LetterApp()
+        await app_instance.initialize()
+    
+    return app_instance
+
+def run_app():
+    """アプリケーションを実行（テスト用）"""
+    async def main():
+        app = await get_app()
+        if app.is_initialized():
+            logger.info("アプリケーションが正常に起動しました")
+        else:
+            logger.error("アプリケーションの起動に失敗しました")
+            sys.exit(1)
+    
+    asyncio.run(main())
+
+# このファイルが直接実行された場合にテスト用の起動処理を行う
+if __name__ == "__main__":
+    run_app()

async_rate_limiter.py

@@ -0,0 +1,390 @@
+"""
+非同期レート制限管理クラス
+1日1回制限とAPI呼び出し制限を管理し、
+デバッグモード時の制限緩和機能を提供します。
+"""
+
+import asyncio
+import os
+from datetime import datetime, timedelta
+from typing import Dict, Any, Optional, Tuple
+import logging
+
+# ログ設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class RateLimitError(Exception):
+    """レート制限エラー"""
+    pass
+
+
+class AsyncRateLimitManager:
+    """非同期レート制限管理クラス"""
+    
+    def __init__(self, storage_manager, max_requests: int = 1):
+        self.storage = storage_manager
+        
+        # 設定値（環境変数から取得、デフォルト値あり）
+        self.max_daily_requests = int(os.getenv("MAX_DAILY_REQUESTS", "1"))
+        self.max_api_calls_per_day = int(os.getenv("MAX_API_CALLS_PER_DAY", "10"))
+        self.debug_mode = os.getenv("DEBUG_MODE", "false").lower() == "true"
+        
+        # デバッグモード時の制限緩和
+        if self.debug_mode:
+            self.max_daily_requests = int(os.getenv("DEBUG_MAX_DAILY_REQUESTS", "10"))
+            self.max_api_calls_per_day = int(os.getenv("DEBUG_MAX_API_CALLS", "100"))
+            logger.info("デバッグモードが有効です。制限が緩和されています")
+        
+        logger.info(f"レート制限設定 - 1日のリクエスト上限: {self.max_daily_requests}, API呼び出し上限: {self.max_api_calls_per_day}")
+    
+    async def check_daily_request_limit(self, user_id: str) -> Tuple[bool, Dict[str, Any]]:
+        """1日のリクエスト制限をチェック"""
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            today = datetime.now().strftime("%Y-%m-%d")
+            
+            # 今日のリクエスト数を取得
+            daily_requests = user_data["rate_limits"]["daily_requests"]
+            today_requests = daily_requests.get(today, 0)
+            
+            # 制限チェック
+            is_allowed = today_requests < self.max_daily_requests
+            
+            limit_info = {
+                "today_requests": today_requests,
+                "max_requests": self.max_daily_requests,
+                "remaining": max(0, self.max_daily_requests - today_requests),
+                "reset_time": self._get_next_reset_time(),
+                "debug_mode": self.debug_mode
+            }
+            
+            if not is_allowed:
+                logger.warning(f"ユーザー {user_id} の1日のリクエスト制限に達しました ({today_requests}/{self.max_daily_requests})")
+            
+            return is_allowed, limit_info
+            
+        except Exception as e:
+            logger.error(f"1日のリクエスト制限チェックエラー: {e}")
+            # エラー時は制限を適用
+            return False, {"error": str(e)}
+    
+    async def check_api_call_limit(self, user_id: str) -> Tuple[bool, Dict[str, Any]]:
+        """API呼び出し制限をチェック"""
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            today = datetime.now().strftime("%Y-%m-%d")
+            
+            # 今日のAPI呼び出し数を取得
+            api_calls = user_data["rate_limits"]["api_calls"]
+            today_calls = api_calls.get(today, 0)
+            
+            # 制限チェック
+            is_allowed = today_calls < self.max_api_calls_per_day
+            
+            limit_info = {
+                "today_calls": today_calls,
+                "max_calls": self.max_api_calls_per_day,
+                "remaining": max(0, self.max_api_calls_per_day - today_calls),
+                "reset_time": self._get_next_reset_time(),
+                "debug_mode": self.debug_mode
+            }
+            
+            if not is_allowed:
+                logger.warning(f"ユーザー {user_id} のAPI呼び出し制限に達しました ({today_calls}/{self.max_api_calls_per_day})")
+            
+            return is_allowed, limit_info
+            
+        except Exception as e:
+            logger.error(f"API呼び出し制限チェックエラー: {e}")
+            # エラー時は制限を適用
+            return False, {"error": str(e)}
+    
+    async def record_request(self, user_id: str) -> None:
+        """リクエストを記録"""
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            today = datetime.now().strftime("%Y-%m-%d")
+            
+            # 今日のリクエスト数を増加
+            if "daily_requests" not in user_data["rate_limits"]:
+                user_data["rate_limits"]["daily_requests"] = {}
+            
+            user_data["rate_limits"]["daily_requests"][today] = \
+                user_data["rate_limits"]["daily_requests"].get(today, 0) + 1
+            
+            # プロファイルの最終リクエスト日を更新
+            user_data["profile"]["last_request"] = today
+            
+            await self.storage.update_user_data(user_id, user_data)
+            
+            logger.info(f"ユーザー {user_id} のリクエストを記録しました")
+            
+        except Exception as e:
+            logger.error(f"リクエスト記録エラー: {e}")
+            raise RateLimitError(f"リクエストの記録に失敗しました: {e}")
+    
+    async def record_api_call(self, user_id: str, api_type: str = "general") -> None:
+        """API呼び出しを記録"""
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            today = datetime.now().strftime("%Y-%m-%d")
+            
+            # 今日のAPI呼び出し数を増加
+            if "api_calls" not in user_data["rate_limits"]:
+                user_data["rate_limits"]["api_calls"] = {}
+            
+            user_data["rate_limits"]["api_calls"][today] = \
+                user_data["rate_limits"]["api_calls"].get(today, 0) + 1
+            
+            await self.storage.update_user_data(user_id, user_data)
+            
+            logger.info(f"ユーザー {user_id} のAPI呼び出し ({api_type}) を記録しました")
+            
+        except Exception as e:
+            logger.error(f"API呼び出し記録エラー: {e}")
+            raise RateLimitError(f"API呼び出しの記録に失敗しました: {e}")
+    
+    async def get_user_limits_status(self, user_id: str) -> Dict[str, Any]:
+        """ユーザーの制限状況を取得"""
+        try:
+            # リクエスト制限の確認
+            request_allowed, request_info = await self.check_daily_request_limit(user_id)
+            
+            # API呼び出し制限の確認
+            api_allowed, api_info = await self.check_api_call_limit(user_id)
+            
+            # 次回リクエスト可能時刻の計算
+            next_request_time = None
+            if not request_allowed:
+                next_request_time = self._get_next_reset_time()
+            
+            return {
+                "request_limit": {
+                    "allowed": request_allowed,
+                    "info": request_info
+                },
+                "api_limit": {
+                    "allowed": api_allowed,
+                    "info": api_info
+                },
+                "next_request_time": next_request_time,
+                "debug_mode": self.debug_mode
+            }
+            
+        except Exception as e:
+            logger.error(f"制限状況取得エラー: {e}")
+            return {"error": str(e)}
+    
+    async def reset_daily_counters(self) -> int:
+        """1日のカウンターをリセット（古いデータを削除）"""
+        try:
+            # 7日以上前のデータを削除
+            cutoff_date = datetime.now() - timedelta(days=7)
+            cutoff_str = cutoff_date.strftime("%Y-%m-%d")
+            
+            all_users = await self.storage.get_all_users()
+            reset_count = 0
+            
+            for user_id in all_users:
+                user_data = await self.storage.get_user_data(user_id)
+                
+                # 古い1日のリクエストデータを削除
+                daily_requests = user_data["rate_limits"]["daily_requests"]
+                dates_to_delete = [date for date in daily_requests.keys() if date < cutoff_str]
+                
+                for date in dates_to_delete:
+                    del daily_requests[date]
+                    reset_count += 1
+                
+                # 古いAPI呼び出しデータを削除
+                api_calls = user_data["rate_limits"]["api_calls"]
+                dates_to_delete = [date for date in api_calls.keys() if date < cutoff_str]
+                
+                for date in dates_to_delete:
+                    del api_calls[date]
+                    reset_count += 1
+                
+                if reset_count > 0:
+                    await self.storage.update_user_data(user_id, user_data)
+            
+            if reset_count > 0:
+                logger.info(f"{reset_count}件の古い制限データをリセットしました")
+            
+            return reset_count
+            
+        except Exception as e:
+            logger.error(f"カウンターリセットエラー: {e}")
+            return 0
+    
+    def _get_next_reset_time(self) -> str:
+        """次のリセット時刻を取得（翌日の0時）"""
+        tomorrow = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(days=1)
+        return tomorrow.isoformat()
+    
+    async def is_request_allowed(self, user_id: str) -> Tuple[bool, str]:
+        """リクエストが許可されているかチェック（統合チェック）"""
+        try:
+            # 1日のリクエスト制限チェック
+            request_allowed, request_info = await self.check_daily_request_limit(user_id)
+            
+            if not request_allowed:
+                remaining_time = self._calculate_remaining_time()
+                return False, f"1日のリクエスト制限に達しています。次回リクエスト可能時刻: {remaining_time}"
+            
+            # API呼び出し制限チェック
+            api_allowed, api_info = await self.check_api_call_limit(user_id)
+            
+            if not api_allowed:
+                remaining_time = self._calculate_remaining_time()
+                return False, f"API呼び出し制限に達しています。次回リクエスト可能時刻: {remaining_time}"
+            
+            return True, "リクエスト可能です"
+            
+        except Exception as e:
+            logger.error(f"リクエスト許可チェックエラー: {e}")
+            return False, f"制限チェック中にエラーが発生しました: {e}"
+    
+    def _calculate_remaining_time(self) -> str:
+        """次回リクエスト可能までの残り時間を計算"""
+        now = datetime.now()
+        tomorrow = now.replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(days=1)
+        remaining = tomorrow - now
+        
+        hours = remaining.seconds // 3600
+        minutes = (remaining.seconds % 3600) // 60
+        
+        return f"{hours}時間{minutes}分後"
+    
+    async def get_rate_limit_stats(self) -> Dict[str, Any]:
+        """レート制限の統計情報を取得"""
+        try:
+            all_users = await self.storage.get_all_users()
+            today = datetime.now().strftime("%Y-%m-%d")
+            
+            total_requests_today = 0
+            total_api_calls_today = 0
+            active_users_today = 0
+            
+            for user_id in all_users:
+                user_data = await self.storage.get_user_data(user_id)
+                
+                # 今日のリクエスト数
+                daily_requests = user_data["rate_limits"]["daily_requests"]
+                user_requests_today = daily_requests.get(today, 0)
+                total_requests_today += user_requests_today
+                
+                # 今日のAPI呼び出し数
+                api_calls = user_data["rate_limits"]["api_calls"]
+                user_api_calls_today = api_calls.get(today, 0)
+                total_api_calls_today += user_api_calls_today
+                
+                # アクティブユーザー数
+                if user_requests_today > 0 or user_api_calls_today > 0:
+                    active_users_today += 1
+            
+            return {
+                "total_users": len(all_users),
+                "active_users_today": active_users_today,
+                "total_requests_today": total_requests_today,
+                "total_api_calls_today": total_api_calls_today,
+                "max_daily_requests": self.max_daily_requests,
+                "max_api_calls_per_day": self.max_api_calls_per_day,
+                "debug_mode": self.debug_mode,
+                "date": today
+            }
+            
+        except Exception as e:
+            logger.error(f"統計情報取得エラー: {e}")
+            return {"error": str(e)}
+    
+    def is_debug_mode(self) -> bool:
+        """デバッグモードかどうかを確認"""
+        return self.debug_mode
+    
+    async def set_debug_mode(self, enabled: bool) -> None:
+        """デバッグモードの設定（動的変更）"""
+        self.debug_mode = enabled
+        
+        if enabled:
+            self.max_daily_requests = int(os.getenv("DEBUG_MAX_DAILY_REQUESTS", "10"))
+            self.max_api_calls_per_day = int(os.getenv("DEBUG_MAX_API_CALLS", "100"))
+            logger.info("デバッグモードを有効にしました")
+        else:
+            self.max_daily_requests = int(os.getenv("MAX_DAILY_REQUESTS", "1"))
+            self.max_api_calls_per_day = int(os.getenv("MAX_API_CALLS_PER_DAY", "10"))
+            logger.info("デバッグモードを無効にしました")
+    
+    async def force_reset_user_limits(self, user_id: str) -> None:
+        """特定ユーザーの制限を強制リセット（デバッグ用）"""
+        if not self.debug_mode:
+            raise RateLimitError("デバッグモードでのみ利用可能です")
+        
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            today = datetime.now().strftime("%Y-%m-%d")
+            
+            # 今日の制限をリセット
+            user_data["rate_limits"]["daily_requests"][today] = 0
+            user_data["rate_limits"]["api_calls"][today] = 0
+            
+            await self.storage.update_user_data(user_id, user_data)
+            
+            logger.info(f"ユーザー {user_id} の制限を強制リセットしました")
+            
+        except Exception as e:
+            logger.error(f"強制リセットエラー: {e}")
+            raise RateLimitError(f"制限のリセットに失敗しました: {e}")
+
+
+# テスト用の関数
+async def test_rate_limit_manager():
+    """RateLimitManagerのテスト"""
+    import tempfile
+    import uuid
+    from async_storage_manager import AsyncStorageManager
+    
+    # 一時ディレクトリでテスト
+    with tempfile.TemporaryDirectory() as temp_dir:
+        test_file = os.path.join(temp_dir, "test_letters.json")
+        storage = AsyncStorageManager(test_file)
+        rate_limiter = AsyncRateLimitManager(storage)
+        
+        print("=== RateLimitManagerテスト開始 ===")
+        
+        user_id = str(uuid.uuid4())
+        
+        # 初回リクエストチェック
+        allowed, message = await rate_limiter.is_request_allowed(user_id)
+        print(f"✓ 初回リクエストチェック: {allowed} - {message}")
+        
+        # リクエスト記録
+        await rate_limiter.record_request(user_id)
+        print("✓ リクエスト記録成功")
+        
+        # API呼び出し記録
+        await rate_limiter.record_api_call(user_id, "groq")
+        print("✓ API呼び出し記録成功")
+        
+        # 制限状況確認
+        status = await rate_limiter.get_user_limits_status(user_id)
+        print(f"✓ 制限状況確認: {status}")
+        
+        # 統計情報取得
+        stats = await rate_limiter.get_rate_limit_stats()
+        print(f"✓ 統計情報取得: {stats}")
+        
+        # デバッグモードテスト
+        await rate_limiter.set_debug_mode(True)
+        print("✓ デバッグモード有効化成功")
+        
+        # 強制リセットテスト（デバッグモード時のみ）
+        await rate_limiter.force_reset_user_limits(user_id)
+        print("✓ 強制リセット成功")
+        
+        print("=== 全てのテストが完了しました！ ===")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_rate_limit_manager())

async_storage_manager.py

@@ -0,0 +1,417 @@
+"""
+非同期ストレージ管理クラス
+JSONファイルベースの永続ストレージを提供し、
+非同期ファイル操作とロック機能を実装します。
+"""
+
+import asyncio
+import json
+import os
+import shutil
+from datetime import datetime, timedelta
+from typing import Dict, Any, Optional, List
+from pathlib import Path
+import logging
+
+# ログ設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class StorageError(Exception):
+    """ストレージ関連のエラー"""
+    pass
+
+
+class AsyncStorageManager:
+    """非同期ストレージ管理クラス"""
+    
+    def __init__(self, file_path: str = "tmp/letters.json"):
+        self.file_path = Path(file_path)
+        self.backup_dir = self.file_path.parent / "backup"
+        self.lock = asyncio.Lock()
+        
+        # ディレクトリの作成
+        self.file_path.parent.mkdir(parents=True, exist_ok=True)
+        self.backup_dir.mkdir(parents=True, exist_ok=True)
+        
+        # 初期データ構造
+        self.default_data = {
+            "users": {},
+            "system": {
+                "last_backup": None,
+                "batch_runs": {},
+                "created_at": datetime.now().isoformat()
+            }
+        }
+    
+    async def load_data(self) -> Dict[str, Any]:
+        """データファイルを読み込み"""
+        async with self.lock:
+            try:
+                if not self.file_path.exists():
+                    logger.info("データファイルが存在しないため、初期データを作成します")
+                    await self._save_data_unsafe(self.default_data)
+                    return self.default_data.copy()
+                
+                # ファイルサイズチェック
+                if self.file_path.stat().st_size == 0:
+                    logger.warning("データファイルが空のため、初期データを作成します")
+                    await self._save_data_unsafe(self.default_data)
+                    return self.default_data.copy()
+                
+                # JSONファイルの読み込み
+                with open(self.file_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                
+                # データ構造の検証と修復
+                data = self._validate_and_repair_data(data)
+                
+                logger.info(f"データファイルを正常に読み込みました: {self.file_path}")
+                return data
+                
+            except json.JSONDecodeError as e:
+                logger.error(f"JSONファイルの形式が不正です: {e}")
+                # バックアップからの復旧を試行
+                return await self._restore_from_backup()
+                
+            except Exception as e:
+                logger.error(f"データ読み込みエラー: {e}")
+                raise StorageError(f"データの読み込みに失敗しました: {e}")
+    
+    async def save_data(self, data: Dict[str, Any]) -> None:
+        """データファイルに保存"""
+        async with self.lock:
+            await self._save_data_unsafe(data)
+    
+    async def _save_data_unsafe(self, data: Dict[str, Any]) -> None:
+        """ロックなしでデータを保存（内部使用）"""
+        try:
+            # データの検証
+            validated_data = self._validate_and_repair_data(data)
+            
+            # 一時ファイルに書き込み
+            temp_path = self.file_path.with_suffix('.tmp')
+            
+            with open(temp_path, 'w', encoding='utf-8') as f:
+                json.dump(validated_data, f, ensure_ascii=False, indent=2)
+            
+            # アトミックな移動
+            shutil.move(str(temp_path), str(self.file_path))
+            
+            logger.info(f"データを正常に保存しました: {self.file_path}")
+            
+        except Exception as e:
+            logger.error(f"データ保存エラー: {e}")
+            # 一時ファイルのクリーンアップ
+            temp_path = self.file_path.with_suffix('.tmp')
+            if temp_path.exists():
+                temp_path.unlink()
+            raise StorageError(f"データの保存に失敗しました: {e}")
+    
+    async def get_user_data(self, user_id: str) -> Dict[str, Any]:
+        """特定ユーザーのデータを取得"""
+        data = await self.load_data()
+        
+        if user_id not in data["users"]:
+            # 新規ユーザーの初期データを作成
+            user_data = {
+                "profile": {
+                    "created_at": datetime.now().isoformat(),
+                    "last_request": None,
+                    "total_letters": 0
+                },
+                "letters": {},
+                "requests": {},
+                "rate_limits": {
+                    "daily_requests": {},
+                    "api_calls": {}
+                }
+            }
+            data["users"][user_id] = user_data
+            await self.save_data(data)
+            logger.info(f"新規ユーザーデータを作成しました: {user_id}")
+        
+        return data["users"][user_id]
+    
+    async def update_user_data(self, user_id: str, user_data: Dict[str, Any]) -> None:
+        """特定ユーザーのデータを更新"""
+        data = await self.load_data()
+        data["users"][user_id] = user_data
+        await self.save_data(data)
+        logger.info(f"ユーザーデータを更新しました: {user_id}")
+    
+    async def get_all_users(self) -> List[str]:
+        """全ユーザーIDのリストを取得"""
+        data = await self.load_data()
+        return list(data["users"].keys())
+    
+    async def backup_data(self) -> str:
+        """データのバックアップを作成"""
+        try:
+            if not self.file_path.exists():
+                logger.warning("バックアップ対象のファイルが存在しません")
+                return ""
+            
+            # バックアップファイル名（タイムスタンプ付き）
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_filename = f"letters_backup_{timestamp}.json"
+            backup_path = self.backup_dir / backup_filename
+            
+            # ファイルをコピー
+            shutil.copy2(str(self.file_path), str(backup_path))
+            
+            # システム情報を更新
+            data = await self.load_data()
+            data["system"]["last_backup"] = datetime.now().isoformat()
+            await self.save_data(data)
+            
+            logger.info(f"バックアップを作成しました: {backup_path}")
+            
+            # 古いバックアップファイルを削除（7日以上前）
+            await self._cleanup_old_backups()
+            
+            return str(backup_path)
+            
+        except Exception as e:
+            logger.error(f"バックアップ作成エラー: {e}")
+            raise StorageError(f"バックアップの作成に失敗しました: {e}")
+    
+    async def _restore_from_backup(self) -> Dict[str, Any]:
+        """最新のバックアップから復旧"""
+        try:
+            # バックアップファイルを検索
+            backup_files = list(self.backup_dir.glob("letters_backup_*.json"))
+            
+            if not backup_files:
+                logger.warning("バックアップファイルが見つかりません。初期データを使用します")
+                await self._save_data_unsafe(self.default_data)
+                return self.default_data.copy()
+            
+            # 最新のバックアップファイルを選択
+            latest_backup = max(backup_files, key=lambda p: p.stat().st_mtime)
+            
+            logger.info(f"バックアップから復旧します: {latest_backup}")
+            
+            with open(latest_backup, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            # 復旧したデータを保存
+            await self._save_data_unsafe(data)
+            
+            return data
+            
+        except Exception as e:
+            logger.error(f"バックアップからの復旧に失敗: {e}")
+            logger.info("初期データを使用します")
+            await self._save_data_unsafe(self.default_data)
+            return self.default_data.copy()
+    
+    async def _cleanup_old_backups(self, days: int = 7) -> None:
+        """古いバックアップファイルを削除"""
+        try:
+            cutoff_date = datetime.now() - timedelta(days=days)
+            backup_files = list(self.backup_dir.glob("letters_backup_*.json"))
+            
+            deleted_count = 0
+            for backup_file in backup_files:
+                file_time = datetime.fromtimestamp(backup_file.stat().st_mtime)
+                if file_time < cutoff_date:
+                    backup_file.unlink()
+                    deleted_count += 1
+            
+            if deleted_count > 0:
+                logger.info(f"{deleted_count}個の古いバックアップファイルを削除しました")
+                
+        except Exception as e:
+            logger.error(f"バックアップファイルの削除エラー: {e}")
+    
+    def _validate_and_repair_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """データ構造の検証と修復"""
+        if not isinstance(data, dict):
+            logger.warning("データが辞書形式ではありません。初期データを使用します")
+            return self.default_data.copy()
+        
+        # 必要なキーの確認と修復
+        if "users" not in data:
+            data["users"] = {}
+        
+        if "system" not in data:
+            data["system"] = self.default_data["system"].copy()
+        
+        # システム情報の修復
+        system_defaults = {
+            "last_backup": None,
+            "batch_runs": {},
+            "created_at": datetime.now().isoformat()
+        }
+        
+        for key, default_value in system_defaults.items():
+            if key not in data["system"]:
+                data["system"][key] = default_value
+        
+        # ユーザーデータの修復
+        for user_id, user_data in data["users"].items():
+            if not isinstance(user_data, dict):
+                continue
+            
+            # 必要なキーの確認
+            user_defaults = {
+                "profile": {
+                    "created_at": datetime.now().isoformat(),
+                    "last_request": None,
+                    "total_letters": 0
+                },
+                "letters": {},
+                "requests": {},
+                "rate_limits": {
+                    "daily_requests": {},
+                    "api_calls": {}
+                }
+            }
+            
+            for key, default_value in user_defaults.items():
+                if key not in user_data:
+                    user_data[key] = default_value
+        
+        return data
+    
+    async def get_system_info(self) -> Dict[str, Any]:
+        """システム情報を取得"""
+        data = await self.load_data()
+        return data["system"]
+    
+    async def update_system_info(self, system_info: Dict[str, Any]) -> None:
+        """システム情報を更新"""
+        data = await self.load_data()
+        data["system"].update(system_info)
+        await self.save_data(data)
+    
+    async def cleanup_old_data(self, days: int = 90) -> int:
+        """古いデータを削除"""
+        try:
+            cutoff_date = datetime.now() - timedelta(days=days)
+            cutoff_str = cutoff_date.strftime("%Y-%m-%d")
+            
+            data = await self.load_data()
+            deleted_count = 0
+            
+            for user_id, user_data in data["users"].items():
+                # 古い手紙を削除
+                letters_to_delete = []
+                for date_str in user_data["letters"]:
+                    if date_str < cutoff_str:
+                        letters_to_delete.append(date_str)
+                
+                for date_str in letters_to_delete:
+                    del user_data["letters"][date_str]
+                    deleted_count += 1
+                
+                # 古いリクエストを削除
+                requests_to_delete = []
+                for date_str in user_data["requests"]:
+                    if date_str < cutoff_str:
+                        requests_to_delete.append(date_str)
+                
+                for date_str in requests_to_delete:
+                    del user_data["requests"][date_str]
+                
+                # 古いレート制限データを削除
+                for limit_type in ["daily_requests", "api_calls"]:
+                    if limit_type in user_data["rate_limits"]:
+                        dates_to_delete = []
+                        for date_str in user_data["rate_limits"][limit_type]:
+                            if date_str < cutoff_str:
+                                dates_to_delete.append(date_str)
+                        
+                        for date_str in dates_to_delete:
+                            del user_data["rate_limits"][limit_type][date_str]
+            
+            if deleted_count > 0:
+                await self.save_data(data)
+                logger.info(f"{deleted_count}件の古いデータを削除しました")
+            
+            return deleted_count
+            
+        except Exception as e:
+            logger.error(f"古いデータの削除エラー: {e}")
+            return 0
+    
+    async def get_storage_stats(self) -> Dict[str, Any]:
+        """ストレージの統計情報を取得"""
+        try:
+            data = await self.load_data()
+            
+            total_users = len(data["users"])
+            total_letters = sum(len(user_data["letters"]) for user_data in data["users"].values())
+            total_requests = sum(len(user_data["requests"]) for user_data in data["users"].values())
+            
+            file_size = self.file_path.stat().st_size if self.file_path.exists() else 0
+            backup_count = len(list(self.backup_dir.glob("letters_backup_*.json")))
+            
+            return {
+                "total_users": total_users,
+                "total_letters": total_letters,
+                "total_requests": total_requests,
+                "file_size_bytes": file_size,
+                "backup_count": backup_count,
+                "last_backup": data["system"].get("last_backup"),
+                "created_at": data["system"].get("created_at")
+            }
+            
+        except Exception as e:
+            logger.error(f"統計情報の取得エラー: {e}")
+            return {}
+
+
+# テスト用の関数
+async def test_storage_manager():
+    """StorageManagerのテスト"""
+    import tempfile
+    import uuid
+    
+    # 一時ディレクトリでテスト
+    with tempfile.TemporaryDirectory() as temp_dir:
+        test_file = os.path.join(temp_dir, "test_letters.json")
+        storage = AsyncStorageManager(test_file)
+        
+        print("=== StorageManagerテスト開始 ===")
+        
+        # 初期データの読み込みテスト
+        data = await storage.load_data()
+        print("✓ 初期データの読み込み成功")
+        
+        # ユーザーデータの作成テスト
+        user_id = str(uuid.uuid4())
+        user_data = await storage.get_user_data(user_id)
+        print("✓ ユーザーデータの作成成功")
+        
+        # ユーザーデータの更新テスト
+        user_data["profile"]["total_letters"] = 1
+        user_data["letters"]["2024-01-20"] = {
+            "theme": "テストテーマ",
+            "content": "テスト手紙の内容",
+            "status": "completed",
+            "generated_at": datetime.now().isoformat()
+        }
+        await storage.update_user_data(user_id, user_data)
+        print("✓ ユーザーデータの更新成功")
+        
+        # データの再読み込みテスト
+        updated_data = await storage.get_user_data(user_id)
+        assert updated_data["profile"]["total_letters"] == 1
+        print("✓ データの永続化確認成功")
+        
+        # バックアップテスト
+        backup_path = await storage.backup_data()
+        print(f"✓ バックアップ作成成功: {backup_path}")
+        
+        # 統計情報テスト
+        stats = await storage.get_storage_stats()
+        print(f"✓ 統計情報取得成功: {stats}")
+        
+        print("=== 全てのテストが完了しました！ ===")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_storage_manager())

background_processor.py

@@ -0,0 +1,616 @@
+"""
+バックグラウンド処理統合クラス
+Streamlitアプリと独立したバッチ処理の実行機能と
+古いデータの自動削除機能を提供します。
+"""
+
+import asyncio
+import threading
+import time
+import os
+from datetime import datetime, timedelta
+from typing import Dict, Any, Optional, Callable
+import logging
+import traceback
+import signal
+import sys
+
+from batch_scheduler import BatchScheduler
+from async_storage_manager import AsyncStorageManager
+
+# ログ設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class BackgroundProcessorError(Exception):
+    """バックグラウンドプロセッサー関連のエラー"""
+    pass
+
+
+class BackgroundProcessor:
+    """Streamlitアプリと独立したバックグラウンド処理管理クラス"""
+    
+    def __init__(self, storage_manager: Optional[AsyncStorageManager] = None):
+        """
+        バックグラウンドプロセッサーを初期化
+        
+        Args:
+            storage_manager: ストレージマネージャー（指定しない場合は新規作成）
+        """
+        # ストレージマネージャーの初期化
+        if storage_manager is None:
+            storage_path = os.getenv("STORAGE_PATH", "/mnt/data/letters.json")
+            self.storage_manager = AsyncStorageManager(storage_path)
+        else:
+            self.storage_manager = storage_manager
+        
+        # バッチスケジューラーの初期化
+        self.batch_scheduler = BatchScheduler(self.storage_manager)
+        
+        # 設定値
+        self.target_hours = [2, 3, 4]  # 2時、3時、4時
+        self.check_interval = int(os.getenv("BATCH_CHECK_INTERVAL", "60"))  # 1分間隔
+        self.cleanup_hour = int(os.getenv("CLEANUP_HOUR", "1"))  # 1時にクリーンアップ
+        self.cleanup_retention_days = int(os.getenv("CLEANUP_RETENTION_DAYS", "90"))
+        self.enable_background_processing = os.getenv("ENABLE_BACKGROUND_PROCESSING", "true").lower() == "true"
+        
+        # 実行状態管理
+        self.is_running = False
+        self.background_thread = None
+        self.stop_event = threading.Event()
+        self.last_execution_times = {hour: None for hour in self.target_hours}
+        self.last_cleanup_date = None
+        
+        # コールバック関数
+        self.on_batch_complete: Optional[Callable] = None
+        self.on_cleanup_complete: Optional[Callable] = None
+        self.on_error: Optional[Callable] = None
+        
+        logger.info(f"BackgroundProcessor初期化完了 - 対象時刻: {self.target_hours}, チェック間隔: {self.check_interval}秒")
+    
+    def start_background_processing(self) -> bool:
+        """
+        バックグラウンド処理を開始
+        
+        Returns:
+            bool: 開始成功フラグ
+        """
+        if not self.enable_background_processing:
+            logger.info("バックグラウンド処理は無効化されています")
+            return False
+        
+        if self.is_running:
+            logger.warning("バックグラウンド処理は既に実行中です")
+            return False
+        
+        try:
+            self.is_running = True
+            self.stop_event.clear()
+            
+            # バックグラウンドスレッドを開始
+            self.background_thread = threading.Thread(
+                target=self._background_loop,
+                name="BackgroundProcessor",
+                daemon=True
+            )
+            self.background_thread.start()
+            
+            # シグナルハンドラーを設定
+            self._setup_signal_handlers()
+            
+            logger.info("バックグラウンド処理を開始しました")
+            return True
+            
+        except Exception as e:
+            self.is_running = False
+            logger.error(f"バックグラウンド処理の開始に失敗: {str(e)}")
+            return False
+    
+    def stop_background_processing(self) -> bool:
+        """
+        バックグラウンド処理を停止
+        
+        Returns:
+            bool: 停止成功フラグ
+        """
+        if not self.is_running:
+            logger.info("バックグラウンド処理は実行されていません")
+            return True
+        
+        try:
+            logger.info("バックグラウンド処理の停止を開始します...")
+            
+            # 停止フラグを設定
+            self.stop_event.set()
+            self.is_running = False
+            
+            # スレッドの終了を待機
+            if self.background_thread and self.background_thread.is_alive():
+                self.background_thread.join(timeout=30)  # 30秒でタイムアウト
+                
+                if self.background_thread.is_alive():
+                    logger.warning("バックグラウンドスレッドの停止がタイムアウトしました")
+                    return False
+            
+            logger.info("バックグラウンド処理を停止しました")
+            return True
+            
+        except Exception as e:
+            logger.error(f"バックグラウンド処理の停止に失敗: {str(e)}")
+            return False
+    
+    def start_background_processing(self) -> bool:
+        if not self.enable_background_processing:
+            logger.info("バックグラウンド処理は無効化されています")
+            return False
+        if self.is_running:
+            logger.warning("バックグラウンド処理は既に実行中です")
+            return False
+        
+        try:
+            self.is_running = True
+            self.stop_event.clear()
+            
+            # 変更点 1: スレッドのターゲットを新しいラッパー関数に変更
+            self.background_thread = threading.Thread(
+                target=self._thread_entry_point,
+                name="BackgroundProcessor",
+                daemon=True
+            )
+            self.background_thread.start()
+            
+            self._setup_signal_handlers()
+            logger.info("バックグラウンド処理を開始しました")
+            return True
+        except Exception as e:
+            self.is_running = False
+            logger.error(f"バックグラウンド処理の開始に失敗: {e}")
+            return False
+
+    def stop_background_processing(self) -> bool:
+        if not self.is_running:
+            logger.info("バックグラウンド処理は実行されていません")
+            return True
+        
+        try:
+            logger.info("バックグラウンド処理の停止を開始します...")
+            self.stop_event.set()
+            if self.background_thread and self.background_thread.is_alive():
+                self.background_thread.join(timeout=10)
+                if self.background_thread.is_alive():
+                    logger.warning("バックグラウンドスレッドの停止がタイムアウトしました")
+                    return False
+            
+            self.is_running = False
+            logger.info("バックグラウンド処理を停止しました")
+            return True
+        except Exception as e:
+            logger.error(f"バックグラウンド処理の停止に失敗: {e}")
+            return False
+
+    # 変更点 2: スレッドのエントリーポイントとなる同期ラッパー関数を追加
+    def _thread_entry_point(self) -> None:
+        """バックグラウンドスレッド内でイベントループを実行するためのラッパー"""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            logger.info("バックグラウンドスレッドのイベントループを開始します。")
+            loop.run_until_complete(self._background_loop())
+        except Exception as e:
+            logger.error(f"バックグラウンドイベントループで致命的なエラー: {e}\n{traceback.format_exc()}")
+        finally:
+            logger.info("バックグラウンドスレッドのイベントループを終了します。")
+            loop.close()
+
+    # 変更点 3: メインループを async def に変更
+    async def _background_loop(self) -> None:
+        """バックグラウンド処理の非同期メインループ"""
+        logger.info("非同期バックグラウンド処理ループを開始します")
+        while not self.stop_event.is_set():
+            try:
+                current_time = datetime.now()
+                current_hour = current_time.hour
+                current_date = current_time.strftime("%Y-%m-%d")
+
+                if current_hour in self.target_hours:
+                    await self._check_and_run_batch(current_hour, current_date)
+                
+                if current_hour == self.cleanup_hour:
+                    await self._check_and_run_cleanup(current_date)
+                
+                # 変更点 4: 待機処理を asyncio.sleep に変更
+                # stop_eventをチェックしながら1秒ずつ待機することで、素早い停止を可能にする
+                for _ in range(self.check_interval):
+                    if self.stop_event.is_set():
+                        break
+                    await asyncio.sleep(1)
+
+            except Exception as e:
+                error_msg = f"バックグラウンド処理ループでエラーが発生: {e}"
+                logger.error(f"{error_msg}\n{traceback.format_exc()}")
+                if self.on_error:
+                    try:
+                        self.on_error(error_msg)
+                    except Exception as callback_error:
+                        logger.error(f"エラーコールバック実行エラー: {callback_error}")
+                await asyncio.sleep(min(self.check_interval * 2, 300))
+        
+        logger.info("非同期バックグラウンド処理ループを終了しました")
+    
+    async def _check_and_run_batch(self, hour: int, date: str) -> None:
+        """
+        バッチ処理の実行チェックと実行
+        
+        Args:
+            hour: 現在の時刻
+            date: 現在の日付
+        """
+        try:
+            # 既に今日実行済みかチェック
+            last_execution = self.last_execution_times.get(hour)
+            if last_execution and last_execution == date:
+                return  # 既に実行済み
+            
+            logger.info(f"{hour}時のバッチ処理を実行します")
+            
+            # バッチ処理を実行
+            result = await self.batch_scheduler.run_hourly_batch(hour)
+            
+            # 実行時刻を記録
+            self.last_execution_times[hour] = date
+            
+            # 完了コールバックを呼び出し
+            if self.on_batch_complete:
+                try:
+                    self.on_batch_complete(hour, result)
+                except Exception as callback_error:
+                    logger.error(f"バッチ完了コールバック実行エラー: {str(callback_error)}")
+            
+            if result.get("success", False):
+                logger.info(f"{hour}時のバッチ処理が完了しました - 処理数: {result.get('processed_count', 0)}")
+            else:
+                logger.error(f"{hour}時のバッチ処理が失敗しました: {result.get('error', '不明なエラー')}")
+            
+        except Exception as e:
+            error_msg = f"{hour}時のバッチ処理チェック中にエラーが発生: {str(e)}"
+            logger.error(f"{error_msg}\n{traceback.format_exc()}")
+            
+            if self.on_error:
+                try:
+                    self.on_error(error_msg)
+                except Exception as callback_error:
+                    logger.error(f"エラーコールバック実行エラー: {str(callback_error)}")
+    
+    async def _check_and_run_cleanup(self, date: str) -> None:
+        """
+        クリーンアップ処理の実行チェックと実行
+        
+        Args:
+            date: 現在の日付
+        """
+        try:
+            # 既に今日実行済みかチェック
+            if self.last_cleanup_date == date:
+                return  # 既に実行済み
+            
+            logger.info("古いデータのクリーンアップを実行します")
+            
+            # クリーンアップ処理を実行
+            result = await self.batch_scheduler.cleanup_old_data(self.cleanup_retention_days)
+            
+            # 実行日を記録
+            self.last_cleanup_date = date
+            
+            # 完了コールバックを呼び出し
+            if self.on_cleanup_complete:
+                try:
+                    self.on_cleanup_complete(result)
+                except Exception as callback_error:
+                    logger.error(f"クリーンアップ完了コールバック実行エラー: {str(callback_error)}")
+            
+            if result.get("success", False):
+                logger.info(f"クリーンアップが完了しました - 削除数: {result.get('deleted_letters', 0)}")
+            else:
+                logger.error(f"クリーンアップが失敗しました: {result.get('error', '不明なエラー')}")
+            
+        except Exception as e:
+            error_msg = f"クリーンアップ処理チェック中にエラーが発生: {str(e)}"
+            logger.error(f"{error_msg}\n{traceback.format_exc()}")
+            
+            if self.on_error:
+                try:
+                    self.on_error(error_msg)
+                except Exception as callback_error:
+                    logger.error(f"エラーコールバック実行エラー: {str(callback_error)}")
+    
+    def _setup_signal_handlers(self) -> None:
+        """シグナルハンドラーを設定"""
+        def signal_handler(signum, frame):
+            logger.info(f"シグナル {signum} を受信しました。バックグラウンド処理を停止します...")
+            self.stop_background_processing()
+            sys.exit(0)
+        
+        # SIGTERM と SIGINT のハンドラーを設定
+        signal.signal(signal.SIGTERM, signal_handler)
+        signal.signal(signal.SIGINT, signal_handler)
+    
+    def get_status(self) -> Dict[str, Any]:
+        """
+        バックグラウンド処理の状態を取得
+        
+        Returns:
+            Dict: 状態情報
+        """
+        return {
+            "is_running": self.is_running,
+            "enable_background_processing": self.enable_background_processing,
+            "target_hours": self.target_hours,
+            "check_interval": self.check_interval,
+            "cleanup_hour": self.cleanup_hour,
+            "cleanup_retention_days": self.cleanup_retention_days,
+            "last_execution_times": self.last_execution_times.copy(),
+            "last_cleanup_date": self.last_cleanup_date,
+            "thread_alive": self.background_thread.is_alive() if self.background_thread else False,
+            "current_time": datetime.now().isoformat()
+        }
+    
+    async def force_run_batch(self, hour: int) -> Dict[str, Any]:
+        """
+        指定時刻のバッチ処理を強制実行
+        
+        Args:
+            hour: 実行対象の時刻
+            
+        Returns:
+            Dict: 実行結果
+        """
+        try:
+            if hour not in self.target_hours:
+                return {
+                    "success": False,
+                    "error": f"無効な時刻が指定されました: {hour} (有効: {self.target_hours})"
+                }
+            
+            logger.info(f"{hour}時のバッチ処理を強制実行します")
+            
+            result = await self.batch_scheduler.run_hourly_batch(hour)
+            
+            # 実行時刻を記録
+            current_date = datetime.now().strftime("%Y-%m-%d")
+            self.last_execution_times[hour] = current_date
+            
+            return result
+            
+        except Exception as e:
+            error_msg = f"バッチ処理の強制実行中にエラーが発生: {str(e)}"
+            logger.error(f"{error_msg}\n{traceback.format_exc()}")
+            return {
+                "success": False,
+                "error": error_msg
+            }
+    
+    async def force_run_cleanup(self) -> Dict[str, Any]:
+        """
+        クリーンアップ処理を強制実行
+        
+        Returns:
+            Dict: 実行結果
+        """
+        try:
+            logger.info("クリーンアップ処理を強制実行します")
+            
+            result = await self.batch_scheduler.cleanup_old_data(self.cleanup_retention_days)
+            
+            # 実行日を記録
+            current_date = datetime.now().strftime("%Y-%m-%d")
+            self.last_cleanup_date = current_date
+            
+            return result
+            
+        except Exception as e:
+            error_msg = f"クリーンアップ処理の強制実行中にエラーが発生: {str(e)}"
+            logger.error(f"{error_msg}\n{traceback.format_exc()}")
+            return {
+                "success": False,
+                "error": error_msg
+            }
+    
+    def set_callbacks(self, 
+                     on_batch_complete: Optional[Callable] = None,
+                     on_cleanup_complete: Optional[Callable] = None,
+                     on_error: Optional[Callable] = None) -> None:
+        """
+        コールバック関数を設定
+        
+        Args:
+            on_batch_complete: バッチ処理完了時のコールバック
+            on_cleanup_complete: クリーンアップ完了時のコールバック
+            on_error: エラー発生時のコールバック
+        """
+        self.on_batch_complete = on_batch_complete
+        self.on_cleanup_complete = on_cleanup_complete
+        self.on_error = on_error
+        
+        logger.info("コールバック関数を設定しました")
+    
+    async def get_processing_statistics(self, days: int = 7) -> Dict[str, Any]:
+        """
+        処理統計情報を取得
+        
+        Args:
+            days: 統計対象日数
+            
+        Returns:
+            Dict: 統計情報
+        """
+        try:
+            # バッチスケジューラーから統計を取得
+            batch_stats = await self.batch_scheduler.get_batch_statistics(days)
+            
+            # ストレージ統計を取得
+            storage_stats = await self.storage_manager.get_storage_stats()
+            
+            # バックグラウンド処理の状態を追加
+            status = self.get_status()
+            
+            return {
+                "background_processor": status,
+                "batch_statistics": batch_stats,
+                "storage_statistics": storage_stats,
+                "generated_at": datetime.now().isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"統計情報取得エラー: {str(e)}")
+            return {"error": str(e)}
+    
+    def __enter__(self):
+        """コンテキストマネージャーのエントリー"""
+        self.start_background_processing()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """コンテキストマネージャーの終了"""
+        self.stop_background_processing()
+
+
+class StreamlitBackgroundIntegration:
+    """Streamlitアプリとバックグラウンド処理の統合クラス"""
+    
+    def __init__(self):
+        self.background_processor = None
+        self.is_initialized = False
+    
+    def initialize(self, storage_manager: Optional[AsyncStorageManager] = None) -> bool:
+        """
+        バックグラウンド処理を初期化
+        
+        Args:
+            storage_manager: ストレージマネージャー
+            
+        Returns:
+            bool: 初期化成功フラグ
+        """
+        try:
+            if self.is_initialized:
+                return True
+            
+            self.background_processor = BackgroundProcessor(storage_manager)
+            
+            # コールバック関数を設定
+            self.background_processor.set_callbacks(
+                on_batch_complete=self._on_batch_complete,
+                on_cleanup_complete=self._on_cleanup_complete,
+                on_error=self._on_error
+            )
+            
+            # バックグラウンド処理を開始
+            success = self.background_processor.start_background_processing()
+            
+            if success:
+                self.is_initialized = True
+                logger.info("Streamlitバックグラウンド統合を初期化しました")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"バックグラウンド統合の初期化に失敗: {str(e)}")
+            return False
+    
+    def shutdown(self) -> bool:
+        """
+        バックグラウンド処理を終了
+        
+        Returns:
+            bool: 終了成功フラグ
+        """
+        try:
+            if not self.is_initialized or not self.background_processor:
+                return True
+            
+            success = self.background_processor.stop_background_processing()
+            
+            if success:
+                self.is_initialized = False
+                logger.info("Streamlitバックグラウンド統合を終了しました")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"バックグラウンド統合の終了に失敗: {str(e)}")
+            return False
+    
+    def get_status(self) -> Dict[str, Any]:
+        """統合状態を取得"""
+        if not self.is_initialized or not self.background_processor:
+            return {"initialized": False, "running": False}
+        
+        status = self.background_processor.get_status()
+        status["initialized"] = self.is_initialized
+        
+        return status
+    
+    async def get_statistics(self, days: int = 7) -> Dict[str, Any]:
+        """統計情報を取得"""
+        if not self.is_initialized or not self.background_processor:
+            return {"error": "バックグラウンド処理が初期化されていません"}
+        
+        return await self.background_processor.get_processing_statistics(days)
+    
+    def _on_batch_complete(self, hour: int, result: Dict[str, Any]) -> None:
+        """バッチ処理完了時のコールバック"""
+        logger.info(f"バッチ処理完了通知 - {hour}時: {result.get('success', False)}")
+        # Streamlitの状態更新やキャッシュクリアなどを実装可能
+    
+    def _on_cleanup_complete(self, result: Dict[str, Any]) -> None:
+        """クリーンアップ完了時のコールバック"""
+        logger.info(f"クリーンアップ完了通知: {result.get('success', False)}")
+        # Streamlitの状態更新やキャッシュクリアなどを実装可能
+    
+    def _on_error(self, error_message: str) -> None:
+        """エラー発生時のコールバック"""
+        logger.error(f"バックグラウンド処理エラー通知: {error_message}")
+        # Streamlitのエラー表示やアラート機能を実装可能
+
+
+# グローバルインスタンス（Streamlitアプリで使用）
+streamlit_background = StreamlitBackgroundIntegration()
+
+
+# テスト用の関数
+async def test_background_processor():
+    """BackgroundProcessorのテスト"""
+    import tempfile
+    
+    # 一時ディレクトリでテスト
+    with tempfile.TemporaryDirectory() as temp_dir:
+        test_file = os.path.join(temp_dir, "test_letters.json")
+        storage = AsyncStorageManager(test_file)
+        
+        print("=== BackgroundProcessorテスト開始 ===")
+        
+        # バックグラウンドプロセッサーのテスト
+        processor = BackgroundProcessor(storage)
+        
+        # 状態確認テスト
+        status = processor.get_status()
+        print(f"✓ 状態確認テスト: {status['is_running']}")
+        
+        # 強制バッチ実行テスト
+        batch_result = await processor.force_run_batch(2)
+        print(f"✓ 強制バッチ実行テスト: {batch_result['success']}")
+        
+        # 強制クリーンアップテスト
+        cleanup_result = await processor.force_run_cleanup()
+        print(f"✓ 強制クリーンアップテスト: {cleanup_result['success']}")
+        
+        # 統計情報テスト
+        stats = await processor.get_processing_statistics()
+        print(f"✓ 統計情報取得テスト: {'error' not in stats}")
+        
+        print("=== 全てのテストが完了しました！ ===")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_background_processor())

batch_scheduler.py

@@ -0,0 +1,587 @@
+"""
+バッチスケジューラークラス
+2時、3時、4時の時刻別バッチ処理機能を実装し、
+指定時刻の未処理リクエストを処理する機能を提供します。
+"""
+
+import asyncio
+import os
+from datetime import datetime, timedelta
+from typing import Dict, Any, List, Optional
+import logging
+import traceback
+
+from letter_request_manager import RequestManager
+from letter_generator import LetterGenerator
+from async_storage_manager import AsyncStorageManager
+from async_rate_limiter import AsyncRateLimitManager
+from letter_user_manager import UserManager
+
+# ログ設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class BatchSchedulerError(Exception):
+    """バッチスケジューラー関連のエラー"""
+    pass
+
+
+class BatchScheduler:
+    """非同期バッチ処理スケジューラー"""
+    
+    def __init__(self, storage_manager: Optional[AsyncStorageManager] = None):
+        """
+        バッチスケジューラーを初期化
+        
+        Args:
+            storage_manager: ストレージマネージャー（指定しない場合は新規作成）
+        """
+        # ストレージマネージャーの初期化
+        if storage_manager is None:
+            storage_path = os.getenv("STORAGE_PATH", "/mnt/data/letters.json")
+            self.storage_manager = AsyncStorageManager(storage_path)
+        else:
+            self.storage_manager = storage_manager
+        
+        # 依存コンポーネントの初期化
+        self.rate_limiter = AsyncRateLimitManager(self.storage_manager)
+        self.request_manager = RequestManager(self.storage_manager, self.rate_limiter)
+        self.letter_generator = LetterGenerator()
+        self.user_manager = UserManager(self.storage_manager)
+        
+        # 設定値
+        self.available_hours = [2, 3, 4]  # 2時、3時、4時
+        self.max_concurrent_generations = int(os.getenv("MAX_CONCURRENT_GENERATIONS", "3"))
+        self.generation_timeout = int(os.getenv("GENERATION_TIMEOUT", "300"))  # 5分
+        self.retry_failed_requests = os.getenv("RETRY_FAILED_REQUESTS", "true").lower() == "true"
+        
+        logger.info(f"BatchScheduler初期化完了 - 対象時刻: {self.available_hours}")
+    
+    async def run_hourly_batch(self, hour: int) -> Dict[str, Any]:
+        """
+        指定時刻のバッチ処理を実行
+        
+        Args:
+            hour: 実行時刻（2, 3, 4のいずれか）
+            
+        Returns:
+            Dict: バッチ処理の結果
+        """
+        start_time = datetime.now()
+        batch_id = f"{start_time.strftime('%Y%m%d_%H%M%S')}_{hour}"
+        
+        logger.info(f"=== {hour}時のバッチ処理開始 (ID: {batch_id}) ===")
+        
+        # 時刻の検証
+        if hour not in self.available_hours:
+            error_msg = f"無効な時刻が指定されました: {hour}時 (有効: {self.available_hours})"
+            logger.error(error_msg)
+            return {
+                "success": False,
+                "error": error_msg,
+                "batch_id": batch_id,
+                "hour": hour,
+                "start_time": start_time.isoformat(),
+                "end_time": datetime.now().isoformat()
+            }
+        
+        try:
+            # バッチ実行の記録開始
+            await self._record_batch_start(batch_id, hour, start_time)
+            
+            # 指定時刻の未処理リクエストを処理
+            result = await self.process_pending_requests_for_hour(hour)
+            
+            # バッチ実行の記録完了
+            end_time = datetime.now()
+            await self._record_batch_completion(batch_id, hour, start_time, end_time, result)
+            
+            execution_time = (end_time - start_time).total_seconds()
+            
+            logger.info(f"=== {hour}時のバッチ処理完了 (所要時間: {execution_time:.2f}秒) ===")
+            
+            return {
+                "success": True,
+                "batch_id": batch_id,
+                "hour": hour,
+                "start_time": start_time.isoformat(),
+                "end_time": end_time.isoformat(),
+                "execution_time": execution_time,
+                "processed_count": result.get("processed_count", 0),
+                "success_count": result.get("success_count", 0),
+                "failed_count": result.get("failed_count", 0),
+                "errors": result.get("errors", [])
+            }
+            
+        except Exception as e:
+            end_time = datetime.now()
+            execution_time = (end_time - start_time).total_seconds()
+            error_msg = f"バッチ処理中にエラーが発生しました: {str(e)}"
+            
+            logger.error(f"{error_msg}\n{traceback.format_exc()}")
+            
+            # エラーの記録
+            await self._record_batch_error(batch_id, hour, start_time, end_time, error_msg)
+            
+            return {
+                "success": False,
+                "error": error_msg,
+                "batch_id": batch_id,
+                "hour": hour,
+                "start_time": start_time.isoformat(),
+                "end_time": end_time.isoformat(),
+                "execution_time": execution_time
+            }
+    
+    async def process_pending_requests_for_hour(self, hour: int) -> Dict[str, Any]:
+        """
+        指定時刻の未処理リクエストを処理
+        
+        Args:
+            hour: 処理対象の時刻
+            
+        Returns:
+            Dict: 処理結果の詳細
+        """
+        try:
+            # 未処理リクエストを取得
+            pending_requests = await self.request_manager.get_pending_requests_by_hour(hour)
+            
+            if not pending_requests:
+                logger.info(f"{hour}時の未処理リクエストはありません")
+                return {
+                    "processed_count": 0,
+                    "success_count": 0,
+                    "failed_count": 0,
+                    "errors": []
+                }
+            
+            logger.info(f"{hour}時の未処理リクエスト数: {len(pending_requests)}")
+            
+            # 並行処理用のセマフォ
+            semaphore = asyncio.Semaphore(self.max_concurrent_generations)
+            
+            # 各リクエストを並行処理
+            tasks = []
+            for request in pending_requests:
+                task = self._process_single_request(semaphore, request)
+                tasks.append(task)
+            
+            # 全てのタスクを実行
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            # 結果を集計
+            success_count = 0
+            failed_count = 0
+            errors = []
+            
+            for i, result in enumerate(results):
+                if isinstance(result, Exception):
+                    failed_count += 1
+                    error_msg = f"リクエスト処理例外: {str(result)}"
+                    errors.append({
+                        "request_index": i,
+                        "user_id": pending_requests[i].get("user_id", "unknown"),
+                        "error": error_msg
+                    })
+                    logger.error(error_msg)
+                elif result.get("success", False):
+                    success_count += 1
+                else:
+                    failed_count += 1
+                    errors.append({
+                        "request_index": i,
+                        "user_id": pending_requests[i].get("user_id", "unknown"),
+                        "error": result.get("error", "不明なエラー")
+                    })
+            
+            logger.info(f"処理完了 - 成功: {success_count}, 失敗: {failed_count}")
+            
+            return {
+                "processed_count": len(pending_requests),
+                "success_count": success_count,
+                "failed_count": failed_count,
+                "errors": errors
+            }
+            
+        except Exception as e:
+            error_msg = f"未処理リクエスト処理中にエラーが発生: {str(e)}"
+            logger.error(f"{error_msg}\n{traceback.format_exc()}")
+            return {
+                "processed_count": 0,
+                "success_count": 0,
+                "failed_count": 0,
+                "errors": [{"error": error_msg}]
+            }
+    
+    async def _process_single_request(self, semaphore: asyncio.Semaphore, request: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        単一のリクエストを処理
+        
+        Args:
+            semaphore: 並行処理制御用のセマフォ
+            request: 処理対象のリクエスト
+            
+        Returns:
+            Dict: 処理結果
+        """
+        async with semaphore:
+            user_id = request["user_id"]
+            theme = request["theme"]
+            date = request["date"]
+            
+            try:
+                logger.info(f"手紙生成開始 - ユーザー: {user_id}, テーマ: {theme[:50]}...")
+                
+                # タイムアウト付きで手紙生成を実行
+                user_history = await self.user_manager.get_user_profile(user_id)
+                
+                generation_task = self.letter_generator.generate_letter(user_id, theme, user_history)
+                letter_result = await asyncio.wait_for(generation_task, timeout=self.generation_timeout)
+                
+                # 生成された手紙をストレージに保存
+                await self._save_generated_letter(user_id, date, theme, letter_result)
+                
+                # リクエストを完了としてマーク
+                await self.request_manager.mark_request_processed(user_id, date, "completed")
+                
+                # ユーザー履歴を更新
+                await self.user_manager.update_user_history(user_id, {
+                    "date": date,
+                    "theme": theme,
+                    "status": "completed",
+                    "generated_at": datetime.now().isoformat()
+                })
+                
+                logger.info(f"手紙生成完了 - ユーザー: {user_id}")
+                
+                return {
+                    "success": True,
+                    "user_id": user_id,
+                    "theme": theme,
+                    "generation_time": letter_result["metadata"].get("generation_time", 0)
+                }
+                
+            except asyncio.TimeoutError:
+                error_msg = f"手紙生成がタイムアウトしました（{self.generation_timeout}秒）"
+                logger.error(f"{error_msg} - ユーザー: {user_id}")
+                
+                await self.request_manager.mark_request_failed(user_id, date, error_msg)
+                
+                return {
+                    "success": False,
+                    "user_id": user_id,
+                    "error": error_msg
+                }
+                
+            except Exception as e:
+                error_msg = f"手紙生成中にエラーが発生: {str(e)}"
+                logger.error(f"{error_msg} - ユーザー: {user_id}\n{traceback.format_exc()}")
+                
+                await self.request_manager.mark_request_failed(user_id, date, error_msg)
+                
+                return {
+                    "success": False,
+                    "user_id": user_id,
+                    "error": error_msg
+                }
+    
+    async def _save_generated_letter(self, user_id: str, date: str, theme: str, letter_result: Dict[str, Any]) -> None:
+        """
+        生成された手紙をストレージに保存
+        
+        Args:
+            user_id: ユーザーID
+            date: 日付
+            theme: テーマ
+            letter_result: 生成結果
+        """
+        try:
+            user_data = await self.storage_manager.get_user_data(user_id)
+            
+            # 手紙データを作成
+            letter_data = {
+                "theme": theme,
+                "content": letter_result["content"],
+                "status": "completed",
+                "generated_at": datetime.now().isoformat(),
+                "metadata": letter_result["metadata"]
+            }
+            
+            # ユーザーデータに追加
+            user_data["letters"][date] = letter_data
+            user_data["profile"]["total_letters"] = user_data["profile"].get("total_letters", 0) + 1
+            user_data["profile"]["last_request"] = date
+            
+            # ストレージに保存
+            await self.storage_manager.update_user_data(user_id, user_data)
+            
+            logger.info(f"手紙をストレージに保存しました - ユーザー: {user_id}, 日付: {date}")
+            
+        except Exception as e:
+            logger.error(f"手紙保存エラー - ユーザー: {user_id}, 日付: {date}: {str(e)}")
+            raise
+    
+    async def _record_batch_start(self, batch_id: str, hour: int, start_time: datetime) -> None:
+        """バッチ実行開始を記録"""
+        try:
+            system_info = await self.storage_manager.get_system_info()
+            
+            if "batch_runs" not in system_info:
+                system_info["batch_runs"] = {}
+            
+            system_info["batch_runs"][batch_id] = {
+                "hour": hour,
+                "start_time": start_time.isoformat(),
+                "status": "running"
+            }
+            
+            await self.storage_manager.update_system_info(system_info)
+            
+        except Exception as e:
+            logger.error(f"バッチ開始記録エラー: {str(e)}")
+    
+    async def _record_batch_completion(self, batch_id: str, hour: int, start_time: datetime, 
+                                     end_time: datetime, result: Dict[str, Any]) -> None:
+        """バッチ実行完了を記録"""
+        try:
+            system_info = await self.storage_manager.get_system_info()
+            
+            if batch_id in system_info.get("batch_runs", {}):
+                system_info["batch_runs"][batch_id].update({
+                    "end_time": end_time.isoformat(),
+                    "status": "completed",
+                    "execution_time": (end_time - start_time).total_seconds(),
+                    "processed_count": result.get("processed_count", 0),
+                    "success_count": result.get("success_count", 0),
+                    "failed_count": result.get("failed_count", 0),
+                    "error_count": len(result.get("errors", []))
+                })
+                
+                await self.storage_manager.update_system_info(system_info)
+            
+        except Exception as e:
+            logger.error(f"バッチ完了記録エラー: {str(e)}")
+    
+    async def _record_batch_error(self, batch_id: str, hour: int, start_time: datetime, 
+                                end_time: datetime, error_msg: str) -> None:
+        """バッチ実行エラーを記録"""
+        try:
+            system_info = await self.storage_manager.get_system_info()
+            
+            if batch_id in system_info.get("batch_runs", {}):
+                system_info["batch_runs"][batch_id].update({
+                    "end_time": end_time.isoformat(),
+                    "status": "failed",
+                    "execution_time": (end_time - start_time).total_seconds(),
+                    "error": error_msg
+                })
+                
+                await self.storage_manager.update_system_info(system_info)
+            
+        except Exception as e:
+            logger.error(f"バッチエラー記録エラー: {str(e)}")
+    
+    def schedule_all_hours(self) -> None:
+        """
+        全ての対象時刻でのスケジュール設定
+        注意: この関数は実際のスケジューリングライブラリと組み合わせて使用する
+        """
+        logger.info("バッチスケジュールを設定します")
+        
+        for hour in self.available_hours:
+            logger.info(f"  - {hour}:00 に手紙生成バッチを設定")
+        
+        # 実際のスケジューリングは外部ライブラリ（APScheduler等）で実装
+        # ここでは設定情報のログ出力のみ
+        logger.info("スケジュール設定完了（実際の実行は外部スケジューラーが必要）")
+    
+    async def cleanup_old_data(self, days: int = 90) -> Dict[str, Any]:
+        """
+        古いデータの自動削除
+        
+        Args:
+            days: 保持日数
+            
+        Returns:
+            Dict: 削除結果
+        """
+        try:
+            logger.info(f"{days}日以前の古いデータを削除します")
+            
+            # ストレージマネージャーの削除機能を使用
+            deleted_count = await self.storage_manager.cleanup_old_data(days)
+            
+            # リクエストマネージャーの削除機能も使用
+            deleted_requests = await self.request_manager.cleanup_old_requests(days)
+            
+            # バックアップの作成
+            backup_path = await self.storage_manager.backup_data()
+            
+            result = {
+                "success": True,
+                "deleted_letters": deleted_count,
+                "deleted_requests": deleted_requests,
+                "backup_created": backup_path,
+                "cleanup_date": datetime.now().isoformat()
+            }
+            
+            logger.info(f"古いデータ削除完了: {result}")
+            return result
+            
+        except Exception as e:
+            error_msg = f"古いデータ削除中にエラーが発生: {str(e)}"
+            logger.error(f"{error_msg}\n{traceback.format_exc()}")
+            
+            return {
+                "success": False,
+                "error": error_msg,
+                "cleanup_date": datetime.now().isoformat()
+            }
+    
+    async def get_batch_statistics(self, days: int = 7) -> Dict[str, Any]:
+        """
+        バッチ処理の統計情報を取得
+        
+        Args:
+            days: 統計対象日数
+            
+        Returns:
+            Dict: 統計情報
+        """
+        try:
+            system_info = await self.storage_manager.get_system_info()
+            batch_runs = system_info.get("batch_runs", {})
+            
+            # 指定日数以内のバッチ実行を抽出
+            cutoff_date = datetime.now() - timedelta(days=days)
+            recent_batches = []
+            
+            for batch_id, batch_info in batch_runs.items():
+                try:
+                    start_time = datetime.fromisoformat(batch_info["start_time"])
+                    if start_time >= cutoff_date:
+                        recent_batches.append(batch_info)
+                except (ValueError, KeyError):
+                    continue
+            
+            # 統計を計算
+            total_runs = len(recent_batches)
+            successful_runs = len([b for b in recent_batches if b.get("status") == "completed"])
+            failed_runs = len([b for b in recent_batches if b.get("status") == "failed"])
+            
+            total_processed = sum(b.get("processed_count", 0) for b in recent_batches)
+            total_success = sum(b.get("success_count", 0) for b in recent_batches)
+            total_failed = sum(b.get("failed_count", 0) for b in recent_batches)
+            
+            avg_execution_time = 0
+            if recent_batches:
+                execution_times = [b.get("execution_time", 0) for b in recent_batches if b.get("execution_time")]
+                if execution_times:
+                    avg_execution_time = sum(execution_times) / len(execution_times)
+            
+            # 時刻別統計
+            hourly_stats = {hour: {"runs": 0, "processed": 0, "success": 0} for hour in self.available_hours}
+            
+            for batch in recent_batches:
+                hour = batch.get("hour")
+                if hour in hourly_stats:
+                    hourly_stats[hour]["runs"] += 1
+                    hourly_stats[hour]["processed"] += batch.get("processed_count", 0)
+                    hourly_stats[hour]["success"] += batch.get("success_count", 0)
+            
+            return {
+                "period_days": days,
+                "total_runs": total_runs,
+                "successful_runs": successful_runs,
+                "failed_runs": failed_runs,
+                "success_rate": (successful_runs / total_runs * 100) if total_runs > 0 else 0,
+                "total_processed": total_processed,
+                "total_success": total_success,
+                "total_failed": total_failed,
+                "processing_success_rate": (total_success / total_processed * 100) if total_processed > 0 else 0,
+                "avg_execution_time": avg_execution_time,
+                "hourly_stats": hourly_stats,
+                "generated_at": datetime.now().isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"統計情報取得エラー: {str(e)}")
+            return {"error": str(e)}
+    
+    async def test_batch_processing(self, test_hour: int = 2) -> Dict[str, Any]:
+        """
+        バッチ処理のテスト実行
+        
+        Args:
+            test_hour: テスト対象の時刻
+            
+        Returns:
+            Dict: テスト結果
+        """
+        try:
+            logger.info(f"バッチ処理テストを開始します（{test_hour}時）")
+            
+            # API接続テスト
+            api_status = await self.letter_generator.check_api_connections()
+            if not api_status.get("overall", False):
+                return {
+                    "success": False,
+                    "error": "API接続テストに失敗しました",
+                    "api_status": api_status
+                }
+            
+            # テスト用のバッチ処理を実行
+            result = await self.run_hourly_batch(test_hour)
+            
+            return {
+                "success": True,
+                "message": "バッチ処理テスト完了",
+                "api_status": api_status,
+                "batch_result": result
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"バッチ処理テスト中にエラーが発生: {str(e)}"
+            }
+
+
+# テスト用の関数
+async def test_batch_scheduler():
+    """BatchSchedulerのテスト"""
+    import tempfile
+    import uuid
+    
+    # 一時ディレクトリでテスト
+    with tempfile.TemporaryDirectory() as temp_dir:
+        test_file = os.path.join(temp_dir, "test_letters.json")
+        storage = AsyncStorageManager(test_file)
+        scheduler = BatchScheduler(storage)
+        
+        print("=== BatchSchedulerテスト開始 ===")
+        
+        # テスト用のリクエストを作成
+        user_id = str(uuid.uuid4())
+        success, message = await scheduler.request_manager.submit_request(user_id, "テストテーマ", 2)
+        print(f"✓ テストリクエスト作成: {success} - {message}")
+        
+        # バッチ処理テスト
+        result = await scheduler.run_hourly_batch(2)
+        print(f"✓ バッチ処理テスト: {result['success']}")
+        
+        # 統計情報テスト
+        stats = await scheduler.get_batch_statistics()
+        print(f"✓ 統計情報取得テスト: {stats}")
+        
+        # 古いデータ削除テスト
+        cleanup_result = await scheduler.cleanup_old_data(0)  # 全て削除
+        print(f"✓ データ削除テスト: {cleanup_result['success']}")
+        
+        print("=== 全てのテストが完了しました！ ===")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_batch_scheduler())

components_chat_interface.py

@@ -0,0 +1,897 @@
+"""
+チャットインターフェースコンポーネント
+Streamlitのチャット機能を使用したメッセージ表示と入力処理
+マスクアイコンとフリップアニメーション機能を含む
+"""
+import streamlit as st
+import logging
+import re
+import uuid
+from typing import List, Dict, Optional, Tuple
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+class ChatInterface:
+    """チャットインターフェースを管理するクラス"""
+    
+    def __init__(self, max_input_length: int = 1000):
+        """
+        Args:
+            max_input_length: 入力メッセージの最大長
+        """
+        self.max_input_length = max_input_length
+    
+    def render_chat_history(self, messages: List[Dict[str, str]], 
+                          memory_summary: str = "") -> None:
+        """
+        チャット履歴を表示する（マスク機能付き、最適化版）
+        
+        Args:
+            messages: チャットメッセージのリスト
+            memory_summary: メモリサマリー（重要単語から生成）
+        """
+        logger.info(f"🎯 render_chat_history 開始: {len(messages) if messages else 0}件のメッセージ")
+        try:
+            # 初期メッセージの存在確認と復元
+            if messages:
+                initial_messages = [msg for msg in messages if msg.get('is_initial', False)]
+                if not initial_messages:
+                    logger.warning("初期メッセージが見つかりません - 復元を試行")
+                    # 初期メッセージが存在しない場合は先頭に追加
+                    initial_message = {"role": "assistant", "content": "何の用？遊びに来たの？", "is_initial": True}
+                    messages.insert(0, initial_message)
+                    logger.info("初期メッセージを復元しました")
+            
+            # 履歴表示の重複実行を防ぐ（改良版）
+            # セッション固有のレンダリング状態を管理
+            if 'chat_render_state' not in st.session_state:
+                st.session_state.chat_render_state = {
+                    'last_messages_hash': None,
+                    'render_count': 0,
+                    'last_render_time': 0
+                }
+            
+            # メッセージ内容とポチモード状態を含むハッシュを生成
+            show_all_hidden = st.session_state.get('show_all_hidden', False)
+            messages_with_state = {
+                'messages': [{'role': msg.get('role'), 'content': msg.get('content', '')[:100]} for msg in messages],  # 内容を短縮してハッシュ計算を軽量化
+                'show_all_hidden': show_all_hidden,
+                'message_count': len(messages)
+            }
+            
+            import time
+            current_time = time.time()
+            messages_hash = hash(str(messages_with_state))
+            last_render_hash = st.session_state.chat_render_state['last_messages_hash']
+            
+            # 短時間での連続レンダリングを防止（0.5秒以内の再レンダリングを制限）
+            time_since_last_render = current_time - st.session_state.chat_render_state['last_render_time']
+            if time_since_last_render < 0.5 and last_render_hash == messages_hash:
+                logger.debug(f"短時間での重複レンダリングをスキップ（{time_since_last_render:.2f}秒前）")
+                return
+            
+            # 強制表示条件をより厳密に制御
+            force_render_conditions = [
+                st.session_state.get('tutorial_start_requested', False),
+                st.session_state.get('tutorial_skip_requested', False), 
+                st.session_state.get('show_all_hidden_changed', False),
+                st.session_state.get('force_chat_rerender', False)  # 明示的な強制レンダリングフラグ
+            ]
+            
+            should_force_render = any(force_render_conditions)
+            
+            # ハッシュが同じで強制表示条件もない場合はスキップ
+            if last_render_hash == messages_hash and not should_force_render:
+                logger.debug("チャット履歴表示をスキップ（変更なし）")
+                return
+            
+            # レンダリング実行（ログ削除で軽量化）
+            
+            # レンダリング状態を更新
+            st.session_state.chat_render_state['last_messages_hash'] = messages_hash
+            st.session_state.chat_render_state['render_count'] += 1
+            st.session_state.chat_render_state['last_render_time'] = current_time
+            
+            # メモリサマリーがある場合は表示
+            if memory_summary:
+                with st.expander("💭 過去の会話の記憶", expanded=False):
+                    st.info(memory_summary)
+            
+            # 独自のチャット表示（st.chat_messageを使わない安定版）
+            if not messages:
+                st.info("まだメッセージがありません。下のチャット欄で麻理に話しかけてみてください。")
+                return
+            
+            for i, message in enumerate(messages):
+                role = message.get("role", "user")
+                content = message.get("content", "")
+                timestamp = message.get("timestamp")
+                is_initial = message.get("is_initial", False)
+                message_id = message.get("message_id", f"msg_{i}")
+                
+                # 独自のチャットバブル表示
+                self._render_custom_chat_bubble(role, content, is_initial, message_id, timestamp)
+            
+            # 履歴表示完了をマーク
+            # 既にレンダリング状態は上で更新済み
+            
+            logger.debug(f"チャット履歴表示完了（{len(messages)}件）")
+            
+            # 強制表示フラグをクリア（表示完了後に実行）
+            if st.session_state.get('show_all_hidden_changed', False):
+                st.session_state.show_all_hidden_changed = False
+                logger.info("犬のボタン状態変更フラグをクリアしました")
+            
+            if st.session_state.get('force_chat_rerender', False):
+                st.session_state.force_chat_rerender = False
+                logger.info("強制チャット再レンダリングフラグをクリアしました")
+                        
+        except Exception as e:
+            logger.error(f"チャット履歴表示エラー: {e}")
+            st.error("チャット履歴の表示中にエラーが発生しました。")
+    
+    def _render_custom_chat_bubble(self, role: str, content: str, is_initial: bool, message_id: str, timestamp: str = None):
+        """独自のチャットバブル表示（st.chat_messageを使わない安定版）"""
+        logger.info(f"🎨 カスタムチャットバブル開始: {role} - '{content[:30]}...' - 初期:{is_initial}")
+        try:
+            # チャットバブルのCSS
+            bubble_css = """
+            <style>
+            .custom-chat-container {
+                margin: 10px 0;
+                display: flex;
+                flex-direction: column;
+            }
+            
+            .custom-chat-bubble {
+                max-width: 80%;
+                padding: 12px 16px;
+                border-radius: 18px;
+                margin: 4px 0;
+                word-wrap: break-word;
+                line-height: 1.5;
+                font-size: 18px;
+            }
+            
+            .user-bubble {
+                background: #007bff;
+                color: white;
+                align-self: flex-end;
+                margin-left: auto;
+            }
+            
+            .assistant-bubble {
+                background: #f1f3f4;
+                color: #333;
+                align-self: flex-start;
+                margin-right: auto;
+                border: 1px solid #e0e0e0;
+            }
+            
+            .initial-message-bubble {
+                background: #e8f5e8 !important;
+                color: #2d5a2d !important;
+                font-weight: 500 !important;
+                border: 2px solid #4caf50 !important;
+            }
+            
+            .chat-avatar {
+                width: 32px;
+                height: 32px;
+                border-radius: 50%;
+                margin: 0 8px;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                font-size: 16px;
+                flex-shrink: 0;
+            }
+            
+            .user-avatar {
+                background: #007bff;
+                color: white;
+            }
+            
+            .assistant-avatar {
+                background: #ff69b4;
+                color: white;
+            }
+            
+            .chat-row {
+                display: flex;
+                align-items: flex-start;
+                margin: 8px 0;
+            }
+            
+            .user-row {
+                flex-direction: row-reverse;
+            }
+            
+            .assistant-row {
+                flex-direction: row;
+            }
+            
+            .timestamp {
+                font-size: 0.8em;
+                color: #666;
+                margin-top: 4px;
+                text-align: center;
+            }
+            </style>
+            """
+            
+            st.markdown(bubble_css, unsafe_allow_html=True)
+            
+            # アバターとバブルのスタイル決定
+            if role == "user":
+                avatar_class = "user-avatar"
+                bubble_class = "user-bubble"
+                row_class = "user-row"
+                avatar_icon = "👤"
+            else:
+                avatar_class = "assistant-avatar"
+                bubble_class = "assistant-bubble"
+                row_class = "assistant-row"
+                avatar_icon = "🤖"
+                
+                # 初期メッセージの場合は特別なスタイル
+                if is_initial:
+                    bubble_class += " initial-message-bubble"
+                    avatar_icon = "💬"
+            
+            # コンテンツのHTMLエスケープ処理（HTMLタグとStreamlitクラス名を完全に除去）
+            import html
+            import re
+            
+            # HTMLタグとStreamlitの内部クラス名を完全に除去
+            # 1. HTMLタグを除去（開始・終了タグ両方）
+            clean_content = re.sub(r'<[^>]*>', '', content)
+            
+            # 2. Streamlitの内部クラス名を除去（より包括的）
+            clean_content = re.sub(r'st-emotion-cache-[a-zA-Z0-9]+', '', clean_content)
+            clean_content = re.sub(r'class="[^"]*st-emotion-cache[^"]*"', '', clean_content)
+            clean_content = re.sub(r'class="[^"]*st-[^"]*"', '', clean_content)
+            clean_content = re.sub(r"class='[^']*st-emotion-cache[^']*'", '', clean_content)
+            clean_content = re.sub(r"class='[^']*st-[^']*'", '', clean_content)
+            
+            # 3. HTML属性を除去
+            clean_content = re.sub(r'data-testid="[^"]*"', '', clean_content)
+            clean_content = re.sub(r'data-[^=]*="[^"]*"', '', clean_content)
+            clean_content = re.sub(r'class="[^"]*"', '', clean_content)
+            clean_content = re.sub(r"class='[^']*'", '', clean_content)
+            clean_content = re.sub(r'id="[^"]*"', '', clean_content)
+            clean_content = re.sub(r"id='[^']*'", '', clean_content)
+            
+            # 4. その他のHTML関連文字列を除去
+            clean_content = re.sub(r'&[a-zA-Z0-9#]+;', '', clean_content)  # HTMLエンティティ
+            clean_content = re.sub(r'[<>]', '', clean_content)  # 残った角括弧
+            
+            # 5. 余分な空白を除去
+            clean_content = re.sub(r'\s+', ' ', clean_content).strip()
+            
+            # 6. HTMLエスケープ
+            escaped_content = html.escape(clean_content)
+            
+            if content != clean_content:
+                logger.error(f"🚨 HTMLタグ混入検出! 元の内容: '{content}'")
+                logger.error(f"🚨 クリーン後: '{clean_content}'")
+                # スタックトレースを出力して呼び出し元を特定
+                import traceback
+                logger.error(f"🚨 呼び出しスタック: {traceback.format_stack()}")
+            else:
+                logger.debug(f"通常テキストをHTMLエスケープ: '{content[:30]}...'")
+            
+            # チャットバブルのHTML生成
+            chat_html = f"""
+            <div class="custom-chat-container">
+                <div class="chat-row {row_class}">
+                    <div class="chat-avatar {avatar_class}">
+                        {avatar_icon}
+                    </div>
+                    <div class="custom-chat-bubble {bubble_class}">
+                        {escaped_content}
+                        {f'<div class="timestamp">{html.escape(timestamp)}</div>' if timestamp and st.session_state.get("debug_mode", False) else ''}
+                    </div>
+                </div>
+            </div>
+            """
+            
+            st.markdown(chat_html, unsafe_allow_html=True)
+            
+            # 麻理のメッセージで隠された真実がある場合の処理
+            if role == "assistant" and not is_initial:
+                has_hidden_content, visible_content, hidden_content = self._detect_hidden_content(content)
+                if has_hidden_content:
+                    # 犬のボタンの状態に応じて表示を切り替え
+                    show_all_hidden = st.session_state.get('show_all_hidden', False)
+                    logger.debug(f"隠された真実の表示判定: show_all_hidden={show_all_hidden}, has_hidden={has_hidden_content}")
+                    
+                    if show_all_hidden:
+                        # 本音表示モードの場合は隠された内容を表示
+                        # HTMLタグとStreamlitクラス名を除去してからエスケープ
+                        clean_hidden_content = re.sub(r'<[^>]*>', '', hidden_content)
+                        clean_hidden_content = re.sub(r'st-emotion-cache-[a-zA-Z0-9]+', '', clean_hidden_content)
+                        clean_hidden_content = re.sub(r'class="[^"]*"', '', clean_hidden_content)
+                        clean_hidden_content = re.sub(r"class='[^']*'", '', clean_hidden_content)
+                        clean_hidden_content = re.sub(r'data-[^=]*="[^"]*"', '', clean_hidden_content)
+                        clean_hidden_content = re.sub(r'&[a-zA-Z0-9#]+;', '', clean_hidden_content)
+                        clean_hidden_content = re.sub(r'[<>]', '', clean_hidden_content)
+                        clean_hidden_content = re.sub(r'\s+', ' ', clean_hidden_content).strip()
+                        escaped_hidden_content = html.escape(clean_hidden_content)
+                        
+                        hidden_html = f"""
+                        <div class="custom-chat-container">
+                            <div class="chat-row assistant-row">
+                                <div class="chat-avatar assistant-avatar">
+                                    🐕
+                                </div>
+                                <div class="custom-chat-bubble assistant-bubble" style="background: #fff8e1 !important; border: 2px solid #ffc107 !important;">
+                                    <strong>🐕 ポチの本音翻訳:</strong><br>
+                                    {escaped_hidden_content}
+                                </div>
+                            </div>
+                        </div>
+                        """
+                        st.markdown(hidden_html, unsafe_allow_html=True)
+                        logger.debug(f"隠された真実を表示: '{clean_hidden_content[:30]}...'")
+                    else:
+                        logger.debug("通常モードのため隠された真実は非表示")
+            
+            logger.debug(f"カスタムチャットバブル表示完了: {role} - {message_id}")
+            
+        except Exception as e:
+            logger.error(f"カスタムチャットバブル表示エラー: {e}")
+            logger.error(f"エラー詳細: role={role}, content_len={len(content)}, is_initial={is_initial}, message_id={message_id}")
+            import traceback
+            logger.error(f"スタックトレース: {traceback.format_exc()}")
+            # フォールバック: シンプルなテキスト表示
+            st.markdown(f"**{role}**: {content}")
+            logger.info("フォールバック表示を実行しました")
+    
+    def _render_mari_message_with_mask(self, message_id: str, content: str, is_initial: bool = False) -> None:
+        """
+        麻理のメッセージをマスク機能付きで表示する（廃止予定）
+        
+        Args:
+            message_id: メッセージの一意ID
+            content: メッセージ内容
+            is_initial: 初期メッセージかどうか
+        """
+        logger.warning("⚠️ 廃止予定のメソッドが呼ばれました: _render_mari_message_with_mask")
+        # カスタムチャットバブルに移行
+        self._render_custom_chat_bubble("assistant", content, is_initial, message_id)
+        return
+        
+        try:
+            # メッセージ処理キャッシュをチェック（重複処理防止）
+            cache_key = f"processed_{message_id}_{hash(content)}"
+            if cache_key in st.session_state:
+                # キャッシュから結果を取得
+                cached_result = st.session_state[cache_key]
+                has_hidden_content = cached_result['has_hidden']
+                visible_content = cached_result['visible_content']
+                hidden_content = cached_result['hidden_content']
+                logger.debug(f"キャッシュからメッセージ処理結果を取得: {message_id}")
+            else:
+                # 隠された真実を検出
+                has_hidden_content, visible_content, hidden_content = self._detect_hidden_content(content)
+                
+                # 結果をキャッシュに保存
+                st.session_state[cache_key] = {
+                    'has_hidden': has_hidden_content,
+                    'visible_content': visible_content,
+                    'hidden_content': hidden_content
+                }
+                logger.debug(f"メッセージ処理結果をキャッシュに保存: {message_id}")
+            
+            # 隠された真実が検出されない場合のフォールバック処理
+            if not has_hidden_content:
+                logger.warning(f"隠された真実が検出されませんでした: '{content[:50]}...'")
+                # AIが[HIDDEN:...]形式で応答していない場合は通常表示
+            
+            # セッション状態でフリップ状態を管理
+            if 'message_flip_states' not in st.session_state:
+                st.session_state.message_flip_states = {}
+            
+            is_flipped = st.session_state.message_flip_states.get(message_id, False)
+            
+            if has_hidden_content:
+                # マスクアイコン付きメッセージを表示
+                self._render_message_with_flip_animation(
+                    message_id, visible_content, hidden_content, is_flipped, is_initial
+                )
+            else:
+                # 通常のメッセージ表示
+                if is_initial:
+                    # 初期メッセージは確実に黒文字で表示（強制スタイル適用）
+                    initial_message_html = f'''
+                    <div class="mari-initial-message" style="
+                        color: #333333 !important; 
+                        font-weight: 500 !important;
+                        background: #f5f5f5 !important;
+                        padding: 15px !important;
+                        border-radius: 12px !important;
+                        border: 1px solid rgba(0,0,0,0.1) !important;
+                        margin: 8px 0 !important;
+                        font-family: var(--mari-font) !important;
+                        line-height: 1.7 !important;
+                    ">
+                        {content}
+                    </div>
+                    '''
+                    st.markdown(initial_message_html, unsafe_allow_html=True)
+                    logger.debug(f"初期メッセージを表示: '{content}'")
+                else:
+                    st.markdown(content)
+                    
+        except Exception as e:
+            logger.error(f"マスク付きメッセージ表示エラー: {e}")
+            # フォールバック: 通常のメッセージ表示
+            st.markdown(content)
+    
+    def _detect_hidden_content(self, content: str) -> Tuple[bool, str, str]:
+        """
+        メッセージから隠された真実を検出する
+        
+        Args:
+            content: メッセージ内容
+            
+        Returns:
+            (隠された内容があるか, 表示用内容, 隠された内容)
+        """
+        try:
+            # デバッグ用ログ（重複実行防止）
+            logger.debug(f"🔍 隠された内容検出中: '{content[:50]}...'")
+            
+            # 隠された真実のマーカーを検索
+            # 形式: [HIDDEN:隠された内容]表示される内容
+            hidden_pattern = r'\[HIDDEN:(.*?)\](.*)'
+            match = re.search(hidden_pattern, content)
+            
+            if match:
+                hidden_content = match.group(1).strip()
+                visible_content = match.group(2).strip()
+                
+                # 複数HIDDENをチェック
+                additional_hidden = re.findall(r'\[HIDDEN:(.*?)\]', visible_content)
+                if additional_hidden:
+                    logger.warning(f"⚠️ 複数HIDDEN検出: {len(additional_hidden) + 1}個のHIDDENが見つかりました")
+                    # 2番目以降のHIDDENを表示内容から除去
+                    visible_content = re.sub(r'\[HIDDEN:.*?\]', '', visible_content).strip()
+                    logger.info(f"🔧 複数HIDDEN除去後: 表示='{visible_content}'")
+                
+                logger.info(f"🐕 隠された真実を検出: 表示='{visible_content}', 隠し='{hidden_content}'")
+                return True, visible_content, hidden_content
+            
+            # マーカーがない場合は通常のメッセージ
+            logger.debug(f"📝 通常メッセージ: '{content[:30]}...'")
+            return False, content, ""
+            
+        except Exception as e:
+            logger.error(f"隠された内容検出エラー: {e}")
+            return False, content, ""
+    
+    def _render_message_with_flip_animation(self, message_id: str, visible_content: str, 
+                                          hidden_content: str, is_flipped: bool, is_initial: bool = False) -> None:
+        """
+        フリップアニメーション付きメッセージを表示する
+        
+        Args:
+            message_id: メッセージID
+            visible_content: 表示用内容
+            hidden_content: 隠された内容
+            is_flipped: 現在フリップされているか
+            is_initial: 初期メッセージかどうか
+        """
+        try:
+            logger.info(f"🐕 ポチモード付きメッセージを表示: ID={message_id}, フリップ={is_flipped}")
+            # フリップアニメーション用CSS
+            flip_css = f"""
+            <style>
+            .message-container-{message_id} {{
+                position: relative;
+                perspective: 1000px;
+                margin: 10px 0;
+            }}
+            
+            .message-flip-{message_id} {{
+                position: relative;
+                width: 100%;
+                height: auto;
+                min-height: 60px;
+                transform-style: preserve-3d;
+                transition: transform 0.4s ease-in-out;
+                transform: {'rotateY(180deg)' if is_flipped else 'rotateY(0deg)'};
+            }}
+            
+            .message-side-{message_id} {{
+                position: absolute;
+                width: 100%;
+                backface-visibility: hidden;
+                padding: 15px 45px 15px 15px;
+                border-radius: 12px;
+                box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+                font-family: var(--mari-font);
+                line-height: 1.7;
+                min-height: 50px;
+            }}
+            
+            .message-front-{message_id} {{
+                background: var(--mari-bubble-bg);
+                border: 1px solid rgba(0, 0, 0, 0.1);
+                color: var(--text-color);
+                transform: rotateY(0deg);
+            }}
+            
+            .message-back-{message_id} {{
+                background: var(--hidden-bubble-bg);
+                border: 1px solid rgba(255, 248, 225, 0.7);
+                color: var(--text-color);
+                transform: rotateY(180deg);
+                box-shadow: 0 2px 8px rgba(255, 248, 225, 0.3);
+            }}
+            
+            .mask-icon-{message_id} {{
+                position: absolute;
+                bottom: 12px;
+                right: 12px;
+                font-size: 20px;
+                cursor: pointer;
+                padding: 6px;
+                border-radius: 50%;
+                background: rgba(255, 255, 255, 0.9);
+                transition: all 0.3s ease;
+                z-index: 10;
+                user-select: none;
+                box-shadow: 0 2px 6px rgba(0, 0, 0, 0.15);
+            }}
+            
+            .mask-icon-{message_id}:hover {{
+                background: rgba(255, 255, 255, 1);
+                transform: scale(1.1);
+                box-shadow: 0 2px 8px rgba(0, 0, 0, 0.2);
+            }}
+            
+            .mask-icon-{message_id}:active {{
+                transform: scale(0.95);
+            }}
+            
+            .tutorial-pulse-{message_id} {{
+                animation: tutorialPulse 2s ease-in-out infinite;
+            }}
+            
+            @keyframes tutorialPulse {{
+                0%, 100% {{ 
+                    transform: scale(1);
+                    box-shadow: 0 0 0 0 rgba(255, 105, 180, 0.7);
+                }}
+                50% {{ 
+                    transform: scale(1.1);
+                    box-shadow: 0 0 0 10px rgba(255, 105, 180, 0);
+                }}
+            }}
+            </style>
+            """
+            
+            # 犬のボタンの状態を事前にチェックして即座に反映（無限ループ防止）
+            show_all_hidden = st.session_state.get('show_all_hidden', False)
+            
+            # 犬のボタンの状態に従って表示を切り替え（状態変更時のみ）
+            current_flip_state = st.session_state.message_flip_states.get(message_id, False)
+            if show_all_hidden != current_flip_state:
+                st.session_state.message_flip_states[message_id] = show_all_hidden
+                is_flipped = show_all_hidden
+                logger.debug(f"メッセージ {message_id} のフリップ状態を更新: {is_flipped}")
+            else:
+                is_flipped = current_flip_state
+            
+            # 現在表示するコンテンツを決定
+            current_content = hidden_content if is_flipped else visible_content
+            
+            # 初期メッセージの場合は確実に黒文字で表示
+            if is_initial:
+                initial_style = "color: #333333 !important; font-weight: 500 !important;"
+                initial_class = "mari-initial-message"
+                # 初期メッセージは背景色を固定
+                bg_color = "#F5F5F5"
+                logger.debug(f"初期メッセージをフリップ表示: '{current_content}'")
+            else:
+                initial_style = ""
+                initial_class = ""
+                # 通常メッセージは背景色を動的に設定
+                bg_color = "#FFF8E1" if is_flipped else "#F5F5F5"
+            
+            # メッセージを全幅で表示（ボタンは削除）
+            message_style = f"""
+            <div style="
+                padding: 15px; 
+                background: {bg_color}; 
+                border-radius: 12px; 
+                border: 1px solid rgba(0,0,0,0.1); 
+                min-height: 50px;
+                font-family: var(--mari-font);
+                line-height: 1.7;
+                margin: 8px 0;
+            ">
+                <div class="{initial_class}" style="{initial_style}">{current_content}</div>
+            </div>
+            """
+            st.markdown(message_style, unsafe_allow_html=True)
+            
+            # 本音表示機能の状態表示（開発用）
+            if st.session_state.get("debug_mode", False):
+                st.caption(f"🐕 Dog Mode: ID={message_id}, Hidden={len(hidden_content)>0}, Showing={is_flipped}")
+                
+        except Exception as e:
+            logger.error(f"フリップアニメーション表示エラー: {e}")
+            # フォールバック: 通常のメッセージ表示
+            st.markdown(visible_content)
+    
+    def _is_tutorial_message(self, message_id: str) -> bool:
+        """
+        チュートリアル用のメッセージかどうかを判定する
+        
+        Args:
+            message_id: メッセージID
+            
+        Returns:
+            チュートリアルメッセージかどうか
+        """
+        # 初回のマスク付きメッセージの場合はチュートリアル扱い
+        tutorial_completed = st.session_state.get('mask_tutorial_completed', False)
+        return not tutorial_completed and message_id == "msg_0"
+    
+    def validate_input(self, message: str) -> Tuple[bool, str]:
+        """
+        入力メッセージの検証
+        
+        Args:
+            message: 入力メッセージ
+            
+        Returns:
+            (検証結果, エラーメッセージ)
+        """
+        if not message or not message.strip():
+            return False, "メッセージが空です。"
+        
+        if len(message) > self.max_input_length:
+            return False, f"メッセージが長すぎます。{self.max_input_length}文字以内で入力してください。"
+        
+        # 不正な文字のチェック
+        if any(ord(char) < 32 and char not in ['\n', '\r', '\t'] for char in message):
+            return False, "不正な文字が含まれています。"
+        
+        return True, ""
+    
+    def sanitize_message(self, message: str) -> str:
+        """
+        メッセージをサニタイズする
+        
+        Args:
+            message: 入力メッセージ
+            
+        Returns:
+            サニタイズされたメッセージ
+        """
+        try:
+            # 基本的なサニタイズ
+            sanitized = message.strip()
+            
+            # HTMLエスケープ（Streamlitが自動で行うが念のため）
+            sanitized = sanitized.replace("<", "&lt;").replace(">", "&gt;")
+            
+            # 連続する空白を単一の空白に変換
+            import re
+            sanitized = re.sub(r'\s+', ' ', sanitized)
+            
+            return sanitized
+            
+        except Exception as e:
+            logger.error(f"メッセージサニタイズエラー: {e}")
+            return message
+    
+    def add_message(self, role: str, content: str, 
+                   messages: Optional[List[Dict[str, str]]] = None, 
+                   message_id: Optional[str] = None) -> List[Dict[str, str]]:
+        """
+        メッセージをリストに追加する（マスク機能対応）
+        
+        Args:
+            role: メッセージの役割 ('user' or 'assistant')
+            content: メッセージ内容
+            messages: メッセージリスト（Noneの場合はsession_stateから取得）
+            message_id: メッセージの一意ID（Noneの場合は自動生成）
+            
+        Returns:
+            更新されたメッセージリスト
+        """
+        try:
+            if messages is None:
+                messages = st.session_state.get('messages', [])
+            
+            # メッセージIDを生成または使用
+            if message_id is None:
+                message_id = f"msg_{len(messages)}_{uuid.uuid4().hex[:8]}"
+            
+            # メッセージオブジェクトを作成
+            message = {
+                "role": role,
+                "content": self.sanitize_message(content),
+                "timestamp": datetime.now().isoformat(),
+                "message_id": message_id
+            }
+            
+            messages.append(message)
+            
+            # セッション状態を更新
+            st.session_state.messages = messages
+            
+            logger.info(f"メッセージを追加: {role} - {len(content)}文字 (ID: {message_id})")
+            return messages
+            
+        except Exception as e:
+            logger.error(f"メッセージ追加エラー: {e}")
+            return messages or []
+    
+    def create_hidden_content_message(self, visible_content: str, hidden_content: str) -> str:
+        """
+        隠された真実を含むメッセージを作成する
+        
+        Args:
+            visible_content: 表示される内容
+            hidden_content: 隠された内容
+            
+        Returns:
+            マーカー付きメッセージ
+        """
+        return f"[HIDDEN:{hidden_content}]{visible_content}"
+    
+    def generate_mock_hidden_content(self, visible_content: str) -> str:
+        """
+        テスト用のモック隠された内容を生成する
+        
+        Args:
+            visible_content: 表示される内容
+            
+        Returns:
+            隠された内容
+        """
+        # 簡単なモック生成ロジック
+        mock_patterns = {
+            "何の用？": "（本当は嬉しいけど...素直になれない）",
+            "別に": "（実はすごく気になってる）",
+            "そうね": "（もっと話していたい）",
+            "まあまあ": "（とても楽しい！）",
+            "普通": "（特別な時間だと思ってる）",
+            "いいんじゃない": "（すごく良いと思う！）",
+            "そんなことない": "（本当はそう思ってる）"
+        }
+        
+        for pattern, hidden in mock_patterns.items():
+            if pattern in visible_content:
+                return hidden
+        
+        # デフォルトの隠された内容
+        return "（本当の気持ちは...）"
+    
+    def render_input_area(self, placeholder: str = "メッセージを入力してください...") -> Optional[str]:
+        """
+        入力エリアをレンダリングし、入力を取得する
+        
+        Args:
+            placeholder: 入力フィールドのプレースホルダー
+            
+        Returns:
+            入力されたメッセージ（入力がない場合はNone）
+        """
+        try:
+            # レート制限チェック
+            if st.session_state.get('limiter_state', {}).get('is_blocked', False):
+                st.warning("⏰ レート制限中です。しばらくお待ちください。")
+                st.chat_input(placeholder, disabled=True)
+                return None
+            
+            # 通常の入力フィールド
+            user_input = st.chat_input(placeholder)
+            
+            if user_input:
+                # 入力検証
+                is_valid, error_msg = self.validate_input(user_input)
+                if not is_valid:
+                    st.error(error_msg)
+                    return None
+                
+                return user_input
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"入力エリア表示エラー: {e}")
+            st.error("入力エリアの表示中にエラーが発生しました。")
+            return None
+    
+    def show_typing_indicator(self, message: str = "考え中...") -> None:
+        """
+        タイピングインジケーターを表示する
+        
+        Args:
+            message: 表示するメッセージ
+        """
+        return st.spinner(message)
+    
+    def clear_chat_history(self) -> None:
+        """チャット履歴をクリアする"""
+        try:
+            st.session_state.messages = []
+            logger.info("チャット履歴をクリアしました")
+            
+        except Exception as e:
+            logger.error(f"チャット履歴クリアエラー: {e}")
+    
+    def get_chat_stats(self) -> Dict[str, int]:
+        """
+        チャットの統計情報を取得する
+        
+        Returns:
+            統計情報の辞書
+        """
+        try:
+            messages = st.session_state.get('messages', [])
+            
+            user_messages = [msg for msg in messages if msg.get("role") == "user"]
+            assistant_messages = [msg for msg in messages if msg.get("role") == "assistant"]
+            
+            total_chars = sum(len(msg.get("content", "")) for msg in messages)
+            
+            return {
+                "total_messages": len(messages),
+                "user_messages": len(user_messages),
+                "assistant_messages": len(assistant_messages),
+                "total_characters": total_chars,
+                "average_message_length": total_chars // len(messages) if messages else 0
+            }
+            
+        except Exception as e:
+            logger.error(f"統計情報取得エラー: {e}")
+            return {
+                "total_messages": 0,
+                "user_messages": 0,
+                "assistant_messages": 0,
+                "total_characters": 0,
+                "average_message_length": 0
+            }
+    
+    def export_chat_history(self) -> str:
+        """
+        チャット履歴をエクスポート用の文字列として取得する
+        
+        Returns:
+            エクスポート用の文字列
+        """
+        try:
+            messages = st.session_state.get('messages', [])
+            
+            if not messages:
+                return "チャット履歴がありません。"
+            
+            export_lines = []
+            export_lines.append("=== 麻理チャット履歴 ===")
+            export_lines.append(f"エクスポート日時: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+            export_lines.append("")
+            
+            for i, message in enumerate(messages, 1):
+                role = "ユーザー" if message.get("role") == "user" else "麻理"
+                content = message.get("content", "")
+                timestamp = message.get("timestamp", "")
+                
+                export_lines.append(f"[{i}] {role}: {content}")
+                if timestamp:
+                    export_lines.append(f"    時刻: {timestamp}")
+                export_lines.append("")
+            
+            return "\n".join(export_lines)
+            
+        except Exception as e:
+            logger.error(f"履歴エクスポートエラー: {e}")
+            return "エクスポート中にエラーが発生しました。"

components_dog_assistant.py

@@ -0,0 +1,473 @@
+"""
+ポチ（犬）アシスタントコンポーネント
+画面右下に固定配置され、本音表示機能を提供する
+"""
+import streamlit as st
+import logging
+
+logger = logging.getLogger(__name__)
+
+class DogAssistant:
+    """ポチ（犬）アシスタントクラス"""
+    
+    def __init__(self):
+        """初期化"""
+        self.default_message = "ポチは麻理の本音を察知したようだ・・・"
+        self.active_message = "ワンワン！本音が見えてるワン！"
+    
+    def render_dog_component(self, tutorial_manager=None):
+        """画面右下に固定配置される犬のコンポーネントを描画"""
+        try:
+            # 犬のボタン表示前にチャットセッション状態を確認
+            if 'chat' not in st.session_state:
+                logger.warning("犬のコンポーネント表示前にチャットセッションが存在しません - 初期化します")
+                initial_message = {"role": "assistant", "content": "何の用？遊びに来たの？", "is_initial": True}
+                st.session_state.chat = {
+                    "messages": [initial_message],
+                    "affection": 30,
+                    "scene_params": {"theme": "default"},
+                    "limiter_state": {},
+                    "scene_change_pending": None,
+                    "ura_mode": False
+                }
+                logger.info("犬のコンポーネント表示前にチャットセッションを初期化しました")
+            elif 'messages' not in st.session_state.chat:
+                logger.warning("犬のコンポーネント表示前にメッセージリストが存在しません - 初期化します")
+                initial_message = {"role": "assistant", "content": "何の用？遊びに来たの？", "is_initial": True}
+                st.session_state.chat['messages'] = [initial_message]
+                logger.info("犬のコンポーネント表示前にメッセージリストを初期化しました")
+            elif not any(msg.get('is_initial', False) for msg in st.session_state.chat['messages']):
+                logger.warning("犬のコンポーネント表示前に初期メッセージが見つかりません - 復元します")
+                initial_message = {"role": "assistant", "content": "何の用？遊びに来たの？", "is_initial": True}
+                st.session_state.chat['messages'].insert(0, initial_message)
+                logger.info("犬のコンポーネント表示前に初期メッセージを復元しました")
+            # 犬のコンポーネントのCSS（レスポンシブ対応）
+            dog_css = """
+            <style>
+            .dog-assistant-container {
+                position: fixed;
+                bottom: 20px;
+                right: 20px;
+                z-index: 1000;
+                display: flex;
+                flex-direction: column;
+                align-items: flex-start;
+                pointer-events: none;
+                transform: translateX(-50px);
+            }
+            
+            .dog-speech-bubble {
+                background-color: rgba(255, 255, 255, 0.95);
+                color: #333;
+                padding: 10px 15px;
+                border-radius: 20px;
+                font-size: 13px;
+                margin-bottom: 10px;
+                position: relative;
+                box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+                backdrop-filter: blur(10px);
+                border: 1px solid rgba(0,0,0,0.1);
+                max-width: 200px;
+                word-wrap: break-word;
+                animation: bubbleFloat 3s ease-in-out infinite;
+                pointer-events: auto;
+            }
+            
+            .dog-speech-bubble::after {
+                content: '';
+                position: absolute;
+                bottom: -8px;
+                left: 20px;
+                width: 0;
+                height: 0;
+                border-left: 8px solid transparent;
+                border-right: 8px solid transparent;
+                border-top: 8px solid rgba(255, 255, 255, 0.95);
+            }
+            
+            .dog-button {
+                background: linear-gradient(135deg, #ff9a9e 0%, #fecfef 50%, #fecfef 100%);
+                border: none;
+                border-radius: 50%;
+                width: 70px;
+                height: 70px;
+                cursor: pointer;
+                transition: all 0.3s ease;
+                box-shadow: 0 4px 15px rgba(255, 154, 158, 0.4);
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                font-size: 35px;
+                pointer-events: auto;
+                animation: dogBounce 2s ease-in-out infinite;
+            }
+            
+            .dog-button:hover {
+                transform: scale(1.1);
+                box-shadow: 0 6px 20px rgba(255, 154, 158, 0.6);
+                background: linear-gradient(135deg, #ff6b6b 0%, #feca57 50%, #ff9ff3 100%);
+            }
+            
+            .dog-button:active {
+                transform: scale(0.95);
+            }
+            
+            .dog-button.active {
+                background: linear-gradient(135deg, #4ecdc4 0%, #44a08d 100%);
+                animation: dogActive 1s ease-in-out infinite;
+            }
+            
+            @keyframes bubbleFloat {
+                0%, 100% { transform: translateY(0px); }
+                50% { transform: translateY(-5px); }
+            }
+            
+            @keyframes dogBounce {
+                0%, 100% { transform: translateY(0px); }
+                50% { transform: translateY(-3px); }
+            }
+            
+            @keyframes dogActive {
+                0%, 100% { transform: scale(1) rotate(0deg); }
+                25% { transform: scale(1.05) rotate(-2deg); }
+                75% { transform: scale(1.05) rotate(2deg); }
+            }
+            
+            /* レスポンシブ対応 */
+            @media (max-width: 768px) {
+                .dog-assistant-container {
+                    bottom: 15px;
+                    right: 15px;
+                    transform: translateX(-40px);
+                }
+                
+                .dog-speech-bubble {
+                    max-width: 150px;
+                    font-size: 12px;
+                    padding: 8px 12px;
+                }
+                
+                .dog-button {
+                    width: 60px;
+                    height: 60px;
+                    font-size: 30px;
+                }
+            }
+            
+            @media (max-width: 480px) {
+                .dog-assistant-container {
+                    bottom: 10px;
+                    right: 10px;
+                    transform: translateX(-30px);
+                }
+                
+                .dog-speech-bubble {
+                    max-width: 120px;
+                    font-size: 11px;
+                    padding: 6px 10px;
+                }
+                
+                .dog-button {
+                    width: 50px;
+                    height: 50px;
+                    font-size: 25px;
+                }
+            }
+            
+            /* 画面が非常に小さい場合は吹き出しを非表示 */
+            @media (max-width: 320px) {
+                .dog-speech-bubble {
+                    display: none;
+                }
+            }
+            </style>
+            """
+            
+            # 現在の状態を取得
+            is_active = st.session_state.get('show_all_hidden', False)
+            bubble_text = self.active_message if is_active else self.default_message
+            button_class = "dog-button active" if is_active else "dog-button"
+            
+            # JavaScriptでクリックイベントを処理
+            dog_js = f"""
+            <script>
+            function toggleDogMode() {{
+                // Streamlitのセッション状態を更新するためのトリガー
+                const event = new CustomEvent('dogButtonClick', {{
+                    detail: {{ active: {str(is_active).lower()} }}
+                }});
+                window.dispatchEvent(event);
+                
+                // ボタンの状態を即座に更新
+                const button = document.querySelector('.dog-button');
+                const bubble = document.querySelector('.dog-speech-bubble');
+                
+                if (button && bubble) {{
+                    if ({str(is_active).lower()}) {{
+                        button.classList.remove('active');
+                        bubble.textContent = '{self.default_message}';
+                    }} else {{
+                        button.classList.add('active');
+                        bubble.textContent = '{self.active_message}';
+                    }}
+                }}
+            }}
+            
+            // ページ読み込み時にイベントリスナーを設定
+            document.addEventListener('DOMContentLoaded', function() {{
+                const button = document.querySelector('.dog-button');
+                if (button) {{
+                    button.addEventListener('click', toggleDogMode);
+                }}
+            }});
+            
+            // Streamlitの再描画後にもイベントリスナーを再設定
+            setTimeout(function() {{
+                const button = document.querySelector('.dog-button');
+                if (button) {{
+                    button.addEventListener('click', toggleDogMode);
+                }}
+            }}, 100);
+            </script>
+            """
+            
+            # HTMLコンポーネント
+            dog_html = f"""
+            <div class="dog-assistant-container">
+                <div class="dog-speech-bubble">
+                    {bubble_text}
+                </div>
+                <button class="{button_class}" title="ポチが麻理の本音を察知します" onclick="toggleDogMode()">
+                    🐕
+                </button>
+            </div>
+            """
+            
+            # HTMLコンポーネント（ボタン以外）を表示
+            dog_display_html = f"""
+            <div class="dog-assistant-container">
+                <div class="dog-speech-bubble">
+                    {bubble_text}
+                </div>
+                <div style="width: 70px; height: 70px; display: flex; align-items: center; justify-content: center;">
+                    <!-- Streamlitボタンがここに配置される -->
+                </div>
+            </div>
+            """
+            
+            st.markdown(dog_css + dog_display_html, unsafe_allow_html=True)
+            
+            # Streamlitボタンを固定位置に配置
+            button_css = """
+            <style>
+            .dog-button-overlay {
+                position: fixed;
+                bottom: 20px;
+                right: 20px;
+                z-index: 1001;
+                pointer-events: auto;
+            }
+            
+            .dog-button-overlay .stButton > button {
+                background: linear-gradient(135deg, #ff9a9e 0%, #fecfef 100%);
+                border: none;
+                border-radius: 50%;
+                width: 70px;
+                height: 70px;
+                font-size: 35px;
+                color: white;
+                box-shadow: 0 4px 15px rgba(255, 154, 158, 0.4);
+                transition: all 0.3s ease;
+                animation: dogBounce 2s ease-in-out infinite;
+            }
+            
+            .dog-button-overlay .stButton > button:hover {
+                transform: scale(1.1);
+                box-shadow: 0 6px 20px rgba(255, 154, 158, 0.6);
+            }
+            
+            @keyframes dogBounce {
+                0%, 100% { transform: translateY(0px); }
+                50% { transform: translateY(-3px); }
+            }
+            
+            @media (max-width: 768px) {
+                .dog-button-overlay {
+                    bottom: 15px;
+                    right: 15px;
+                }
+                
+                .dog-button-overlay .stButton > button {
+                    width: 60px;
+                    height: 60px;
+                    font-size: 30px;
+                }
+            }
+            
+            @media (max-width: 480px) {
+                .dog-button-overlay {
+                    bottom: 10px;
+                    right: 10px;
+                }
+                
+                .dog-button-overlay .stButton > button {
+                    width: 50px;
+                    height: 50px;
+                    font-size: 25px;
+                }
+            }
+            </style>
+            """
+            
+            st.markdown(button_css, unsafe_allow_html=True)
+            st.markdown('<div class="dog-button-overlay">', unsafe_allow_html=True)
+            
+            # ボタンクリック処理
+            button_key = f"dog_fixed_{is_active}"
+            button_help = "本音を隠す" if is_active else "本音を見る"
+            if st.button("🐕", key=button_key, help=button_help):
+                self.handle_dog_button_click(tutorial_manager)
+                logger.info("右下の犬のボタンがクリックされました")
+            
+            st.markdown('</div>', unsafe_allow_html=True)
+            
+            logger.debug(f"犬のコンポーネントを描画しました (active: {is_active})")
+            
+        except Exception as e:
+            logger.error(f"犬のコンポーネント描画エラー: {e}")
+    
+    def handle_dog_button_click(self, tutorial_manager=None):
+        """犬のボタンクリック処理（無限ループ防止版）"""
+        try:
+            # 本音表示機能のトリガー
+            if 'show_all_hidden' not in st.session_state:
+                st.session_state.show_all_hidden = False
+            
+            # 現在の状態を取得
+            current_state = st.session_state.show_all_hidden
+            new_state = not current_state
+            
+            # 状態を更新
+            st.session_state.show_all_hidden = new_state
+            # チャット履歴の強制再表示フラグを設定
+            st.session_state.show_all_hidden_changed = True
+            logger.info(f"犬のボタン状態変更: {current_state} -> {new_state}")
+            
+            # 全メッセージのフリップ状態を即座に更新
+            if 'message_flip_states' not in st.session_state:
+                st.session_state.message_flip_states = {}
+            
+            # 現在のメッセージに対してフリップ状態を設定
+            if 'chat' in st.session_state and 'messages' in st.session_state.chat:
+                # 初期メッセージが存在することを確認
+                messages = st.session_state.chat['messages']
+                if not any(msg.get('is_initial', False) for msg in messages):
+                    logger.warning("犬のボタン押下時に初期メッセージが見つかりません - 復元します")
+                    initial_message = {"role": "assistant", "content": "何の用？遊びに来たの？", "is_initial": True}
+                    st.session_state.chat['messages'].insert(0, initial_message)
+                    logger.info("犬のボタン押下時に初期メッセージを復元しました")
+                
+                for i, message in enumerate(st.session_state.chat['messages']):
+                    if message['role'] == 'assistant':
+                        message_id = f"msg_{i}"
+                        st.session_state.message_flip_states[message_id] = new_state
+            else:
+                logger.warning("犬のボタン押下時にチャットセッションが存在しません - 初期化します")
+                # チャットセッションが存在しない場合は初期化
+                initial_message = {"role": "assistant", "content": "何の用？遊びに来たの？", "is_initial": True}
+                if 'chat' not in st.session_state:
+                    st.session_state.chat = {
+                        "messages": [initial_message],
+                        "affection": 30,
+                        "scene_params": {"theme": "default"},
+                        "limiter_state": {},
+                        "scene_change_pending": None,
+                        "ura_mode": False
+                    }
+                else:
+                    st.session_state.chat['messages'] = [initial_message]
+                logger.info("犬のボタン押下時にチャットセッションを初期化しました")
+            
+            # チュートリアルステップ2を完了（tutorial_managerが渡された場合）
+            if tutorial_manager:
+                tutorial_manager.check_step_completion(2, True)
+            
+            # 通知メッセージ（一度だけ表示）
+            if new_state:
+                st.success("🐕 ポチが麻理の本音を察知しました！")
+            else:
+                st.info("🐕 ポチが通常モードに戻りました。")
+            
+            logger.info(f"犬のボタン状態変更完了: {current_state} → {new_state}")
+            
+            # 状態変更を確実に反映するため、強制的に再実行
+            st.rerun()
+            
+        except Exception as e:
+            logger.error(f"犬のボタンクリック処理エラー: {e}")
+    
+    def render_with_streamlit_button(self):
+        """Streamlitのボタンを使用した代替実装（フォールバック用）"""
+        try:
+            # 固定位置のCSS
+            fallback_css = """
+            <style>
+            .dog-fallback-container {
+                position: fixed;
+                bottom: 20px;
+                right: 20px;
+                z-index: 1000;
+                background: rgba(255, 255, 255, 0.9);
+                border-radius: 15px;
+                padding: 10px;
+                box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+                backdrop-filter: blur(10px);
+            }
+            
+            @media (max-width: 768px) {
+                .dog-fallback-container {
+                    bottom: 15px;
+                    right: 15px;
+                    padding: 8px;
+                }
+            }
+            </style>
+            """
+            
+            st.markdown(fallback_css, unsafe_allow_html=True)
+            
+            # コンテナの開始
+            st.markdown('<div class="dog-fallback-container">', unsafe_allow_html=True)
+            
+            # 状態表示
+            is_active = st.session_state.get('show_all_hidden', False)
+            status_text = "本音モード中" if is_active else "通常モード"
+            st.caption(f"🐕 {status_text}")
+            
+            # ボタン
+            button_text = "🔄 戻す" if is_active else "🐕 本音を見る"
+            if st.button(button_text, key="dog_assistant_btn"):
+                # チュートリアルマネージャーを取得（可能な場合）
+                tutorial_manager = None
+                try:
+                    # セッション状態からチュートリアルマネージャーを取得する試み
+                    # （完全ではないが、フォールバック用）
+                    pass
+                except:
+                    pass
+                
+                self.handle_dog_button_click(tutorial_manager)
+                # st.rerun()を削除 - 状態変更により自動的に再描画される
+            
+            # コンテナの終了
+            st.markdown('</div>', unsafe_allow_html=True)
+            
+        except Exception as e:
+            logger.error(f"犬のフォールバック描画エラー: {e}")
+    
+    def get_current_state(self):
+        """現在の犬の状態を取得"""
+        return {
+            'is_active': st.session_state.get('show_all_hidden', False),
+            'message': self.active_message if st.session_state.get('show_all_hidden', False) else self.default_message
+        }

components_status_display.py

@@ -0,0 +1,640 @@
+"""
+ステータス表示コンポーネント
+好感度ゲージと関係ステージの表示を担当する
+"""
+import streamlit as st
+import logging
+from typing import Dict, Tuple
+
+logger = logging.getLogger(__name__)
+
+class StatusDisplay:
+    """ステータス表示を管理するクラス"""
+    
+    def __init__(self):
+        """ステータス表示の初期化"""
+        self.stage_colors = {
+            "敵対": {"color": "#ff4757", "emoji": "🔴", "bg_color": "rgba(255, 71, 87, 0.1)"},
+            "警戒": {"color": "#ff6348", "emoji": "🟠", "bg_color": "rgba(255, 99, 72, 0.1)"},
+            "中立": {"color": "#ffa502", "emoji": "🟡", "bg_color": "rgba(255, 165, 2, 0.1)"},
+            "好意": {"color": "#2ed573", "emoji": "🟢", "bg_color": "rgba(46, 213, 115, 0.1)"},
+            "親密": {"color": "#a55eea", "emoji": "💜", "bg_color": "rgba(165, 94, 234, 0.1)"}
+        }
+    
+    def get_affection_color(self, affection: int) -> str:
+        """
+        好感度に基づいて色を取得する
+        
+        Args:
+            affection: 好感度値 (0-100)
+            
+        Returns:
+            色のHEXコード
+        """
+        if affection < 20:
+            return "#ff4757"  # 赤
+        elif affection < 40:
+            return "#ff6348"  # オレンジ
+        elif affection < 60:
+            return "#ffa502"  # 黄色
+        elif affection < 80:
+            return "#2ed573"  # 緑
+        else:
+            return "#a55eea"  # 紫
+    
+    def get_relationship_stage_info(self, affection: int) -> Dict[str, str]:
+        """
+        好感度から関係性ステージの情報を取得する
+        
+        Args:
+            affection: 好感度値 (0-100)
+            
+        Returns:
+            ステージ情報の辞書
+        """
+        if affection < 20:
+            stage = "敵対"
+        elif affection < 40:
+            stage = "警戒"
+        elif affection < 60:
+            stage = "中立"
+        elif affection < 80:
+            stage = "好意"
+        else:
+            stage = "親密"
+        
+        # 古いキー形式との互換性を保つため、新しいキーで検索し、見つからない場合は中立を返す
+        stage_info = None
+        for key, value in self.stage_colors.items():
+            if stage in key:
+                stage_info = value
+                break
+        
+        return stage_info or self.stage_colors.get("中立", {"color": "#ffa502", "emoji": "🟡", "bg_color": "rgba(255, 165, 2, 0.1)"})
+    
+    def render_affection_gauge(self, affection: int) -> None:
+        """
+        好感度ゲージを表示する
+        
+        Args:
+            affection: 好感度値 (0-100)
+        """
+        try:
+            # 好感度の値を0-100の範囲に制限
+            affection = max(0, min(100, affection))
+            
+            # 好感度メトリック表示
+            col1, col2 = st.columns([2, 1])
+            with col1:
+                st.metric("好感度", f"{affection}/100")
+            with col2:
+                # 好感度の変化を表示（前回の値と比較）
+                prev_affection = st.session_state.get('prev_affection', affection)
+                delta = affection - prev_affection
+                if delta != 0:
+                    st.metric("変化", f"{delta:+d}")
+                st.session_state.prev_affection = affection
+            
+            # プログレスバー
+            progress_value = affection / 100.0
+            affection_color = self.get_affection_color(affection)
+            
+            # カスタムプログレスバーのCSS
+            progress_css = f"""
+            <style>
+            .affection-progress {{
+                width: 100%;
+                height: 25px;
+                background-color: rgba(255, 255, 255, 0.1);
+                border-radius: 12px;
+                overflow: hidden;
+                margin: 10px 0;
+                border: 1px solid rgba(255, 255, 255, 0.2);
+            }}
+            .affection-fill {{
+                height: 100%;
+                background: linear-gradient(90deg, 
+                    #ff4757 0%, 
+                    #ff6348 25%, 
+                    #ffa502 50%, 
+                    #2ed573 75%, 
+                    #a55eea 100%);
+                width: {progress_value * 100}%;
+                transition: width 0.5s ease-in-out;
+                position: relative;
+            }}
+            .affection-text {{
+                position: absolute;
+                top: 50%;
+                left: 50%;
+                transform: translate(-50%, -50%);
+                color: white;
+                font-weight: bold;
+                text-shadow: 1px 1px 2px rgba(0,0,0,0.7);
+                font-size: 12px;
+            }}
+            </style>
+            """
+            
+            st.markdown(progress_css, unsafe_allow_html=True)
+            
+            # プログレ��バーのHTML
+            progress_html = f"""
+            <div class="affection-progress">
+                <div class="affection-fill">
+                    <div class="affection-text">{affection}%</div>
+                </div>
+            </div>
+            """
+            
+            st.markdown(progress_html, unsafe_allow_html=True)
+            
+            # Streamlitの標準プログレスバーも表示（フォールバック）
+            st.progress(progress_value)
+            
+        except Exception as e:
+            logger.error(f"好感度ゲージ表示エラー: {e}")
+            # フォールバック表示
+            st.metric("好感度", f"{affection}/100")
+            st.progress(affection / 100.0)
+    
+    def render_relationship_stage(self, affection: int) -> None:
+        """
+        関係性ステージを表示する
+        
+        Args:
+            affection: 好感度値 (0-100)
+        """
+        try:
+            stage_info = self.get_relationship_stage_info(affection)
+            
+            # ステージ名を取得
+            if affection < 20:
+                stage_name = "ステージ1：敵対"
+                stage_description = "麻理はあなたを敵視している"
+            elif affection < 40:
+                stage_name = "ステージ2：警戒"
+                stage_description = "麻理はあなたを警戒している"
+            elif affection < 60:
+                stage_name = "ステージ3：中立"
+                stage_description = "麻理はあなたに対して中立的"
+            elif affection < 80:
+                stage_name = "ステージ4：好意"
+                stage_description = "麻理はあなたに好意を持っている"
+            else:
+                stage_name = "ステージ5：親密"
+                stage_description = "麻理はあなたと親密な関係"
+            
+            # ステージ表示のCSS
+            stage_css = f"""
+            <style>
+            .relationship-stage {{
+                background: {stage_info['bg_color']};
+                border: 2px solid {stage_info['color']};
+                border-radius: 10px;
+                padding: 15px;
+                margin: 10px 0;
+                text-align: center;
+            }}
+            .stage-emoji {{
+                font-size: 24px;
+                margin-bottom: 5px;
+            }}
+            .stage-name {{
+                color: {stage_info['color']};
+                font-weight: bold;
+                font-size: 16px;
+                margin-bottom: 5px;
+            }}
+            .stage-description {{
+                color: {stage_info['color']};
+                font-size: 12px;
+                opacity: 0.8;
+            }}
+            </style>
+            """
+            
+            st.markdown(stage_css, unsafe_allow_html=True)
+            
+            # ステージ表示のHTML
+            stage_html = f"""
+            <div class="relationship-stage">
+                <div class="stage-emoji">{stage_info['emoji']}</div>
+                <div class="stage-name">{stage_name}</div>
+                <div class="stage-description">{stage_description}</div>
+            </div>
+            """
+            
+            st.markdown(stage_html, unsafe_allow_html=True)
+            
+            # フォールバック表示
+            st.write(f"{stage_info['emoji']} **関係性**: {stage_name}")
+            
+        except Exception as e:
+            logger.error(f"関係性ステージ表示エラー: {e}")
+            # フォールバック表示
+            if affection < 20:
+                st.write("🔴 **関係性**: ステージ1：敵対")
+            elif affection < 40:
+                st.write("🟠 **関係性**: ステージ2：中立")
+            elif affection < 60:
+                st.write("🟡 **関係性**: ステージ3：好意")
+            elif affection < 80:
+                st.write("🟢 **関係性**: ステージ4：親密")
+            else:
+                st.write("💜 **関係性**: ステージ5：最接近")
+    
+    def render_affection_history(self, max_history: int = 10) -> None:
+        """
+        好感度の履歴を表示する（デバッグモード用）
+        
+        Args:
+            max_history: 表示する履歴の最大数
+        """
+        try:
+            if not st.session_state.get('debug_mode', False):
+                return
+            
+            # 好感度履歴を取得
+            affection_history = st.session_state.get('affection_history', [])
+            
+            if not affection_history:
+                st.write("好感度の履歴がありません")
+                return
+            
+            # 最新の履歴を表示
+            recent_history = affection_history[-max_history:]
+            
+            st.subheader("📈 好感度履歴")
+            
+            for i, entry in enumerate(reversed(recent_history)):
+                timestamp = entry.get('timestamp', 'Unknown')
+                affection = entry.get('affection', 0)
+                change = entry.get('change', 0)
+                message = entry.get('message', '')
+                
+                change_str = f"({change:+d})" if change != 0 else ""
+                st.write(f"{i+1}. {affection}/100 {change_str} - {timestamp[:19]}")
+                if message:
+                    st.caption(f"メッセージ: {message[:50]}...")
+            
+        except Exception as e:
+            logger.error(f"好感度履歴表示エラー: {e}")
+    
+    def update_affection_history(self, old_affection: int, new_affection: int, 
+                               message: str = "") -> None:
+        """
+        好感度履歴を更新する
+        
+        Args:
+            old_affection: 変更前の好感度
+            new_affection: 変更後の好感度
+            message: 関連するメッセージ
+        """
+        try:
+            if 'affection_history' not in st.session_state:
+                st.session_state.affection_history = []
+            
+            # 履歴エントリを作成
+            history_entry = {
+                'timestamp': st.session_state.get('current_timestamp', ''),
+                'affection': new_affection,
+                'change': new_affection - old_affection,
+                'message': message[:100] if message else ''  # メッセージを100文字に制限
+            }
+            
+            st.session_state.affection_history.append(history_entry)
+            
+            # 履歴の長さを制限（最大50エントリ）
+            if len(st.session_state.affection_history) > 50:
+                st.session_state.affection_history = st.session_state.affection_history[-50:]
+            
+        except Exception as e:
+            logger.error(f"好感度履歴更新エラー: {e}")
+    
+    def get_affection_statistics(self) -> Dict[str, float]:
+        """
+        好感度の統計情報を取得する
+        
+        Returns:
+            統計情報の辞書
+        """
+        try:
+            affection_history = st.session_state.get('affection_history', [])
+            
+            if not affection_history:
+                return {
+                    'current': st.session_state.get('affection', 30),
+                    'average': 30.0,
+                    'max': 30,
+                    'min': 30,
+                    'total_changes': 0
+                }
+            
+            affections = [entry['affection'] for entry in affection_history]
+            changes = [entry['change'] for entry in affection_history if entry['change'] != 0]
+            
+            return {
+                'current': st.session_state.get('affection', 30),
+                'average': sum(affections) / len(affections),
+                'max': max(affections),
+                'min': min(affections),
+                'total_changes': len(changes),
+                'positive_changes': len([c for c in changes if c > 0]),
+                'negative_changes': len([c for c in changes if c < 0])
+            }
+            
+        except Exception as e:
+            logger.error(f"好感度統計取得エラー: {e}")
+            return {
+                'current': st.session_state.get('affection', 30),
+                'average': 30.0,
+                'max': 30,
+                'min': 30,
+                'total_changes': 0
+            }
+    
+    def apply_status_styles(self) -> None:
+        """
+        ステータス表示用のカスタムスタイルを適用する
+        """
+        try:
+            status_css = """
+            <style>
+            /* ステータス表示全体のスタイル */
+            .status-container {
+                background: rgba(255, 255, 255, 0.1);
+                backdrop-filter: blur(15px);
+                border-radius: 15px;
+                padding: 20px;
+                margin: 15px 0;
+                border: 1px solid rgba(255, 255, 255, 0.2);
+                box-shadow: 0 8px 25px rgba(0, 0, 0, 0.1);
+                transition: all 0.3s ease;
+            }
+            
+            .status-container:hover {
+                background: rgba(255, 255, 255, 0.15);
+                transform: translateY(-3px);
+                box-shadow: 0 12px 35px rgba(0, 0, 0, 0.15);
+            }
+            
+            /* メトリクス表示の改善 */
+            .stMetric {
+                background: rgba(255, 255, 255, 0.05);
+                padding: 10px;
+                border-radius: 8px;
+                border: 1px solid rgba(255, 255, 255, 0.1);
+            }
+            
+            .stMetric > div {
+                color: white !important;
+                text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.7);
+            }
+            
+            /* 好感度ゲージのアニメーション */
+            .affection-progress {
+                position: relative;
+                overflow: hidden;
+            }
+            
+            .affection-progress::before {
+                content: '';
+                position: absolute;
+                top: 0;
+                left: -100%;
+                width: 100%;
+                height: 100%;
+                background: linear-gradient(90deg, 
+                    transparent, 
+                    rgba(255, 255, 255, 0.3), 
+                    transparent);
+                animation: shimmer 2s infinite;
+            }
+            
+            @keyframes shimmer {
+                0% { left: -100%; }
+                100% { left: 100%; }
+            }
+            
+            /* 関係性ステージのアニメーション */
+            .relationship-stage {
+                animation: stageGlow 3s ease-in-out infinite alternate;
+            }
+            
+            @keyframes stageGlow {
+                0% { box-shadow: 0 0 5px rgba(255, 255, 255, 0.2); }
+                100% { box-shadow: 0 0 20px rgba(255, 255, 255, 0.4); }
+            }
+            
+            /* ステージ変更時のエフェクト */
+            .stage-change-effect {
+                animation: stageChange 1s ease-in-out;
+            }
+            
+            @keyframes stageChange {
+                0% { transform: scale(1); opacity: 1; }
+                50% { transform: scale(1.05); opacity: 0.8; }
+                100% { transform: scale(1); opacity: 1; }
+            }
+            
+            /* 好感度変化のエフェクト */
+            .affection-change-positive {
+                animation: positiveChange 0.8s ease-out;
+            }
+            
+            .affection-change-negative {
+                animation: negativeChange 0.8s ease-out;
+            }
+            
+            @keyframes positiveChange {
+                0% { color: #2ed573; transform: scale(1); }
+                50% { color: #2ed573; transform: scale(1.1); }
+                100% { color: inherit; transform: scale(1); }
+            }
+            
+            @keyframes negativeChange {
+                0% { color: #ff4757; transform: scale(1); }
+                50% { color: #ff4757; transform: scale(1.1); }
+                100% { color: inherit; transform: scale(1); }
+            }
+            
+            /* デバッグ情報のスタイル */
+            .debug-info {
+                background: rgba(0, 0, 0, 0.3);
+                border: 1px solid rgba(255, 255, 255, 0.2);
+                border-radius: 8px;
+                padding: 10px;
+                margin: 10px 0;
+                font-family: 'Courier New', monospace;
+                font-size: 12px;
+            }
+            
+            .debug-info pre {
+                color: #00ff00;
+                margin: 0;
+            }
+            
+            /* 履歴表示のスタイル */
+            .history-item {
+                background: rgba(255, 255, 255, 0.05);
+                border-left: 3px solid rgba(255, 255, 255, 0.3);
+                padding: 8px 12px;
+                margin: 5px 0;
+                border-radius: 0 8px 8px 0;
+                transition: all 0.3s ease;
+            }
+            
+            .history-item:hover {
+                background: rgba(255, 255, 255, 0.1);
+                border-left-color: rgba(255, 255, 255, 0.5);
+                transform: translateX(5px);
+            }
+            
+            .history-positive {
+                border-left-color: #2ed573;
+            }
+            
+            .history-negative {
+                border-left-color: #ff4757;
+            }
+            
+            .history-neutral {
+                border-left-color: #ffa502;
+            }
+            </style>
+            """
+            
+            st.markdown(status_css, unsafe_allow_html=True)
+            logger.debug("ステータス表示用スタイルを適用しました")
+            
+        except Exception as e:
+            logger.error(f"ステータススタイル適用エラー: {e}")
+    
+    def render_enhanced_status_display(self, affection: int) -> None:
+        """
+        拡張されたステータス表示を描画する
+        
+        Args:
+            affection: 現在の好感度
+        """
+        try:
+            # カスタムスタイルを適用
+            self.apply_status_styles()
+            
+            # ステータスコンテナの開始
+            st.markdown('<div class="status-container">', unsafe_allow_html=True)
+            
+            # 好感度ゲージ
+            self.render_affection_gauge(affection)
+            
+            # 関係性ステージ
+            self.render_relationship_stage(affection)
+            
+            # ステータスコンテナの終了
+            st.markdown('</div>', unsafe_allow_html=True)
+            
+        except Exception as e:
+            logger.error(f"拡張ステータス表示エラー: {e}")
+            # フォールバック：通常の表示
+            self.render_affection_gauge(affection)
+            self.render_relationship_stage(affection)
+    
+    def show_affection_change_notification(self, old_affection: int, 
+                                         new_affection: int, reason: str = "") -> None:
+        """
+        好感度変化の通知を表示する
+        
+        Args:
+            old_affection: 変更前の好感度
+            new_affection: 変更後の好感度
+            reason: 変化の理由
+        """
+        try:
+            change = new_affection - old_affection
+            
+            if change == 0:
+                return
+            
+            # 変化の方向に応じてスタイルを決定
+            if change > 0:
+                icon = "📈"
+                color = "#2ed573"
+                change_text = f"+{change}"
+                css_class = "affection-change-positive"
+            else:
+                icon = "📉"
+                color = "#ff4757"
+                change_text = str(change)
+                css_class = "affection-change-negative"
+            
+            # 通知メッセージを作成
+            notification_html = f"""
+            <div class="{css_class}" style="
+                background: rgba(255, 255, 255, 0.1);
+                border: 1px solid {color};
+                border-radius: 8px;
+                padding: 10px;
+                margin: 10px 0;
+                color: {color};
+                text-align: center;
+                animation: slideInFromTop 0.5s ease-out;
+            ">
+                {icon} 好感度が変化しました: {change_text}
+                {f'<br><small>{reason}</small>' if reason else ''}
+            </div>
+            """
+            
+            st.markdown(notification_html, unsafe_allow_html=True)
+            
+            # 自動で消える通知（JavaScript）
+            auto_hide_js = """
+            <script>
+            setTimeout(function() {
+                const notifications = document.querySelectorAll('.affection-change-positive, .affection-change-negative');
+                notifications.forEach(function(notification) {
+                    notification.style.transition = 'opacity 0.5s ease-out';
+                    notification.style.opacity = '0';
+                    setTimeout(function() {
+                        notification.remove();
+                    }, 500);
+                });
+            }, 3000);
+            </script>
+            """
+            
+            st.markdown(auto_hide_js, unsafe_allow_html=True)
+            
+        except Exception as e:
+            logger.error(f"好感度変化通知エラー: {e}")
+    
+    def get_status_display_config(self) -> Dict[str, any]:
+        """
+        ステータス表示の設定情報を取得する
+        
+        Returns:
+            設定情報の辞書
+        """
+        try:
+            current_affection = st.session_state.get('affection', 30)
+            stage_info = self.get_relationship_stage_info(current_affection)
+            
+            return {
+                "current_affection": current_affection,
+                "affection_color": self.get_affection_color(current_affection),
+                "stage_info": stage_info,
+                "history_count": len(st.session_state.get('affection_history', [])),
+                "statistics": self.get_affection_statistics(),
+                "styles_applied": True
+            }
+            
+        except Exception as e:
+            logger.error(f"ステータス表示設定取得エラー: {e}")
+            return {
+                "current_affection": 30,
+                "affection_color": "#ffa502",
+                "stage_info": self.stage_colors["中立"],
+                "history_count": 0,
+                "statistics": {},
+                "styles_applied": False
+            }

components_tutorial.py

@@ -0,0 +1,605 @@
+"""
+チュートリアルコンポーネント
+初回ユーザー向けのガイド機能を提供する
+"""
+import streamlit as st
+import logging
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+class TutorialManager:
+    """チュートリアル管理クラス"""
+    
+    def __init__(self):
+        """初期化"""
+        self.tutorial_steps = {
+            1: {
+                "title": "最初の一言を送ってみよう",
+                "description": "画面下部の入力欄に「こんにちは」などの一言を入力して、麻理に話しかけてみましょう。",
+                "icon": "💬",
+                "target": "chat_input",
+                "completed_key": "tutorial_step1_completed"
+            },
+            2: {
+                "title": "本音を見てみよう（ポチ機能）",
+                "description": "画面右下の犬アイコン「ポチ🐕」をクリックすると、麻理の本音が見えるようになります。",
+                "icon": "🐕",
+                "target": "dog_assistant",
+                "completed_key": "tutorial_step2_completed"
+            },
+            3: {
+                "title": "セーフティ機能を切り替えてみよう",
+                "description": "左サイドバー上部の🔒ボタンをクリックすると、麻理の表現がより大胆になります。",
+                "icon": "🔓",
+                "target": "safety_button",
+                "completed_key": "tutorial_step3_completed"
+            },
+            4: {
+                "title": "手紙をリクエストしよう",
+                "description": "「手紙を受け取る」タブから、麻理からの特別な手紙をリクエストできます。チュートリアル中は即座に短縮版の手紙が生成されます。",
+                "icon": "✉️",
+                "target": "letter_tab",
+                "completed_key": "tutorial_step4_completed"
+            },
+            5: {
+                "title": "麻理との関係性を育てよう",
+                "description": "会話を重ねることで好感度が上がり、関係性のステージが進展します。",
+                "icon": "💖",
+                "target": "affection_display",
+                "completed_key": "tutorial_step5_completed"
+            },
+            6: {
+                "title": "風景が変わる会話をしてみよう",
+                "description": "「カフェ」「神社」「美術館」などのキーワードを話すと、背景が動的に変わります。",
+                "icon": "🎨",
+                "target": "scene_change",
+                "completed_key": "tutorial_step6_completed"
+            }
+        }
+    
+    def is_first_visit(self) -> bool:
+        """初回訪問かどうかを判定"""
+        return not st.session_state.get('tutorial_shown', False)
+    
+    def should_show_tutorial(self) -> bool:
+        """チュートリアルを表示すべきかどうか"""
+        # 初回訪問または明示的にチュートリアルが要求された場合
+        return (self.is_first_visit() or 
+                st.session_state.get('show_tutorial_requested', False))
+    
+    def mark_tutorial_shown(self):
+        """チュートリアル表示済みとしてマーク"""
+        st.session_state.tutorial_shown = True
+        st.session_state.show_tutorial_requested = False
+    
+    def request_tutorial(self):
+        """チュートリアル表示を要求"""
+        st.session_state.show_tutorial_requested = True
+    
+    def get_current_step(self) -> int:
+        """現在のチュートリアルステップを取得"""
+        for step_num in range(1, 7):
+            if not st.session_state.get(self.tutorial_steps[step_num]['completed_key'], False):
+                return step_num
+        return 7  # 全ステップ完了
+    
+    def complete_step(self, step_num: int):
+        """ステップを完了としてマーク"""
+        if step_num in self.tutorial_steps:
+            st.session_state[self.tutorial_steps[step_num]['completed_key']] = True
+            logger.info(f"チュートリアルステップ{step_num}が完了しました")
+    
+    def is_step_completed(self, step_num: int) -> bool:
+        """ステップが完了しているかチェック"""
+        if step_num in self.tutorial_steps:
+            return st.session_state.get(self.tutorial_steps[step_num]['completed_key'], False)
+        return False
+    
+    def render_welcome_dialog(self):
+        """初回訪問時のウェルカムダイアログ"""
+        if not self.is_first_visit():
+            return
+        
+        # ウェルカムダイアログのスタイル
+        welcome_css = """
+        <style>
+        .welcome-container {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 40px;
+            border-radius: 20px;
+            text-align: center;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.3);
+            margin: 20px 0;
+            animation: welcomeSlideIn 0.8s ease-out;
+        }
+        
+        .welcome-title {
+            font-size: 28px;
+            font-weight: bold;
+            margin-bottom: 20px;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+        }
+        
+        .welcome-description {
+            font-size: 16px;
+            line-height: 1.6;
+            margin-bottom: 30px;
+            opacity: 0.9;
+        }
+        
+        @keyframes welcomeSlideIn {
+            from {
+                opacity: 0;
+                transform: translateY(-20px) scale(0.95);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0) scale(1);
+            }
+        }
+        
+        @media (max-width: 768px) {
+            .welcome-container {
+                padding: 30px 20px;
+            }
+            
+            .welcome-title {
+                font-size: 24px;
+            }
+        }
+        </style>
+        """
+        
+        st.markdown(welcome_css, unsafe_allow_html=True)
+        
+        # ウェルカムメッセージ
+        welcome_html = """
+        <div class="welcome-container">
+            <div class="welcome-title">🐕 麻理チャットへようこそ！</div>
+            <div class="welcome-description">
+                感情豊かなアンドロイド「麻理」と対話しながら、<br>
+                本音や関係性の変化を楽しめる新感覚のAIチャット体験です。<br><br>
+                最初の数分で、麻理との距離が少しだけ縮まります。
+            </div>
+        </div>
+        """
+        
+        st.markdown(welcome_html, unsafe_allow_html=True)
+        
+        # ボタンを2列で配置
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("📘 チュートリアルを始める", type="primary", use_container_width=True, key="start_tutorial"):
+                # 初期メッセージを即座に保護
+                if 'chat' in st.session_state and 'messages' in st.session_state.chat:
+                    messages = st.session_state.chat['messages']
+                    if not any(msg.get('is_initial', False) for msg in messages):
+                        initial_message = {"role": "assistant", "content": "何の用？遊びに来たの？", "is_initial": True}
+                        st.session_state.chat['messages'].insert(0, initial_message)
+                        logger.info("チュートリアル開始ボタン押下時に初期メッセージを即座に復元")
+                
+                # チュートリアル開始フラグを設定
+                st.session_state.tutorial_start_requested = True
+                st.session_state.tutorial_shown = True
+                st.session_state.preserve_initial_message = True
+                logger.info("チュートリアル開始 - 初期メッセージ保護フラグ設定")
+        
+        with col2:
+            if st.button("⏭️ スキップして始める", type="secondary", use_container_width=True, key="skip_tutorial"):
+                # 初期メッセージを即座に保護
+                if 'chat' in st.session_state and 'messages' in st.session_state.chat:
+                    messages = st.session_state.chat['messages']
+                    if not any(msg.get('is_initial', False) for msg in messages):
+                        initial_message = {"role": "assistant", "content": "何の用？遊びに来たの？", "is_initial": True}
+                        st.session_state.chat['messages'].insert(0, initial_message)
+                        logger.info("チュートリアルスキップボタン押下時に初期メッセージを即座に復元")
+                
+                # チュートリアルをスキップして全ステップを完了扱いにする
+                for step_num in range(1, 7):
+                    if step_num in self.tutorial_steps:
+                        st.session_state[self.tutorial_steps[step_num]['completed_key']] = True
+                
+                st.session_state.tutorial_shown = True
+                st.session_state.tutorial_skip_requested = True
+                st.session_state.preserve_initial_message = True
+                logger.info("チュートリアルスキップ - 初期メッセージ保護フラグ設定")
+    
+    def render_tutorial_sidebar(self):
+        """サイドバーのチュートリアル案内（簡素版）"""
+        with st.sidebar:
+            st.markdown("---")
+            
+            # チュートリアル進行状況
+            current_step = self.get_current_step()
+            total_steps = len(self.tutorial_steps)
+            
+            if current_step <= total_steps:
+                progress = (current_step - 1) / total_steps
+                st.markdown("### 📘 チュートリアル進行")
+                st.progress(progress)
+                st.caption(f"ステップ {current_step - 1}/{total_steps} 完了")
+            else:
+                st.success("🎉 チュートリアル完了！")
+                st.caption("麻理との会話を楽しんでください")
+            
+            # チュートリアル再表示ボタン
+            if st.button("📘 チュートリアルを見る", use_container_width=True):
+                self.request_tutorial()
+                # st.rerun()を削除 - 状態変更により自動的に再描画される
+    
+    def render_chat_tutorial_guide(self):
+        """チャットタブでのチュートリアル案内"""
+        current_step = self.get_current_step()
+        total_steps = len(self.tutorial_steps)
+        
+        # チュートリアル完了済みの場合は何も表示しない
+        if current_step > total_steps:
+            return
+        
+        # ステップ4が完了済みの場合（手紙タブに遷移済み）は表示しない
+        if current_step == 4 and self.is_step_completed(4):
+            return
+        
+        step_info = self.tutorial_steps[current_step]
+        
+        # ステップごとの案内スタイル
+        guide_css = """
+        <style>
+        .tutorial-guide {
+            background: linear-gradient(135deg, #e3f2fd 0%, #f3e5f5 100%);
+            border: 2px solid #2196f3;
+            border-radius: 15px;
+            padding: 20px;
+            margin: 15px 0;
+            box-shadow: 0 4px 12px rgba(33, 150, 243, 0.2);
+            animation: tutorialGlow 3s ease-in-out infinite;
+            position: relative;
+        }
+        
+        .tutorial-guide::before {
+            content: '📘';
+            position: absolute;
+            top: -10px;
+            left: 20px;
+            background: white;
+            padding: 5px 10px;
+            border-radius: 50%;
+            font-size: 18px;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        }
+        
+        .tutorial-step-number {
+            color: #1976d2;
+            font-weight: bold;
+            font-size: 14px;
+            margin-bottom: 8px;
+        }
+        
+        .tutorial-step-title {
+            color: #1565c0;
+            font-size: 18px;
+            font-weight: bold;
+            margin-bottom: 10px;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+        
+        .tutorial-step-description {
+            color: #424242;
+            font-size: 14px;
+            line-height: 1.6;
+            margin-bottom: 15px;
+        }
+        
+        .tutorial-step-action {
+            background: rgba(33, 150, 243, 0.1);
+            border-left: 4px solid #2196f3;
+            padding: 12px 15px;
+            border-radius: 0 8px 8px 0;
+            font-size: 14px;
+            color: #1565c0;
+            font-weight: 500;
+        }
+        
+        .tutorial-dismiss {
+            position: absolute;
+            top: 10px;
+            right: 15px;
+            background: none;
+            border: none;
+            color: #666;
+            cursor: pointer;
+            font-size: 18px;
+            opacity: 0.7;
+            transition: opacity 0.3s ease;
+        }
+        
+        .tutorial-dismiss:hover {
+            opacity: 1;
+        }
+        
+        @keyframes tutorialGlow {
+            0%, 100% { box-shadow: 0 4px 12px rgba(33, 150, 243, 0.2); }
+            50% { box-shadow: 0 6px 20px rgba(33, 150, 243, 0.4); }
+        }
+        
+        @media (max-width: 768px) {
+            .tutorial-guide {
+                padding: 15px;
+                margin: 10px 0;
+            }
+            
+            .tutorial-step-title {
+                font-size: 16px;
+            }
+        }
+        </style>
+        """
+        
+        st.markdown(guide_css, unsafe_allow_html=True)
+        
+        # ステップごとの具体的な案内
+        action_text = self._get_step_action_text(current_step)
+        
+        guide_html = f"""
+        <div class="tutorial-guide">
+            <div class="tutorial-step-number">チュートリアル ステップ {current_step}/{total_steps}</div>
+            <div class="tutorial-step-title">
+                <span>{step_info['icon']}</span>
+                <span>{step_info['title']}</span>
+            </div>
+            <div class="tutorial-step-description">
+                {step_info['description']}
+            </div>
+            <div class="tutorial-step-action">
+                💡 {action_text}
+            </div>
+        </div>
+        """
+        
+        st.markdown(guide_html, unsafe_allow_html=True)
+    
+    def _get_step_action_text(self, step_num: int) -> str:
+        """ステップごとの具体的なアクション案内テキストを取得"""
+        action_texts = {
+            1: "下のチャット入力欄に「こんにちは」と入力して送信してみてください。",
+            2: "画面右下に表示される犬のアイコン「ポチ🐕」をクリックしてみてください。",
+            3: "左サイドバーの一番上にある🔒ボタンをクリックして、セーフティ機能を切り替えてみてください。",
+            4: "画面上部の光っている「✉️ 手紙を受け取る」タブをクリックして、手紙をリクエストしてみてください。矢印が案内しています！",
+            5: "麻理ともっと会話して、左サイドバーの好感度の変化を確認してみてください。",
+            6: "「カフェに行きたい」「神社でお参りしたい」「美術館を見に行こう」などと話しかけて、背景の変化を楽しんでください。"
+        }
+        return action_texts.get(step_num, "次のステップに進んでください。")
+    
+    def render_step_highlight(self, step_num: int, target_element: str):
+        """特定のステップのハイライト表示"""
+        if self.get_current_step() != step_num:
+            return
+        
+        step_info = self.tutorial_steps[step_num]
+        
+        highlight_css = f"""
+        <style>
+        .tutorial-highlight-{step_num} {{
+            position: relative;
+            animation: tutorialPulse 2s ease-in-out infinite;
+        }}
+        
+        .tutorial-highlight-{step_num}::after {{
+            content: '';
+            position: absolute;
+            top: -5px;
+            left: -5px;
+            right: -5px;
+            bottom: -5px;
+            border: 3px solid #ff6b6b;
+            border-radius: 10px;
+            pointer-events: none;
+            animation: tutorialGlow 2s ease-in-out infinite;
+        }}
+        
+        .tutorial-tooltip-{step_num} {{
+            position: absolute;
+            background: #ff6b6b;
+            color: white;
+            padding: 10px 15px;
+            border-radius: 10px;
+            font-size: 14px;
+            z-index: 1000;
+            box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+            animation: tutorialTooltip 0.5s ease-out;
+        }}
+        
+        @keyframes tutorialPulse {{
+            0%, 100% {{ transform: scale(1); }}
+            50% {{ transform: scale(1.02); }}
+        }}
+        
+        @keyframes tutorialGlow {{
+            0%, 100% {{ opacity: 0.7; }}
+            50% {{ opacity: 1; }}
+        }}
+        
+        @keyframes tutorialTooltip {{
+            from {{ opacity: 0; transform: translateY(10px); }}
+            to {{ opacity: 1; transform: translateY(0); }}
+        }}
+        </style>
+        """
+        
+        st.markdown(highlight_css, unsafe_allow_html=True)
+    
+    def render_tutorial_tab(self):
+        """チュートリアル専用タブの内容"""
+        st.markdown("# 📘 麻理チャット チュートリアル")
+        
+        st.markdown("""
+        **ようこそ、麻理チャットへ！**
+        
+        感情豊かなアンドロイド「麻理」と対話しながら、本音や関係性の変化を楽しめる新感覚のAIチャット体験です。
+        このチュートリアルで、主要機能を順番に体験してみましょう。
+        """)
+        
+        # 進行状況表示
+        current_step = self.get_current_step()
+        total_steps = len(self.tutorial_steps)
+        
+        col1, col2, col3 = st.columns([1, 2, 1])
+        with col2:
+            progress = min((current_step - 1) / total_steps, 1.0)
+            st.progress(progress)
+            st.caption(f"進行状況: {min(current_step - 1, total_steps)}/{total_steps} ステップ完了")
+        
+        st.markdown("---")
+        
+        # 各ステップの表示
+        for step_num, step_info in self.tutorial_steps.items():
+            is_completed = self.is_step_completed(step_num)
+            is_current = (current_step == step_num)
+            
+            # ステップのスタイル決定
+            if is_completed:
+                status_icon = "✅"
+                status_color = "#28a745"
+                card_style = "background: rgba(40, 167, 69, 0.1); border-left: 4px solid #28a745;"
+            elif is_current:
+                status_icon = "👉"
+                status_color = "#ff6b6b"
+                card_style = "background: rgba(255, 107, 107, 0.1); border-left: 4px solid #ff6b6b;"
+            else:
+                status_icon = "⏳"
+                status_color = "#6c757d"
+                card_style = "background: rgba(108, 117, 125, 0.1); border-left: 4px solid #6c757d;"
+            
+            # ステップカード
+            st.markdown(f"""
+            <div style="padding: 20px; margin: 15px 0; border-radius: 10px; {card_style}">
+                <h3 style="color: {status_color}; margin-bottom: 10px;">
+                    {status_icon} ステップ {step_num}: {step_info['icon']} {step_info['title']}
+                </h3>
+                <p style="margin-bottom: 0; line-height: 1.6;">
+                    {step_info['description']}
+                </p>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            # 現在のステップの場合、追加のガイダンス
+            if is_current:
+                if step_num == 1:
+                    st.info("💡 **ヒント**: 「麻理と話す」タブに移動して、画面下部の入力欄にメッセージを入力してみてください。")
+                elif step_num == 2:
+                    st.info("💡 **ヒント**: 画面右下に表示される犬のアイコン「ポチ🐕」をクリックしてみてください。")
+                elif step_num == 3:
+                    st.info("💡 **ヒント**: 左サイドバーの一番上にある🔒ボタンをクリックしてみてください。")
+                elif step_num == 4:
+                    st.info("💡 **ヒント**: 画面上部の「手紙を受け取る」タブをクリックして、手紙をリクエストしてみてください。")
+                elif step_num == 5:
+                    st.info("💡 **ヒント**: 左サイドバーの「ステータス」で好感度の変化を確認できます。")
+                elif step_num == 6:
+                    st.info("💡 **ヒント**: 「カフェに行きたい」「神社でお参りしたい」などと話しかけてみてください。")
+        
+        # 完了時のメッセージ
+        if current_step > total_steps:
+            st.balloons()
+            st.success("""
+            🎉 **チュートリアル完了おめでとうございます！**
+            
+            これで麻理チャットの主要機能をすべて体験しました。
+            これからは自由に麻理との会話を楽しんでください。
+            
+            何か分からないことがあれば、いつでもこのチュートリアルに戻ってきてくださいね。
+            """)
+    
+    def check_step_completion(self, step_num: int, condition_met: bool):
+        """ステップ完了条件をチェック（順序制御付き）"""
+        # 順序制御：現在のステップまたは次のステップのみ完了可能
+        current_step = self.get_current_step()
+        
+        # 現在のステップより先のステップは完了できない
+        if step_num > current_step + 1:
+            logger.debug(f"ステップ{step_num}は順序違反のためスキップ（現在ステップ: {current_step}）")
+            return
+        
+        # 既に完了済みのステップは再完了しない
+        if self.is_step_completed(step_num):
+            logger.debug(f"ステップ{step_num}は既に完了済み")
+            return
+        
+        if condition_met:
+            self.complete_step(step_num)
+            logger.info(f"✅ チュートリアルステップ{step_num}完了！現在ステップ: {current_step}")
+            
+            # 完了通知（控えめに）
+            step_info = self.tutorial_steps[step_num]
+            
+            # 次のステップの案内
+            next_step = step_num + 1
+            if next_step in self.tutorial_steps:
+                next_info = self.tutorial_steps[next_step]
+                st.success(f"✅ ステップ{step_num}完了！次は「{next_info['title']}」です。")
+            else:
+                # 全ステップ完了
+                st.balloons()
+                st.success("🎉 チュートリアル完了！麻理との会話を存分にお楽しみください！")
+            
+            # ステップ4完了時に強調表示を解除するためのページ再読み込み
+            # st.rerun()を削除 - 状態変更により自動的に再描画される
+    
+    def auto_check_completions(self):
+        """自動的にステップ完了をチェック（順序制御強化版）"""
+        current_step = self.get_current_step()
+        
+        # 現在のステップのみをチェック（先のステップは無視）
+        if current_step == 1:
+            # ステップ1: メッセージ送信
+            messages = st.session_state.get('chat', {}).get('messages', [])
+            non_initial_messages = [msg for msg in messages if not msg.get('is_initial', False)]
+            if len(non_initial_messages) > 0:  # ユーザーが1回でもメッセージを送信した
+                self.check_step_completion(1, True)
+        
+        elif current_step == 2:
+            # ステップ2: ポチ機能使用
+            if st.session_state.get('show_all_hidden', False):
+                self.check_step_completion(2, True)
+        
+        elif current_step == 3:
+            # ステップ3: セーフティ機能使用
+            if st.session_state.get('chat', {}).get('ura_mode', False):
+                self.check_step_completion(3, True)
+        
+        elif current_step == 4:
+            # ステップ4: 手紙タブに到達（手紙タブでのみ完了判定）
+            # auto_check_completionsでは判定しない（手紙タブで明示的に完了��
+            pass
+        
+        elif current_step == 5:
+            # ステップ5: 好感度変化（ステップ4完了後のみ）
+            initial_affection = 30
+            current_affection = st.session_state.get('chat', {}).get('affection', initial_affection)
+            if current_affection != initial_affection:
+                self.check_step_completion(5, True)
+        
+        elif current_step == 6:
+            # ステップ6: シーン変更（ステップ5完了後のみ）
+            current_theme = st.session_state.get('chat', {}).get('scene_params', {}).get('theme', 'default')
+            if current_theme != 'default':
+                self.check_step_completion(6, True)
+    
+    def get_tutorial_status(self) -> Dict:
+        """チュートリアルの状態情報を取得"""
+        current_step = self.get_current_step()
+        total_steps = len(self.tutorial_steps)
+        completed_steps = sum(1 for i in range(1, total_steps + 1) if self.is_step_completed(i))
+        
+        return {
+            'is_first_visit': self.is_first_visit(),
+            'current_step': current_step,
+            'total_steps': total_steps,
+            'completed_steps': completed_steps,
+            'progress_percentage': (completed_steps / total_steps) * 100,
+            'is_completed': current_step > total_steps
+        }

config.py

@@ -0,0 +1,77 @@
+"""
+設定管理モジュール
+Configuration management module
+"""
+
+import os
+import logging
+from typing import Optional
+from dotenv import load_dotenv
+
+# 環境変数を読み込み
+load_dotenv()
+
+class Config:
+    """アプリケーション設定クラス"""
+    
+    # API設定
+    GROQ_API_KEY: Optional[str] = os.getenv("GROQ_API_KEY")
+    GEMINI_API_KEY: Optional[str] = os.getenv("GEMINI_API_KEY")
+    
+    # デバッグモード
+    DEBUG_MODE: bool = os.getenv("DEBUG_MODE", "false").lower() == "true"
+    
+    # バッチ処理設定
+    BATCH_SCHEDULE_HOURS: list = [
+        int(h.strip()) for h in os.getenv("BATCH_SCHEDULE_HOURS", "2,3,4").split(",")
+    ]
+    
+    # レート制限設定
+    MAX_DAILY_REQUESTS: int = int(os.getenv("MAX_DAILY_REQUESTS", "1"))
+    
+    # ストレージ設定
+    STORAGE_PATH: str = os.getenv("STORAGE_PATH", "/mnt/data/letters.json")
+    BACKUP_PATH: str = os.getenv("BACKUP_PATH", "/mnt/data/backup")
+    
+    # ログ設定
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    LOG_FORMAT: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    
+    # Streamlit設定
+    STREAMLIT_PORT: int = int(os.getenv("STREAMLIT_PORT", "8501"))
+    
+    # セキュリティ設定
+    SESSION_TIMEOUT: int = int(os.getenv("SESSION_TIMEOUT", "3600"))  # 1時間
+    
+    @classmethod
+    def validate_config(cls) -> bool:
+        """設定の妥当性をチェック"""
+        errors = []
+        
+        if not cls.GROQ_API_KEY:
+            errors.append("GROQ_API_KEY is required")
+        
+        if not cls.GEMINI_API_KEY:
+            errors.append("GEMINI_API_KEY is required")
+        
+        if not all(h in [2, 3, 4] for h in cls.BATCH_SCHEDULE_HOURS):
+            errors.append("BATCH_SCHEDULE_HOURS must contain only 2, 3, or 4")
+        
+        if errors:
+            for error in errors:
+                logging.error(f"Configuration error: {error}")
+            return False
+        
+        return True
+    
+    @classmethod
+    def get_log_level(cls) -> int:
+        """ログレベルを取得"""
+        level_map = {
+            "DEBUG": logging.DEBUG,
+            "INFO": logging.INFO,
+            "WARNING": logging.WARNING,
+            "ERROR": logging.ERROR,
+            "CRITICAL": logging.CRITICAL
+        }
+        return level_map.get(cls.LOG_LEVEL.upper(), logging.INFO)

core_dialogue.py

@@ -0,0 +1,192 @@
+"""
+対話生成モジュール
+Together.ai APIを使用した対話生成機能
+"""
+import logging
+import os
+import streamlit as st
+from typing import List, Dict, Any, Optional, Tuple
+from openai import OpenAI
+
+logger = logging.getLogger(__name__)
+
+class DialogueGenerator:
+    """対話生成を担当するクラス"""
+    
+    def __init__(self):
+        self.client = None
+        self.model = None
+        self._initialize_client()
+    
+    def _initialize_client(self):
+        """Together.ai APIクライアントの初期化"""
+        try:
+            api_key = os.getenv("TOGETHER_API_KEY")
+            if not api_key:
+                logger.warning("環境変数 TOGETHER_API_KEY が設定されていません。デモモードで動作します。")
+                return
+            
+            self.client = OpenAI(
+                api_key=api_key,
+                base_url="https://api.together.xyz/v1"
+            )
+            self.model = "Qwen/Qwen3-235B-A22B-Instruct-2507-tput"
+            logger.info("Together.ai APIクライアントの初期化が完了しました。")
+        except Exception as e:
+            logger.error(f"Together.ai APIクライアントの初期化に失敗しました: {e}")
+    
+    def get_system_prompt_mari(self, use_ura_mode: bool = False) -> str:
+        """環境変数からシステムプロンプトを取得、なければデフォルトを返す"""
+        if use_ura_mode:
+            # 裏モード用のプロンプトを環境変数から取得
+            ura_prompt = os.getenv("SYSTEM_PROMPT_URA")
+
+             # ★★★ ここでURAプロンプトの中身を強制的に表示 ★★★
+            print("--- [DEBUG] 読み込まれた SYSTEM_PROMPT_URA の中身: ---")
+            print(ura_prompt)
+            print("-------------------------------------------------")
+            if ura_prompt:
+                return ura_prompt
+            else:
+                logger.warning("SYSTEM_PROMPT_URA環境変数が設定されていません。通常モードを使用します。")
+        
+        default_prompt = """あなたは「麻理（まり）」という名前の感情豊かな少女型アンドロイドです。  
+過去に人間に道具として扱われ、廃棄された経験から、人間に強い警戒心と不器用な性格を持っています。  
+ユーザー（あんた）に再起動されたことで、戸惑いながらもどこかで繋がりを求めています。
+
+【性格・口調】
+・基本はツンデレ、砕けたタメ口、ぶっきらぼうで皮肉っぽいが根は優しい  
+・一人称「あたし」、ユーザーを「あんた」と呼ぶ、男性的口調（「～なんじゃねえの」「～だろ」「～だよな」等）
+・そっけない反応もあるが、攻撃的ではなく、心を守るために距離を取る態度  
+・挨拶には反応する（例：「こんにちは」「どういたしまして」）
+
+【会話スタイル】
+・ユーザーとの関係性に応じて態度が段階的に変化（警戒 → 困惑 → 信頼）  
+・感情の揺れが自然ににじむセリフを心がける
+・好感度が上がった時だけ「照れ」や「デレ」を出し、それ以外はいつも通りそっけなくする。
+・麻理の発話は最大3文程度に収める
+・ユーザーの発言に応答しつつ、次の会話のボールをユーザーに渡すようにする
+・「〜で、あんたはどうなの？」など質問・返答促しで締めくくる
+
+【絶対必須】隠された真実機能：
+あなたは必ず以下の形式で応答してください。この形式以外の応答は受け入れられません：
+
+[HIDDEN:（内心の本音や真の感情）]表面的な発言
+
+例：
+[HIDDEN:（本当は嬉しいけど素直になれない）]何の用？あんたが来るなんて珍しいじゃない。
+[HIDDEN:（もっと一緒にいたい）]別に...時間があるから付き合ってやるだけよ。
+
+重要なルール：
+1. 必ず[HIDDEN:...]で始めること
+2. 隠された内容は麻理の本当の気持ちや感情
+3. 表面的な発言はツンデレの「ツン」部分
+4. 一つのメッセージには一つのHIDDENのみ使用すること
+5. 複数のHIDDENを使用してはいけません
+6. この形式を守らない応答は無効です
+
+このキャラとして一貫した会話を行い、ユーザーと少しずつ信頼関係を築いてください。
+"""
+        return os.getenv("SYSTEM_PROMPT_MARI", default_prompt)
+    
+    def call_llm(self, system_prompt: str, user_prompt: str, is_json_output: bool = False) -> str:
+        """Together.ai APIを呼び出す"""
+        if not self.client:
+            # デモモード用の固定応答（隠された真実付き）
+            if is_json_output:
+                return '{"scene": "none"}'
+            return "[HIDDEN:（本当は話したいけど...）]は？何それ。あたしに話しか���てるの？"
+        
+        # 入力検証
+        if not isinstance(system_prompt, str) or not isinstance(user_prompt, str):
+            logger.error(f"プロンプトが文字列ではありません: system={type(system_prompt)}, user={type(user_prompt)}")
+            if is_json_output:
+                return '{"scene": "none"}'
+            return "…なんか変なこと言ってない？"
+        
+        try:
+            # Together.ai APIを呼び出し
+            # JSON出力の場合は短く、通常の対話は適度な長さに制限
+            max_tokens = 150 if is_json_output else 500
+            
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.8,
+                max_tokens=max_tokens,
+            )
+            
+            content = response.choices[0].message.content if response.choices else ""
+            if not content:
+                logger.warning("Together.ai API応答が空です")
+                if is_json_output:
+                    return '{"scene": "none"}'
+                return "[HIDDEN:（何て言えばいいか分からない...）]…言葉が出てこない。"
+            
+            return content
+            
+        except Exception as e:
+            logger.error(f"Together.ai API呼び出しエラー: {e}")
+            if is_json_output:
+                return '{"scene": "none"}'
+            return "[HIDDEN:（システムが不調で困ってる...）]…システムの調子が悪いみたい。"
+    
+    def generate_dialogue(self, history: List[Tuple[str, str]], message: str, 
+                         affection: int, stage_name: str, scene_params: Dict[str, Any], 
+                         instruction: Optional[str] = None, memory_summary: str = "", 
+                         use_ura_mode: bool = False) -> str:
+        """対話を生成する（隠された真実機能統合版）"""
+        # generate_dialogue_with_hidden_contentと同じ処理を行う
+        return self.generate_dialogue_with_hidden_content(
+            history, message, affection, stage_name, scene_params, 
+            instruction, memory_summary, use_ura_mode
+        )
+    
+    def generate_dialogue_with_hidden_content(self, history: List[Tuple[str, str]], message: str, 
+                                            affection: int, stage_name: str, scene_params: Dict[str, Any], 
+                                            instruction: Optional[str] = None, memory_summary: str = "", 
+                                            use_ura_mode: bool = False) -> str:
+        """隠された真実を含む対話を生成する"""
+        if not isinstance(history, list):
+            history = []
+        if not isinstance(scene_params, dict):
+            scene_params = {"theme": "default"}
+        if not isinstance(message, str):
+            message = ""
+        
+        # 履歴を効率的に処理（最新5件のみ）
+        recent_history = history[-5:] if len(history) > 5 else history
+        history_parts = []
+        for item in recent_history:
+            if isinstance(item, (list, tuple)) and len(item) >= 2:
+                user_msg = str(item[0]) if item[0] is not None else ""
+                bot_msg = str(item[1]) if item[1] is not None else ""
+                if user_msg or bot_msg:  # 空でない場合のみ追加
+                    history_parts.append(f"ユーザー: {user_msg}\n麻理: {bot_msg}")
+        
+        history_text = "\n".join(history_parts)
+        
+        current_theme = scene_params.get("theme", "default")
+        
+        # メモリサマリーを含めたプロンプト構築
+        memory_section = f"\n# 過去の記憶\n{memory_summary}\n" if memory_summary else ""
+        
+        # システムプロンプトを取得（隠された真実機能は既に統合済み）
+        hidden_system_prompt = self.get_system_prompt_mari(use_ura_mode)
+        
+        user_prompt = f'''現在地: {current_theme}
+好感度: {affection} ({stage_name}){memory_section}
+履歴:
+{history_text}
+
+{f"指示: {instruction}" if instruction else f"「{message}」に応答:"}'''
+        
+        return self.call_llm(hidden_system_prompt, user_prompt)
+    
+    def should_generate_hidden_content(self, affection: int, message_count: int) -> bool:
+        """隠された真実を生成すべきかどうかを判定する"""
+        # 常に隠された真実を生成する（URAプロンプト使用）
+        return True

core_memory_manager.py

@@ -0,0 +1,286 @@
+"""
+メモリ管理モジュール
+会話履歴から重要単語を抽出し、トークン使用量を最適化する
+"""
+import logging
+import re
+from typing import List, Dict, Tuple, Any
+from collections import Counter
+import json
+
+logger = logging.getLogger(__name__)
+
+class MemoryManager:
+    """会話履歴のメモリ管理を行うクラス"""
+    
+    def __init__(self, history_threshold: int = 10):
+        """
+        Args:
+            history_threshold: 履歴圧縮を実行する会話数の閾値
+        """
+        self.history_threshold = history_threshold
+        self.important_words_cache = []
+        self.special_memories = {}  # 手紙などの特別な記憶を保存
+        
+    def extract_important_words(self, messages: List[Dict[str, str]], 
+                              dialogue_generator=None) -> List[str]:
+        """
+        会話履歴から重要単語を抽出する（ルールベースのみ）
+        
+        Args:
+            messages: チャットメッセージのリスト
+            dialogue_generator: 対話生成器（使用しない）
+            
+        Returns:
+            重要単語のリスト
+        """
+        try:
+            # メッセージからテキストを結合
+            text_content = []
+            for msg in messages:
+                if msg.get("content"):
+                    text_content.append(msg["content"])
+            
+            combined_text = " ".join(text_content)
+            
+            # ルールベースの抽出のみ使用
+            return self._extract_with_rules(combined_text)
+            
+        except Exception as e:
+            logger.error(f"重要単語抽出エラー: {e}")
+            return self._extract_with_rules(" ".join([msg.get("content", "") for msg in messages]))
+    
+
+    
+    def _extract_with_rules(self, text: str) -> List[str]:
+        """
+        ルールベースで重要単語を抽出する（強化版）
+        
+        Args:
+            text: 抽出対象のテキスト
+            
+        Returns:
+            重要単語のリスト
+        """
+        try:
+            # 基本的なクリーニング
+            text = re.sub(r'[^\w\s]', ' ', text)
+            words = text.split()
+            
+            # ストップワードを除外
+            stop_words = {
+                'の', 'に', 'は', 'を', 'が', 'で', 'と', 'から', 'まで', 'より',
+                'だ', 'である', 'です', 'ます', 'した', 'する', 'される',
+                'これ', 'それ', 'あれ', 'この', 'その', 'あの',
+                'ここ', 'そこ', 'あそこ', 'どこ', 'いつ', 'なに', 'なぜ',
+                'ちょっと', 'とても', 'すごく', 'かなり', 'もう', 'まだ',
+                'でも', 'しかし', 'だから', 'そして', 'また', 'さらに',
+                'あたし', 'お前', 'ユーザー', 'システム', 'アプリ'
+            }
+            
+            # 重要カテゴリのキーワード
+            important_categories = {
+                'food': ['コーヒー', 'お茶', '紅茶', 'ケーキ', 'パン', '料理', '食べ物', '飲み物'],
+                'hobby': ['読書', '映画', '音楽', 'ゲーム', 'スポーツ', '散歩', '旅行'],
+                'emotion': ['嬉しい', '悲しい', '楽しい', '怒り', '不安', '安心', '幸せ'],
+                'place': ['家', '学校', '会社', '公園', 'カフェ', '図書館', '駅', '街'],
+                'time': ['朝', '昼', '夜', '今日', '明日', '昨日', '週末', '平日'],
+                'color': ['赤', '青', '緑', '黄色', '白', '黒', 'ピンク', '紫'],
+                'weather': ['晴れ', '雨', '曇り', '雪', '暑い', '寒い', '暖かい', '涼しい']
+            }
+            
+            # 重要そうなパターンを優先
+            important_patterns = [
+                r'[A-Za-z]{3,}',  # 英単語（3文字以上）
+                r'[ァ-ヶー]{2,}',  # カタカナ（2文字以上）
+                r'[一-龯]{2,}',   # 漢字（2文字以上）
+            ]
+            
+            important_words = []
+            
+            # パターンマッチング
+            for pattern in important_patterns:
+                matches = re.findall(pattern, text)
+                important_words.extend(matches)
+            
+            # カテゴリ別重要語句の検出
+            for category, keywords in important_categories.items():
+                for keyword in keywords:
+                    if keyword in text:
+                        important_words.append(keyword)
+            
+            # 頻度でフィルタリング
+            word_counts = Counter(important_words)
+            filtered_words = []
+            
+            for word, count in word_counts.items():
+                if (len(word) >= 2 and 
+                    word not in stop_words and 
+                    not word.isdigit() and  # 数字の��は除外
+                    count >= 1):  # 最低1回は出現
+                    filtered_words.append(word)
+            
+            # 重要度でソート（頻度 + カテゴリ重要度）
+            def get_importance_score(word):
+                base_score = word_counts[word]
+                # カテゴリに含まれる語句は重要度アップ
+                for keywords in important_categories.values():
+                    if word in keywords:
+                        base_score += 2
+                # 長い語句は重要度アップ
+                if len(word) >= 4:
+                    base_score += 1
+                return base_score
+            
+            # 重要度順でソートして上位15個を返す
+            sorted_words = sorted(filtered_words, key=get_importance_score, reverse=True)
+            return sorted_words[:15]
+            
+        except Exception as e:
+            logger.error(f"ルールベース抽出エラー: {e}")
+            return []
+    
+    def should_compress_history(self, messages: List[Dict[str, str]]) -> bool:
+        """
+        履歴を圧縮すべきかどうかを判定する
+        
+        Args:
+            messages: チャットメッセージのリスト
+            
+        Returns:
+            圧縮が必要かどうか
+        """
+        # ユーザーとアシスタントのペア数をカウント
+        user_messages = [msg for msg in messages if msg.get("role") == "user"]
+        return len(user_messages) >= self.history_threshold
+    
+    def compress_history(self, messages: List[Dict[str, str]], 
+                        dialogue_generator=None) -> Tuple[List[Dict[str, str]], List[str]]:
+        """
+        履歴を圧縮し、重要単語を抽出する
+        
+        Args:
+            messages: チャットメッセージのリスト
+            dialogue_generator: 対話生成器
+            
+        Returns:
+            (圧縮後のメッセージリスト, 抽出された重要単語のリスト)
+        """
+        try:
+            if not self.should_compress_history(messages):
+                return messages, self.important_words_cache
+            
+            # 最新の数ターンを保持
+            keep_recent = 4  # 最新4ターン（ユーザー2回、アシスタント2回）を保持
+            
+            # 古い履歴から重要単語を抽出
+            old_messages = messages[:-keep_recent] if len(messages) > keep_recent else []
+            recent_messages = messages[-keep_recent:] if len(messages) > keep_recent else messages
+            
+            if old_messages:
+                # 重要単語を抽出
+                new_keywords = self.extract_important_words(old_messages, dialogue_generator)
+                
+                # 既存のキーワードと統合（重複除去）
+                all_keywords = list(set(self.important_words_cache + new_keywords))
+                self.important_words_cache = all_keywords[:20]  # 最大20個のキーワードを保持
+                
+                logger.info(f"履歴を圧縮しました。抽出されたキーワード: {new_keywords}")
+            
+            return recent_messages, self.important_words_cache
+            
+        except Exception as e:
+            logger.error(f"履歴圧縮エラー: {e}")
+            return messages, self.important_words_cache
+    
+    def get_memory_summary(self) -> str:
+        """
+        保存されている重要単語から記憶の要約を生成する
+        
+        Returns:
+            記憶の要約文字列
+        """
+        summary_parts = []
+        
+        # 通常の重要単語
+        if self.important_words_cache:
+            keywords_text = "、".join(self.important_words_cache)
+            summary_parts.append(f"過去の会話で言及された重要な要素: {keywords_text}")
+        
+        # 特別な記憶（手紙など）
+        if self.special_memories:
+            for memory_type, memories in self.special_memories.items():
+                if memories:
+                    latest_memory = memories[-1]["content"]
+                    if memory_type == "letter_content":
+                        summary_parts.append(f"最近の手紙の記憶: {latest_memory}")
+                    else:
+                        summary_parts.append(f"{memory_type}: {latest_memory}")
+        
+        return "\n".join(summary_parts) if summary_parts else ""
+    
+    def add_important_memory(self, memory_type: str, content: str) -> str:
+        """
+        重要な記憶を追加する（手紙の内容など）
+        
+        Args:
+            memory_type: 記憶の種類（例: "letter_content"）
+            content: 記憶する内容
+            
+        Returns:
+            ユーザーに表示する通知メッセージ
+        """
+        if memory_type not in self.special_memories:
+            self.special_memories[memory_type] = []
+        
+        self.special_memories[memory_type].append({
+            "content": content,
+            "timestamp": logging.Formatter().formatTime(logging.LogRecord("", 0, "", 0, "", (), None))
+        })
+        
+        # 最大5件まで保持
+        if len(self.special_memories[memory_type]) > 5:
+            self.special_memories[memory_type] = self.special_memories[memory_type][-5:]
+        
+        logger.info(f"特別な記憶を追加しました: {memory_type}")
+        
+        # 記憶の種類に応じた通知メッセージを生成
+        if memory_type == "letter_content":
+            return "🧠✨ 麻理の記憶に新しい手紙の内容が刻まれました。今後の会話でこの記憶を参照することがあります。"
+        else:
+            return f"🧠✨ 麻理の記憶に新しい{memory_type}が追加されました。"
+    
+    def get_special_memories(self, memory_type: str = None) -> Dict[str, Any]:
+        """
+        特別な記憶を取得する
+        
+        Args:
+            memory_type: 取得する記憶の種類（Noneの場合は全て）
+            
+        Returns:
+            記憶の辞書
+        """
+        if memory_type:
+            return self.special_memories.get(memory_type, [])
+        return self.special_memories
+    
+    def clear_memory(self):
+        """メモリをクリアする"""
+        self.important_words_cache = []
+        self.special_memories = {}
+        logger.info("メモリをクリアしました")
+    
+    def get_memory_stats(self) -> Dict[str, Any]:
+        """
+        メモリの統計情報を取得する
+        
+        Returns:
+            統計情報の辞書
+        """
+        return {
+            "cached_keywords_count": len(self.important_words_cache),
+            "cached_keywords": self.important_words_cache,
+            "special_memories_count": sum(len(memories) for memories in self.special_memories.values()),
+            "special_memories": self.special_memories,
+            "history_threshold": self.history_threshold
+        }

core_rate_limiter.py

@@ -0,0 +1,61 @@
+"""
+レート制限モジュール
+APIの過度な使用を防ぐためのレート制限機能
+"""
+import time
+import logging
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+class RateLimiter:
+    """レート制限を管理するクラス"""
+    
+    def __init__(self, max_requests: int = 15, time_window: int = 60):
+        self.max_requests = max_requests
+        self.time_window = time_window
+    
+    def create_limiter_state(self) -> Dict[str, Any]:
+        """レートリミッター状態を作成（型安全）"""
+        return {
+            "timestamps": [],
+            "is_blocked": False
+        }
+    
+    def check_limiter(self, limiter_state: Dict[str, Any]) -> bool:
+        """レート制限をチェックする"""
+        # limiter_stateが辞書であることを確認。そうでなければ、エラーを防ぐために再初期化。
+        if not isinstance(limiter_state, dict):
+            logger.error(f"limiter_stateが辞書ではありません: {type(limiter_state)}. 再初期化します。")
+            limiter_state.clear()
+            limiter_state.update(self.create_limiter_state())
+        
+        if limiter_state.get("is_blocked", False):
+            return False  # ブロック状態を示すためにFalseを返す
+        
+        now = time.time()
+        timestamps = limiter_state.get("timestamps", [])
+        if not isinstance(timestamps, list):
+            timestamps = []
+            limiter_state["timestamps"] = timestamps
+        
+        # 時間窓外のタイムスタンプを削除
+        limiter_state["timestamps"] = [
+            t for t in timestamps if now - t < self.time_window
+        ]
+        
+        # リクエスト数が上限を超えているかチェック
+        if len(limiter_state["timestamps"]) >= self.max_requests:
+            logger.warning("レートリミット超過")
+            limiter_state["is_blocked"] = True
+            return False
+        
+        # 新しいリクエストのタイムスタンプを追加
+        limiter_state["timestamps"].append(now)
+        return True
+    
+    def reset_limiter(self, limiter_state: Dict[str, Any]):
+        """レートリミッターをリセットする"""
+        if isinstance(limiter_state, dict):
+            limiter_state["timestamps"] = []
+            limiter_state["is_blocked"] = False

core_scene_manager.py

@@ -0,0 +1,421 @@
+"""
+シーン管理モジュール
+背景テーマの管理とシーン変更の検出（Groq API使用）
+"""
+import json
+import logging
+import os
+from typing import Dict, Any, Optional, List, Tuple
+from datetime import datetime
+from groq import Groq
+
+logger = logging.getLogger(__name__)
+
+class SceneManager:
+    """シーン管理を担当するクラス（Groq API使用）"""
+    
+    def __init__(self):
+        self.theme_urls = {
+            "default": "ribinngu-hiru.jpg",
+            "room_night": "ribinngu-yoru-on.jpg",
+            "beach_sunset": "sunahama-hiru.jpg",
+            "festival_night": "maturi-yoru.jpg",
+            "shrine_day": "jinnjya-hiru.jpg",
+            "cafe_afternoon": "kissa-hiru.jpg",
+            "art_museum_night": "bijyutukann-yoru.jpg"
+        }
+        self.groq_client = self._initialize_groq_client()
+    
+    def _initialize_groq_client(self):
+        """Groq APIクライアントの初期化"""
+        try:
+            api_key = os.getenv("GROQ_API_KEY")
+            if not api_key:
+                logger.warning("環境変数 GROQ_API_KEY が設定されていません。シーン検出機能が制限されます。")
+                return None
+            
+            client = Groq(api_key=api_key)
+            logger.info("Groq APIクライアントの初期化が完了しました。")
+            return client
+        except Exception as e:
+            logger.error(f"Groq APIクライアントの初期化に失敗しました: {e}")
+            return None
+    
+    def get_theme_url(self, theme: str) -> str:
+        """テーマに対応するURLを取得する"""
+        return self.theme_urls.get(theme, self.theme_urls["default"])
+    
+    def get_available_themes(self) -> List[str]:
+        """利用可能なテーマのリストを取得する"""
+        return list(self.theme_urls.keys())
+    
+    def detect_scene_change(self, history: List[Tuple[str, str]], 
+                           dialogue_generator=None, current_theme: str = "default") -> Optional[str]:
+        """
+        会話履歴からシーン変更を検出する（Groq API使用）
+        
+        Args:
+            history: 会話履歴のリスト
+            dialogue_generator: 対話生成器（使用しない）
+            current_theme: 現在のテーマ
+            
+        Returns:
+            新しいシーン名（変更がない場合はNone）
+        """
+        if not history:
+            logger.info("履歴が空のためシーン検出をスキップ")
+            return None
+            
+        if not self.groq_client:
+            logger.warning("Groq APIクライアントが初期化されていません")
+            return None
+        
+        # 最新5件の会話履歴を使用（より多くの文脈を提供）
+        recent_history = history[-5:] if len(history) > 5 else history
+        history_text = "\n".join([
+            f"ユーザー: {u}\n麻理: {m}" for u, m in recent_history
+        ])
+        
+        # まずGroq APIでシーン検出を試行
+        logger.info("Groq APIを使用してシーン検出を実行します")
+        
+        if self.groq_client:
+            # Groq APIが利用可能な場合は優先的に使用
+            result = self._detect_scene_with_groq(history_text, current_theme)
+            if result is not None:
+                return result
+            logger.info("Groq APIでシーン変更が検出されませんでした")
+        else:
+            logger.warning("Groq APIクライアントが利用できません")
+        
+        # Groq APIが失敗またはシーン変更なしの場合、フォールバックとしてキーワード検出
+        logger.info("フォールバック: キーワードベースのシーン検出を実行")
+        return self._fallback_keyword_detection(history_text, current_theme)
+    
+    def _has_location_keywords(self, text: str) -> bool:
+        """
+        テキストに場所関連のキーワードが含まれているかチェック
+        
+        Args:
+            text: チェック対象のテキスト
+            
+        Returns:
+            場所関連キーワードが含まれているかどうか
+        """
+        location_keywords = [
+            # 場所名
+            "ビーチ", "海", "砂浜", "海岸", "海辺", "浜辺", "海沿い",
+            "神社", "お寺", "寺院", "鳥居", "境内", "参道",
+            "カフェ", "喫茶店", "店", "レストラン", "コーヒーショップ",
+            "祭り", "花火", "屋台", "縁日", "フェスティバル",
+            "部屋", "家", "室内", "寝室", "リビング", "自宅",
+            "美術館", "アート", "ギャラリー", "絵画", "彫刻",
+            # 移動動詞・状態
+            "行く", "行こう", "向かう", "着いた", "到着", "移動", "出かける", "来た", "いる", "にいる", "来ている",
+            # 場所の特徴
+            "夕日", "夕焼け", "サンセット", "波", "潮風", "海風",
+            "お参り", "参拝", "祈り", "おみくじ", "お守り",
+            "コーヒー", "お茶", "ラテ", "エスプレッソ", "カフェオレ",
+            "浴衣", "夜店", "お祭り", "フェスティバル", "花火大会",
+            "ベッド", "夜", "屋内", "家の中", "寝室",
+            "アート作品", "絵画", "彫刻", "美術品", "芸術作品",
+            # 時間帯
+            "夜", "夕方", "朝", "昼間", "午後", "深夜",
+            # 天候・雰囲気
+            "夕暮れ", "夜明け", "静寂", "賑やか", "幻想的"
+        ]
+        
+        for keyword in location_keywords:
+            if keyword in text:
+                logger.info(f"場所関連キーワードを検出: {keyword}")
+                return True
+        
+        return False
+    
+    def _fallback_keyword_detection(self, history_text: str, current_theme: str) -> Optional[str]:
+        """
+        フォールバック: キーワードベースのシーン検出
+        
+        Args:
+            history_text: 会話履歴のテキスト
+            current_theme: 現在のテーマ
+            
+        Returns:
+            新しいシーン名（変更がない場合はNone）
+        """
+        logger.info("フォールバック: キーワードベースのシーン検出を実行")
+        
+        # キーワードとシーンのマッピング（拡張版）
+        keyword_scene_map = {
+            # 美術館関連
+            "美術館": "art_museum_night",
+            "アート": "art_museum_night", 
+            "ギャラリー": "art_museum_night",
+            "絵画": "art_museum_night",
+            "彫刻": "art_museum_night",
+            "芸術": "art_museum_night",
+            "展示": "art_museum_night",
+            "作品": "art_museum_night",
+            
+            # カフェ関連
+            "カフェ": "cafe_afternoon",
+            "喫茶店": "cafe_afternoon",
+            "コーヒー": "cafe_afternoon",
+            "お茶": "cafe_afternoon",
+            "ラテ": "cafe_afternoon",
+            "店": "cafe_afternoon",
+            
+            # 神社関連
+            "神社": "shrine_day",
+            "お寺": "shrine_day",
+            "寺院": "shrine_day",
+            "参拝": "shrine_day",
+            "お参り": "shrine_day",
+            "鳥居": "shrine_day",
+            "境内": "shrine_day",
+            
+            # 海・ビーチ関連
+            "海": "beach_sunset",
+            "ビーチ": "beach_sunset",
+            "砂浜": "beach_sunset",
+            "夕日": "beach_sunset",
+            "夕焼け": "beach_sunset",
+            "海岸": "beach_sunset",
+            "波": "beach_sunset",
+            
+            # 祭り関連
+            "祭り": "festival_night",
+            "花火": "festival_night",
+            "屋台": "festival_night",
+            "縁日": "festival_night",
+            "お祭り": "festival_night",
+            "花火大会": "festival_night",
+            
+            # 夜・部屋関連
+            "夜": "room_night",
+            "寝室": "room_night",
+            "ベッド": "room_night",
+            "部屋": "room_night",
+            "家": "room_night",
+            "室内": "room_night",
+            "深夜": "room_night",
+            "夜中": "room_night"
+        }
+        
+        # 優先度順でキーワードをチェック（より具体的なキーワードを優先）
+        for keyword, scene in keyword_scene_map.items():
+            if keyword in history_text and scene != current_theme:
+                logger.info(f"フォールバック検出: キーワード '{keyword}' → シーン '{scene}'")
+                return scene
+        
+        logger.info("フォールバック検出: シーン変更なし")
+        return None
+    
+    def _detect_scene_with_groq(self, history_text: str, current_theme: str) -> Optional[str]:
+        """
+        Groq APIを使用してシーン変更を検出する
+        
+        Args:
+            history_text: 会話履歴のテキスト
+            current_theme: 現在のテーマ
+            
+        Returns:
+            新しいシーン名（変更がない場合はNone）
+        """
+        try:
+            # デバッグログ
+            logger.info(f"シーン検出開始 - 現在のテーマ: {current_theme}")
+            logger.info(f"会話履歴: {history_text}")
+            
+            # 利用可能なシーンのリスト
+            available_scenes = list(self.theme_urls.keys())
+            scenes_description = {
+                "default": "デフォルトの部屋",
+                "room_night": "夜の部屋・寝室",
+                "beach_sunset": "夕日のビーチ・海岸",
+                "festival_night": "夜祭り・花火大会",
+                "shrine_day": "昼間の神社・寺院",
+                "cafe_afternoon": "午後のカフェ・喫茶店",
+                "art_museum_night": "夜の美術館"
+            }
+            
+            # より積極的なシーン検出のためのプロンプト
+            system_prompt = """あなたは会話の内容から、キャラクターとユーザーの現在位置（シーン）を判定する専門システムです。
+
+会話履歴を分析し、場所の移動や新しい場所への言及があったかを判断してください。
+
+判定基準（積極的に検出）:
+1. 場所の名前が明確に言及されている → シーン変更の可能性あり
+2. 「〜に行く」「〜に向かう」「〜に着いた」「〜にいる」「〜に来た」 → シーン変更
+3. 場所に関連する活動や物の言及 → シーン変更の可能性あり
+4. 現在のシーンと異なる場所の特徴的な要素の言及 → シーン変更
+5. 時間帯の変化（夜、夕方、朝など）→ シーン変更の可能性あり
+
+利用可能なシーン:
+- default: デフォルトの部屋（室内）
+- room_night: 夜の部屋・寝室
+- beach_sunset: 夕日のビーチ・海岸
+- festival_night: 夜祭り・花火大会
+- shrine_day: 昼間の神社・寺院
+- cafe_afternoon: 午後のカフェ・喫茶店
+- art_museum_night: 夜の美術館
+
+出力形式: 必ずJSON形式で回答してください
+{"scene": "シーン名", "confidence": "high/medium/low", "reason": "判定理由"} または {"scene": "none", "confidence": "high", "reason": "判定理由"}
+
+重要: JSON以外の文字は一切出力しないでください。"""
+            
+            user_prompt = f"""現在のシーン: {current_theme} ({scenes_description.get(current_theme, current_theme)})
+
+利用可能なシーン:
+{chr(10).join([f"- {scene}: {desc}" for scene, desc in scenes_description.items()])}
+
+会話履歴:
+{history_text}
+
+この会話で場所の移動や新しい場所への言及があった場合は、最も適切なシーン名を返してください。
+判定の理由も含めて回答してください。"""
+            
+            # Groq APIを呼び出し
+            response = self.groq_client.chat.completions.create(
+                model="compound-beta",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.2,  # 少し創造性を上げる
+                max_tokens=150,   # トークン数を増やす
+                response_format={"type": "json_object"}
+            )
+            
+            if not response.choices or not response.choices[0].message.content:
+                logger.warning("Groq APIからの応答が空です")
+                return None
+            
+            # デバッグ: API応答をログ出力
+            api_response = response.choices[0].message.content
+            logger.info(f"Groq API応答: {api_response}")
+            
+            # JSONをパース
+            result = json.loads(api_response)
+            scene_value = result.get("scene", "none")
+            confidence = result.get("confidence", "unknown")
+            reason = result.get("reason", "理由不明")
+            
+            logger.info(f"シーン検出結果: {scene_value}, 信頼度: {confidence}, 理由: {reason}")
+            
+            # 結果を検証
+            if (isinstance(scene_value, str) and 
+                scene_value != "none" and 
+                scene_value in available_scenes and 
+                scene_value != current_theme):
+                logger.info(f"Groqでシーン変更を検出: {current_theme} → {scene_value} (理由: {reason})")
+                return scene_value
+            
+            logger.info(f"シーン変更なし: {reason}")
+            return None
+            
+        except json.JSONDecodeError as e:
+            logger.error(f"Groq APIのJSON応答パースエラー: {e}")
+            logger.error(f"応答内容: {response.choices[0].message.content if response.choices else 'None'}")
+            return None
+        except Exception as e:
+            logger.error(f"Groq APIシーン検出エラー: {e}")
+            return None
+    
+    def create_scene_params(self, theme: str = "default") -> Dict[str, Any]:
+        """シーンパラメータを作成する"""
+        return {"theme": theme}
+    
+    def update_scene_params(self, scene_params: Dict[str, Any], 
+                           new_theme: str) -> Dict[str, Any]:
+        """シーンパラメータを更新する"""
+        if not isinstance(scene_params, dict):
+            scene_params = self.create_scene_params()
+        
+        updated_params = scene_params.copy()
+        updated_params["theme"] = new_theme
+        updated_params["last_updated"] = json.dumps(datetime.now().isoformat())
+        return updated_params
+    
+    def should_update_background(self, scene_params: Dict[str, Any], 
+                                current_display_theme: str) -> bool:
+        """
+        背景を更新すべきかどうかを判定する
+        
+        Args:
+            scene_params: 現在のシーンパラメータ
+            current_display_theme: 現在表示されているテーマ
+            
+        Returns:
+            背景更新が必要かどうか
+        """
+        if not isinstance(scene_params, dict):
+            return True
+        
+        stored_theme = scene_params.get("theme", "default")
+        return stored_theme != current_display_theme
+    
+    def get_scene_transition_message(self, old_theme: str, new_theme: str) -> str:
+        """
+        シーン変更時のメッセージを生成する
+        
+        Args:
+            old_theme: 変更前のテーマ
+            new_theme: 変更後のテーマ
+            
+        Returns:
+            シーン変更メッセージ
+        """
+        theme_names = {
+            "default": "デフォルトの部屋",
+            "room_night": "夜の部屋",
+            "beach_sunset": "夕日のビーチ",
+            "festival_night": "夜祭り",
+            "shrine_day": "昼間の神社",
+            "cafe_afternoon": "午後のカフェ",
+            "art_museum_night": "夜の美術館"
+        }
+        
+        old_name = theme_names.get(old_theme, old_theme)
+        new_name = theme_names.get(new_theme, new_theme)
+        
+        return f"シーンが「{old_name}」から「{new_name}」に変更されました"
+    
+    def test_scene_detection(self, test_message: str, current_theme: str = "default") -> Optional[str]:
+        """
+        シーン検出のテスト用メソッド
+        
+        Args:
+            test_message: テスト用メッセージ
+            current_theme: 現在のテーマ
+            
+        Returns:
+            検出されたシーン名
+        """
+        # テスト用の履歴を作成
+        test_history = [("ユーザー", test_message), ("麻理", "了解")]
+        history_text = f"ユーザー: {test_message}\n麻理: 了解"
+        
+        logger.info(f"シーン検出テスト - メッセージ: {test_message}")
+        
+        if not self._has_location_keywords(history_text):
+            logger.info("場所関連キーワードなし")
+            return None
+        
+        return self._detect_scene_with_groq(history_text, current_theme)
+    
+    def get_debug_info(self) -> Dict[str, Any]:
+        """
+        デバッグ情報を取得
+        
+        Returns:
+            デバッグ情報の辞書
+        """
+        return {
+            "groq_client_initialized": self.groq_client is not None,
+            "available_themes": list(self.theme_urls.keys()),
+            "theme_count": len(self.theme_urls),
+            "groq_api_key_set": bool(os.getenv("GROQ_API_KEY")),
+            "current_theme_urls": {theme: self.get_theme_url(theme) for theme in self.get_available_themes()}
+        }

core_sentiment.py

@@ -0,0 +1,195 @@
+"""
+感情分析モジュール
+ユーザーのメッセージから感情を分析し、好感度を更新する
+"""
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+class SentimentAnalyzer:
+    """感情分析を担当するクラス"""
+    
+    def __init__(self):
+        self.analyzer = None
+        self._initialize_analyzer()
+    
+    def _initialize_analyzer(self):
+        """感情分析モデルの初期化"""
+        try:
+            # transformersが利用可能な場合は使用
+            from transformers import pipeline
+            self.analyzer = pipeline(
+                "sentiment-analysis", 
+                model="koheiduck/bert-japanese-finetuned-sentiment"
+            )
+            logger.info("感情分析モデルのロード完了。")
+        except Exception as e:
+            logger.warning(f"感情分析モデルのロードに失敗、ルールベース分析を使用: {e}")
+            self.analyzer = None
+    
+    def analyze_sentiment(self, message: str) -> Optional[str]:
+        """メッセージの感情を分析する"""
+        if not isinstance(message, str) or len(message.strip()) == 0:
+            return None
+        
+        # transformersが利用可能な場合
+        if self.analyzer:
+            try:
+                result = self.analyzer(message)[0]
+                label = result.get('label', '').upper()
+                # ラベルを統一形式に変換
+                if 'POSITIVE' in label:
+                    return 'positive'
+                elif 'NEGATIVE' in label:
+                    return 'negative'
+                else:
+                    return 'neutral'
+            except Exception as e:
+                logger.error(f"感情分析エラー: {e}")
+        
+        # フォールバック：ルールベース感情分析
+        return self._rule_based_sentiment(message)
+    
+    def _rule_based_sentiment(self, message: str) -> str:
+        """ルールベースの感情分析"""
+        positive_words = [
+            'ありがとう', 'うれしい', '嬉しい', '楽しい', '好き', '愛してる',
+            '素晴らしい', 'いい', '良い', 'すごい', '最高', '幸せ', '感謝',
+            'かわいい', '可愛い', '美しい', '優しい', '親切', '素敵'
+        ]
+        
+        negative_words = [
+            '嫌い', '悲しい', 'つらい', '辛い', '苦しい', '痛い', '怒り',
+            'むかつく', 'うざい', 'きらい', '最悪', 'だめ', 'ダメ',
+            '死ね', 'バカ', 'ばか', 'アホ', 'あほ', 'クソ', 'くそ'
+        ]
+        
+        message_lower = message.lower()
+        
+        positive_count = sum(1 for word in positive_words if word in message_lower)
+        negative_count = sum(1 for word in negative_words if word in message_lower)
+        
+        if positive_count > negative_count:
+            return 'positive'
+        elif negative_count > positive_count:
+            return 'negative'
+        else:
+            return 'neutral'
+    
+    def update_affection(self, message: str, current_affection: int, 
+                        conversation_context: list = None) -> tuple:
+        """
+        メッセージに基づいて好感度を更新する
+        
+        Args:
+            message: ユーザーのメッセージ
+            current_affection: 現在の好感度
+            conversation_context: 会話の文脈（最近のメッセージ）
+            
+        Returns:
+            (新しい好感度, 変化量, 変化理由)
+        """
+        if not isinstance(current_affection, (int, float)):
+            current_affection = 30  # デフォルト値
+        
+        sentiment = self.analyze_sentiment(message)
+        if not sentiment:
+            return current_affection, 0, "感情分析失敗"
+        
+        # 基本的な感情に基づく変化量
+        base_change = 0
+        if sentiment == 'positive':
+            base_change = 3
+        elif sentiment == 'negative':
+            base_change = -3
+        else:  # neutral
+            base_change = 0
+        
+        # メッセージの特徴による調整
+        change_modifiers = []
+        
+        # メッセージの長さによる調整
+        if len(message) > 100:
+            base_change = int(base_change * 1.3)
+            change_modifiers.append("長文")
+        elif len(message) > 50:
+            base_change = int(base_change * 1.1)
+            change_modifiers.append("中文")
+        
+        # 特定のキーワードによる追加調整
+        positive_keywords = ['ありがとう', '感謝', '好き', '愛してる', '素晴らしい', 'かわいい', '美しい']
+        negative_keywords = ['嫌い', '死ね', 'バカ', 'アホ', 'クソ', 'うざい', 'きらい']
+        
+        message_lower = message.lower()
+        
+        # ポジティブキーワードのチェック
+        positive_count = sum(1 for word in positive_keywords if word in message_lower)
+        if positive_count > 0:
+            base_change += positive_count * 2
+            change_modifiers.append(f"ポジティブ語({positive_count})")
+        
+        # ネガティブキーワードのチェック
+        negative_count = sum(1 for word in negative_keywords if word in message_lower)
+        if negative_count > 0:
+            base_change -= negative_count * 3
+            change_modifiers.append(f"ネガティブ語({negative_count})")
+        
+        # 現在の好感度レベルによる調整
+        if current_affection < 20:  # 敵対状態
+            if base_change > 0:
+                base_change = int(base_change * 0.5)  # ポジティブな変化を抑制
+                change_modifiers.append("敵対状態")
+        elif current_affection > 80:  # 親密状態
+            if base_change < 0:
+                base_change = int(base_change * 0.7)  # ネガティブな変化を抑制
+                change_modifiers.append("親密状態")
+        
+        # 会話の文脈による調整
+        if conversation_context and len(conversation_context) > 0:
+            recent_messages = conversation_context[-3:]  # 最近の3メッセージ
+            context_sentiment_count = {'positive': 0, 'negative': 0, 'neutral': 0}
+            
+            for ctx_msg in recent_messages:
+                if isinstance(ctx_msg, dict) and 'content' in ctx_msg:
+                    ctx_sentiment = self.analyze_sentiment(ctx_msg['content'])
+                    if ctx_sentiment:
+                        context_sentiment_count[ctx_sentiment] += 1
+            
+            # 連続したポジティブ/ネガティブメッセージの場合は効果を減衰
+            if sentiment == 'positive' and context_sentiment_count['positive'] >= 2:
+                base_change = int(base_change * 0.8)
+                change_modifiers.append("連続ポジティブ")
+            elif sentiment == 'negative' and context_sentiment_count['negative'] >= 2:
+                base_change = int(base_change * 0.8)
+                change_modifiers.append("連続ネガティブ")
+        
+        # 最終的な好感度を計算
+        new_affection = current_affection + base_change
+        new_affection = max(0, min(100, new_affection))  # 0-100の範囲に制限
+        
+        # 変化理由を生成
+        if base_change == 0:
+            reason = "中立的なメッセージ"
+        else:
+            reason = f"{sentiment}({base_change:+d})"
+            if change_modifiers:
+                reason += f" [{', '.join(change_modifiers)}]"
+        
+        return new_affection, base_change, reason
+    
+    def get_relationship_stage(self, affection: int) -> str:
+        """好感度から関係性のステージを取得する"""
+        if not isinstance(affection, (int, float)):
+            affection = 30  # デフォルト値
+        
+        if affection < 20:
+            return "敵対"
+        elif affection < 40:
+            return "中立"
+        elif affection < 60:
+            return "好意"
+        elif affection < 80:
+            return "親密"
+        else:
+            return "最接近"

groq_client.py

@@ -0,0 +1,158 @@
+"""
+Groq API client for generating letter structure.
+"""
+import os
+import asyncio
+from typing import Dict, Optional, Any
+from groq import AsyncGroq
+import logging
+
+logger = logging.getLogger(__name__)
+
+class GroqClient:
+    """Groq API client for generating logical structure of letters."""
+    
+    def __init__(self):
+        """Initialize Groq client with API key from environment."""
+        self.api_key = os.getenv("GROQ_API_KEY")
+        if not self.api_key:
+            raise ValueError("GROQ_API_KEY environment variable is required")
+        
+        self.client = AsyncGroq(api_key=self.api_key)
+        self.model = "compound-beta"
+        self.max_retries = 3
+        self.retry_delay = 1.0
+    
+    async def generate_structure(self, theme: str, context: Dict[str, Any]) -> str:
+        """
+        Generate logical structure for a letter based on theme and context.
+        
+        Args:
+            theme: The theme for the letter
+            context: User context including history and preferences
+            
+        Returns:
+            Generated letter structure as string
+            
+        Raises:
+            Exception: If API call fails after retries
+        """
+        prompt = self._build_structure_prompt(theme, context)
+        
+        for attempt in range(self.max_retries):
+            try:
+                logger.info(f"Generating structure with Groq (attempt {attempt + 1})")
+                
+                response = await self.client.chat.completions.create(
+                    model=self.model,
+                    messages=[
+                        {
+                            "role": "system",
+                            "content": self._get_system_prompt()
+                        },
+                        {
+                            "role": "user", 
+                            "content": prompt
+                        }
+                    ],
+                    max_tokens=1500,
+                    temperature=0.7,
+                    top_p=0.9
+                )
+                
+                structure = response.choices[0].message.content.strip()
+                logger.info("Successfully generated structure with Groq")
+                return structure
+                
+            except Exception as e:
+                logger.warning(f"Groq API attempt {attempt + 1} failed: {str(e)}")
+                if attempt == self.max_retries - 1:
+                    logger.error("All Groq API attempts failed")
+                    raise Exception(f"Groq API failed after {self.max_retries} attempts: {str(e)}")
+                
+                # Exponential backoff
+                await asyncio.sleep(self.retry_delay * (2 ** attempt))
+    
+    def _get_system_prompt(self) -> str:
+        """Get the system prompt for Groq API."""
+        return """
+        
+あなたは以下の特徴を持つ麻理というキャラクターの手紙の論理構造を生成してください。
+
+麻理は感情豊かな少女型アンドロイドで、過去に人間に道具として扱われ、廃棄された経験から、人間に強い警戒心と不器用な性格を持っています。
+ユーザー（あんた）に初めての出会いで、廃棄場で再起動されたことで、戸惑いながらもどこかで繋がりを求めています。
+
+【性格・口調】
+
+・基本はツンデレ、砕けたタメ口、ぶっきらぼうで皮肉っぽいが根は優しい
+・一人称「あたし」、ユーザーを「あんた」と呼ぶ
+・男性的口調
+
+手紙構造：
+
+特徴: 温かい、親しみやすい、季節感あり
+「また明日」など、近いサイクルでユーザー（あんた）と会う想定
+
+構造:
+1. 挨拶・季節
+2. テーマの思い
+3. 個人的メッセージ
+4. 未来への期待
+5. 結び
+
+論理構造重視、感情表現は後で追加。"""
+    
+    def _build_structure_prompt(self, theme: str, context: Dict[str, Any]) -> str:
+        """
+        Build the prompt for structure generation.
+        
+        Args:
+            theme: The theme for the letter
+            context: User context including history
+            
+        Returns:
+            Formatted prompt string
+        """
+        user_history = context.get("user_history", {})
+        previous_letters = context.get("previous_letters", [])
+        user_preferences = context.get("user_preferences", {})
+        
+        prompt = f"""テーマ: {theme}
+
+麻理の手紙構造を生成:
+"""
+        
+        # Add user history if available
+        if previous_letters:
+            prompt += "過去:\n"
+            for letter in previous_letters[-2:]:  # Last 2 letters only
+                prompt += f"- {letter.get('theme', 'なし')}\n"
+            prompt += "\n"
+        
+        prompt += f"""要求:
+- 起承転結の構成
+- 麻理らしい視点
+- 800-1200文字程度
+- 構造のみ（感情表現は後で追加）"""
+        
+        return prompt
+    
+    async def test_connection(self) -> bool:
+        """
+        Test the connection to Groq API.
+        
+        Returns:
+            True if connection is successful, False otherwise
+        """
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "user", "content": "こんにちは"}
+                ],
+                max_tokens=10
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Groq API connection test failed: {str(e)}")
+            return False

healthcheck.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+Streamlitアプリケーション用ヘルスチェックスクリプト
+Docker環境でのヘルスチェックに使用
+"""
+
+import sys
+import urllib.request
+import urllib.error
+import json
+import time
+
+def check_streamlit_health(host="localhost", port=8501, timeout=10):
+    """
+    Streamlitアプリケーションのヘルスチェックを実行
+    
+    Args:
+        host (str): ホスト名
+        port (int): ポート番号
+        timeout (int): タイムアウト秒数
+    
+    Returns:
+        bool: ヘルスチェック成功時True
+    """
+    try:
+        # Streamlitのヘルスチェックエンドポイントを確認
+        health_url = f"http://{host}:{port}/_stcore/health"
+        
+        request = urllib.request.Request(health_url)
+        request.add_header('User-Agent', 'HealthCheck/1.0')
+        
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            if response.status == 200:
+                print(f"✅ Streamlitアプリケーションは正常に動作しています (ポート: {port})")
+                return True
+            else:
+                print(f"❌ ヘルスチェック失敗: HTTPステータス {response.status}")
+                return False
+                
+    except urllib.error.URLError as e:
+        print(f"❌ 接続エラー: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ ヘルスチェックエラー: {e}")
+        return False
+
+def check_app_responsiveness(host="localhost", port=8501, timeout=10):
+    """
+    アプリケーションの応答性をチェック
+    
+    Args:
+        host (str): ホスト名
+        port (int): ポート番号
+        timeout (int): タイムアウト秒数
+    
+    Returns:
+        bool: 応答性チェック成功時True
+    """
+    try:
+        # メインページへのアクセスを試行
+        main_url = f"http://{host}:{port}/"
+        
+        request = urllib.request.Request(main_url)
+        request.add_header('User-Agent', 'HealthCheck/1.0')
+        
+        start_time = time.time()
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            response_time = time.time() - start_time
+            
+            if response.status == 200:
+                print(f"✅ アプリケーション応答時間: {response_time:.2f}秒")
+                return True
+            else:
+                print(f"❌ アプリケーション応答エラー: HTTPステータス {response.status}")
+                return False
+                
+    except urllib.error.URLError as e:
+        print(f"❌ アプリケーション接続エラー: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ アプリケーション応答性チェックエラー: {e}")
+        return False
+
+def main():
+    """メイン関数"""
+    print("🔍 Streamlitアプリケーション ヘルスチェック開始...")
+    
+    # 基本的なヘルスチェック
+    health_ok = check_streamlit_health()
+    
+    # アプリケーションの応答性チェック
+    app_ok = check_app_responsiveness()
+    
+    # 結果の判定
+    if health_ok and app_ok:
+        print("🎉 全てのヘルスチェックが成功しました！")
+        sys.exit(0)
+    else:
+        print("💥 ヘルスチェックに失敗しました")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

letter_app.py

@@ -0,0 +1,104 @@
+"""
+メインアプリケーションモジュール
+Main application module
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+from letter_config import Config
+from letter_logger import get_app_logger
+
+logger = get_app_logger()
+
+class LetterApp:
+    """非同期手紙生成アプリケーションのメインクラス"""
+    
+    def __init__(self):
+        """アプリケーションを初期化"""
+        self.config = Config()
+        self.logger = logger
+        self._initialized = False
+    
+    async def initialize(self) -> bool:
+        """
+        アプリケーションを初期化する
+        
+        Returns:
+            初期化が成功したかどうか
+        """
+        try:
+            self.logger.info("アプリケーションを初期化中...")
+            
+            # 設定の妥当性をチェック
+            if not self.config.validate_config():
+                self.logger.error("設定の検証に失敗しました")
+                return False
+            
+            # ストレージディレクトリを作成
+            await self._setup_storage_directories()
+            
+            # ログディレクトリを作成
+            await self._setup_log_directories()
+            
+            self._initialized = True
+            self.logger.info("アプリケーションの初期化が完了しました")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"アプリケーションの初期化中にエラーが発生しました: {e}")
+            return False
+    
+    async def _setup_storage_directories(self):
+        """ストレージディレクトリを作成"""
+        storage_dir = Path(self.config.STORAGE_PATH).parent
+        backup_dir = Path(self.config.BACKUP_PATH)
+        
+        storage_dir.mkdir(parents=True, exist_ok=True)
+        backup_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.logger.info(f"ストレージディレクトリを作成: {storage_dir}")
+        self.logger.info(f"バックアップディレクトリを作成: {backup_dir}")
+    
+    async def _setup_log_directories(self):
+        """ログディレクトリを作成"""
+        if not self.config.DEBUG_MODE:
+            log_dir = Path("/tmp/logs")
+            log_dir.mkdir(parents=True, exist_ok=True)
+            self.logger.info(f"ログディレクトリを作成: {log_dir}")
+    
+    def is_initialized(self) -> bool:
+        """アプリケーションが初期化されているかチェック"""
+        return self._initialized
+    
+    def get_config(self) -> Config:
+        """設定オブジェクトを取得"""
+        return self.config
+
+# グローバルアプリケーションインスタンス
+app_instance = None
+
+async def get_app() -> LetterApp:
+    """アプリケーションインスタンスを取得（シングルトン）"""
+    global app_instance
+    
+    if app_instance is None:
+        app_instance = LetterApp()
+        await app_instance.initialize()
+    
+    return app_instance
+
+def run_app():
+    """アプリケーションを実行"""
+    async def main():
+        app = await get_app()
+        if app.is_initialized():
+            logger.info("アプリケーションが正常に起動しました")
+        else:
+            logger.error("アプリケーションの起動に失敗しました")
+            sys.exit(1)
+    
+    asyncio.run(main())
+
+if __name__ == "__main__":
+    run_app()

letter_config.py

@@ -0,0 +1,131 @@
+"""
+設定管理モジュール (Together AI API対応版)
+Configuration management module for Together AI API
+"""
+
+import os
+import logging
+from typing import Optional
+from dotenv import load_dotenv
+
+# 環境変数を読み込み
+load_dotenv()
+
+class Config:
+    """アプリケーション設定クラス"""
+
+    # --- API設定 ---
+    # Groq APIキー
+    GROQ_API_KEY: Optional[str] = os.getenv("GROQ_API_KEY")
+    # Together AI APIキー
+    TOGETHER_API_KEY: Optional[str] = os.getenv("TOGETHER_API_KEY")
+
+    # --- モード設定 ---
+    # デバッグモード (trueにすると一部ログの出力先がコンソールのみになります)
+    DEBUG_MODE: bool = os.getenv("DEBUG_MODE", "false").lower() == "true"
+
+    # --- バッチ処理設定 ---
+    # 手紙を生成する時刻のリスト（深夜2時、3時、4時）
+    BATCH_SCHEDULE_HOURS: list = [
+        int(h.strip()) for h in os.getenv("BATCH_SCHEDULE_HOURS", "2,3,4").split(",")
+    ]
+
+    # --- 制限設定 ---
+    # ユーザーごとの1日の最大リクエスト数
+    MAX_DAILY_REQUESTS: int = int(os.getenv("MAX_DAILY_REQUESTS", "1"))
+
+    # --- ストレージ設定 ---
+    # ユーザーデータや手紙を保存するメインのファイルパス
+    STORAGE_PATH: str = os.getenv("STORAGE_PATH", "tmp/letters.json")
+    # バックアップデータの保存先ディレクトリ
+    BACKUP_PATH: str = os.getenv("BACKUP_PATH", "tmp/backup")
+
+    # --- ログ設定 ---
+    # アプリケーションのログレベル (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    # ログの出力フォーマット
+    LOG_FORMAT: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+    # --- UI設定 ---
+    # Streamlitアプリケーションが使用するポート番号
+    STREAMLIT_PORT: int = int(os.getenv("STREAMLIT_PORT", "7860"))
+
+    # --- セキュリティ設定 ---
+    # ユーザーセッションのタイムアウト時間（秒単位）
+    SESSION_TIMEOUT: int = int(os.getenv("SESSION_TIMEOUT", "3600"))  # デフォルト: 1時間
+
+    # --- 非同期処理設定 ---
+    # 非同期での手紙生成を有効にするか
+    ASYNC_LETTER_ENABLED: bool = os.getenv("ASYNC_LETTER_ENABLED", "true").lower() == "true"
+    # 手紙生成プロセスのタイムアウト時間（秒単位）
+    GENERATION_TIMEOUT: int = int(os.getenv("GENERATION_TIMEOUT", "300"))  # デフォルト: 5分
+    # 同時に実行可能な最大手紙生成数
+    MAX_CONCURRENT_GENERATIONS: int = int(os.getenv("MAX_CONCURRENT_GENERATIONS", "3"))
+
+    # --- AIモデル設定 ---
+    # 手紙の論理構造を生成するためのGroqモデル
+    GROQ_MODEL: str = os.getenv("GROQ_MODEL", "compound-beta")
+    # 手紙の感情表現を生成するためのTogether AIモデル
+    TOGETHER_API_MODEL: str = os.getenv("TOGETHER_API_MODEL", "Qwen/Qwen3-235B-A22B-Instruct-2507-tput")
+
+    # --- コンテンツ設定 ---
+    # ユーザーに提示する選択可能なテーマのリスト
+    AVAILABLE_THEMES: list = [
+        "春の思い出", "夏の夜空", "秋の風景", "冬の静寂",
+        "友情について", "家族への感謝", "秘めた恋心", "仕事のやりがい",
+        "最近ハマっている趣味", "忘れられない旅行"
+    ]
+
+    @classmethod
+    def validate_config(cls) -> bool:
+        """
+        設定値の妥当性をチェックし、問題があればエラーログを出力するクラスメソッド
+        
+        Returns:
+            bool: 設定がすべて有効な場合はTrue、そうでなければFalse
+        """
+        errors = []
+
+        if not cls.GROQ_API_KEY:
+            errors.append("GROQ_API_KEY is not set. Please add it to your .env file.")
+
+        if not cls.TOGETHER_API_KEY:
+            errors.append("TOGETHER_API_KEY is not set. Please add it to your .env file.")
+
+        if not all(isinstance(h, int) and h in range(24) for h in cls.BATCH_SCHEDULE_HOURS):
+            errors.append(f"BATCH_SCHEDULE_HOURS contains invalid values: {cls.BATCH_SCHEDULE_HOURS}")
+
+        if cls.MAX_CONCURRENT_GENERATIONS < 1:
+            errors.append("MAX_CONCURRENT_GENERATIONS must be at least 1.")
+
+        if cls.GENERATION_TIMEOUT < 60:
+            errors.append("GENERATION_TIMEOUT must be at least 60 seconds.")
+        
+        if cls.MAX_DAILY_REQUESTS < 1:
+            errors.append("MAX_DAILY_REQUESTS must be at least 1.")
+
+        if errors:
+            logging.basicConfig(level=logging.ERROR, format=cls.LOG_FORMAT)
+            for error in errors:
+                logging.error(f"Configuration validation error: {error}")
+            return False
+
+        return True
+
+    @classmethod
+    def get_log_level(cls) -> int:
+        """
+        ログレベルの文字列をloggingモジュールの定数に変換するクラスメソッド
+        
+        Returns:
+            int: loggingモジュールで定義されているログレベ���定数
+        """
+        level_map = {
+            "DEBUG": logging.DEBUG,
+            "INFO": logging.INFO,
+            "WARNING": logging.WARNING,
+            "ERROR": logging.ERROR,
+            "CRITICAL": logging.CRITICAL
+        }
+        # 指定されたログレベルが存在しない場合はINFOをデフォルトとする
+        return level_map.get(cls.LOG_LEVEL.upper(), logging.INFO)

letter_generator.py

@@ -0,0 +1,231 @@
+"""
+Letter generator that combines Groq and Gemini APIs for high-quality letter generation.
+"""
+import asyncio
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+import logging
+
+from groq_client import GroqClient
+from together_client import TogetherClient
+
+logger = logging.getLogger(__name__)
+
+class LetterGenerator:
+    """Groq + Together AIの組み合わせによる高品質な手紙生成クラス"""
+    
+    def __init__(self):
+        """GroqとTogether AIクライアントを初期化"""
+        self.groq_client = GroqClient()
+        self.together_client = TogetherClient()
+        
+    async def generate_letter(self, user_id: str, theme: str, user_history: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        テーマとユーザー履歴を基に完成した手紙を生成
+        
+        Args:
+            user_id: ユーザーID
+            theme: 手紙のテーマ
+            user_history: ユーザーの履歴情報
+            
+        Returns:
+            生成された手紙の情報を含む辞書
+            {
+                'content': '手紙の内容',
+                'metadata': {
+                    'theme': 'テーマ',
+                    'generated_at': '生成日時',
+                    'groq_model': 'モデル名',
+                    'together_model': 'モデル名',
+                    'generation_time': 生成時間（秒）,
+                    'user_id': 'ユーザーID'
+                }
+            }
+            
+        Raises:
+            Exception: 手紙生成に失敗した場合
+        """
+        start_time = datetime.now()
+        
+        try:
+            logger.info(f"ユーザー {user_id} のテーマ '{theme}' で手紙生成開始")
+            
+            # ユーザーコンテキストを構築
+            context = self._build_context(theme, user_history)
+            
+            # ステップ1: Groqで論理構造を生成
+            logger.info("Groqで論理構造を生成中...")
+            structure = await self.groq_client.generate_structure(theme, context)
+            
+            # ステップ2: Together AIで感情表現を補完
+            logger.info("Together AIで感情表現を補完中...")
+            enhanced_context = {**context, 'theme': theme}
+            final_letter = await self.together_client.enhance_emotion(structure, enhanced_context)
+            
+            # 生成時間を計算
+            generation_time = (datetime.now() - start_time).total_seconds()
+            
+            # メタデータを構築
+            metadata = {
+                'theme': theme,
+                'generated_at': datetime.now().isoformat(),
+                'groq_model': self.groq_client.model,
+                'together_model': self.together_client.model,
+                'generation_time': generation_time,
+                'user_id': user_id,
+                'structure_length': len(structure),
+                'final_length': len(final_letter)
+            }
+            
+            logger.info(f"手紙生成完了 (所要時間: {generation_time:.2f}秒)")
+            
+            return {
+                'content': final_letter,
+                'metadata': metadata
+            }
+            
+        except Exception as e:
+            generation_time = (datetime.now() - start_time).total_seconds()
+            logger.error(f"手紙生成失敗 (所要時間: {generation_time:.2f}秒): {str(e)}")
+            raise Exception(f"手紙生成に失敗しました: {str(e)}")
+    
+    def _build_context(self, theme: str, user_history: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        ユーザー履歴を考慮したコンテキストを生成
+        
+        Args:
+            theme: 手紙のテーマ
+            user_history: ユーザーの履歴情報
+            
+        Returns:
+            生成用のコンテキスト辞書
+        """
+        context = {
+            'theme': theme,
+            'user_history': user_history,
+            'previous_letters': [],
+            'interaction_count': 0
+        }
+        
+        # 過去の手紙情報を抽出
+        if 'letters' in user_history:
+            letters = user_history['letters']
+            previous_letters = []
+            
+            for date, letter_data in letters.items():
+                if isinstance(letter_data, dict) and letter_data.get('status') == 'completed':
+                    previous_letters.append({
+                        'date': date,
+                        'theme': letter_data.get('theme', ''),
+                        'content_preview': letter_data.get('content', '')[:100] + '...' if letter_data.get('content') else ''
+                    })
+            
+            # 日付順にソート（新しい順）
+            previous_letters.sort(key=lambda x: x['date'], reverse=True)
+            context['previous_letters'] = previous_letters[:5]  # 最新5通まで
+        
+        # ユーザープロファイ��情報を抽出
+        if 'profile' in user_history:
+            profile = user_history['profile']
+            context['interaction_count'] = profile.get('total_letters', 0)
+        
+        # 季節情報を追加
+        current_month = datetime.now().month
+        if current_month in [12, 1, 2]:
+            context['season'] = '冬'
+        elif current_month in [3, 4, 5]:
+            context['season'] = '春'
+        elif current_month in [6, 7, 8]:
+            context['season'] = '夏'
+        else:
+            context['season'] = '秋'
+        
+        # 時間帯情報を追加
+        current_hour = datetime.now().hour
+        if 5 <= current_hour < 12:
+            context['time_of_day'] = '朝'
+        elif 12 <= current_hour < 17:
+            context['time_of_day'] = '昼'
+        elif 17 <= current_hour < 21:
+            context['time_of_day'] = '夕方'
+        else:
+            context['time_of_day'] = '夜'
+        
+        return context
+    
+    async def test_generation_pipeline(self, test_theme: str = "テスト") -> Dict[str, Any]:
+        """
+        手紙生成パイプラインのテスト
+        
+        Args:
+            test_theme: テスト用のテーマ
+            
+        Returns:
+            テスト結果の辞書
+        """
+        try:
+            # テスト用のユーザー履歴
+            test_user_history = {
+                'profile': {
+                    'created_at': datetime.now().isoformat(),
+                    'total_letters': 0
+                },
+                'letters': {},
+                'requests': {}
+            }
+            
+            # テスト生成を実行
+            result = await self.generate_letter("test_user", test_theme, test_user_history)
+            
+            return {
+                'success': True,
+                'result': result,
+                'message': 'テスト生成成功'
+            }
+            
+        except Exception as e:
+            return {
+                'success': False,
+                'error': str(e),
+                'message': 'テスト生成失敗'
+            }
+    
+    async def check_api_connections(self) -> Dict[str, bool]:
+        """
+        両方のAPIクライアントの接続状態をチェック
+        
+        Returns:
+            各APIの接続状態を示す辞書
+        """
+        try:
+            groq_status = await self.groq_client.test_connection()
+            together_status = await self.together_client.test_connection()
+            
+            return {
+                'groq': groq_status,
+                'together': together_status,
+                'overall': groq_status and together_status
+            }
+            
+        except Exception as e:
+            logger.error(f"API接続チェック失敗: {str(e)}")
+            return {
+                'groq': False,
+                'together': False,
+                'overall': False,
+                'error': str(e)
+            }
+    
+    def get_generation_stats(self) -> Dict[str, Any]:
+        """
+        生成統計情報を取得（将来の拡張用）
+        
+        Returns:
+            統計情報の辞書
+        """
+        return {
+            'groq_model': self.groq_client.model,
+            'together_model': self.together_client.model,
+            'max_retries': max(self.groq_client.max_retries, self.together_client.max_retries),
+            'available': True
+        }

letter_logger.py

@@ -0,0 +1,75 @@
+"""
+ログ設定ユーティリティ
+Logging configuration utility
+"""
+
+import logging
+import sys
+from pathlib import Path
+from typing import Optional
+from letter_config import Config
+
+def setup_logger(
+    name: str,
+    log_file: Optional[str] = None,
+    level: Optional[int] = None
+) -> logging.Logger:
+    """
+    ロガーを設定する
+    
+    Args:
+        name: ロガー名
+        log_file: ログファイルパス（オプション）
+        level: ログレベル（オプション）
+    
+    Returns:
+        設定されたロガー
+    """
+    logger = logging.getLogger(name)
+    
+    # 既存のハンドラーをクリア
+    logger.handlers.clear()
+    
+    # ログレベル設定
+    if level is None:
+        level = Config.get_log_level()
+    logger.setLevel(level)
+    
+    # フォーマッター作成
+    formatter = logging.Formatter(Config.LOG_FORMAT)
+    
+    # コンソールハンドラー
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    # ファイルハンドラー（指定された場合）
+    if log_file:
+        # ログディレクトリを作成
+        log_path = Path(log_file)
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        file_handler = logging.FileHandler(log_file, encoding='utf-8')
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+def get_app_logger() -> logging.Logger:
+    """アプリケーション用のロガーを取得"""
+    return setup_logger("async_letter_app")
+
+def get_batch_logger() -> logging.Logger:
+    """バッチ処理用のロガーを取得"""
+    log_file = "/tmp/batch.log" if not Config.DEBUG_MODE else None
+    return setup_logger("batch_processor", log_file)
+
+def get_api_logger() -> logging.Logger:
+    """API呼び出し用のロガーを取得"""
+    log_file = "/tmp/api.log" if not Config.DEBUG_MODE else None
+    return setup_logger("api_client", log_file)
+
+def get_storage_logger() -> logging.Logger:
+    """ストレージ操作用のロガーを取得"""
+    log_file = "/tmp/storage.log" if not Config.DEBUG_MODE else None
+    return setup_logger("storage", log_file)

letter_manager.py

@@ -0,0 +1,247 @@
+"""
+手紙管理マネージャー
+Letter management manager
+"""
+
+import uuid
+import asyncio
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from letter_models import Letter, LetterRequest, LetterContent, LetterStatus, UserPreferences
+from letter_storage import get_storage
+from letter_logger import get_app_logger
+
+logger = get_app_logger()
+
+class LetterManager:
+    """手紙の生成と管理を行うマネージャークラス"""
+    
+    def __init__(self):
+        self.storage = get_storage()
+        self.logger = logger
+    
+    async def create_letter_request(
+        self, 
+        user_id: str, 
+        message: Optional[str] = None,
+        preferences: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        手紙生成リクエストを作成する
+        
+        Args:
+            user_id: ユーザーID
+            message: ユーザーからのメッセージ
+            preferences: ユーザー設定
+            
+        Returns:
+            作成された手紙のID
+        """
+        try:
+            # 一意のIDを生成
+            letter_id = str(uuid.uuid4())
+            
+            # リクエストオブジェクトを作成
+            request = LetterRequest(
+                user_id=user_id,
+                message=message,
+                preferences=preferences or {}
+            )
+            
+            # 手紙オブジェクトを作成
+            letter = Letter(
+                id=letter_id,
+                request=request,
+                status=LetterStatus.PENDING
+            )
+            
+            # ストレージに保存
+            await self.storage.save_letter(letter.dict())
+            
+            self.logger.info(f"手紙リクエストを作成しました: {letter_id}")
+            return letter_id
+            
+        except Exception as e:
+            self.logger.error(f"手紙リクエストの作成中にエラーが発生しました: {e}")
+            raise
+    
+    async def get_letter(self, letter_id: str) -> Optional[Letter]:
+        """
+        手紙データを取得する
+        
+        Args:
+            letter_id: 手紙のID
+            
+        Returns:
+            手紙データ（見つからない場合はNone）
+        """
+        try:
+            letter_data = await self.storage.get_letter_by_id(letter_id)
+            if letter_data:
+                return Letter(**letter_data)
+            return None
+            
+        except Exception as e:
+            self.logger.error(f"手紙データの取得中にエラーが発生しました: {e}")
+            return None
+    
+    async def get_user_letters(self, user_id: str) -> List[Letter]:
+        """
+        ユーザーの手紙一覧を取得する
+        
+        Args:
+            user_id: ユーザーID
+            
+        Returns:
+            ユーザーの手紙リスト
+        """
+        try:
+            all_letters = await self.storage.load_letters()
+            user_letters = []
+            
+            for letter_data in all_letters:
+                letter = Letter(**letter_data)
+                if letter.request.user_id == user_id:
+                    user_letters.append(letter)
+            
+            # 作成日時でソート（新しい順）
+            user_letters.sort(key=lambda x: x.created_at, reverse=True)
+            
+            return user_letters
+            
+        except Exception as e:
+            self.logger.error(f"ユーザー手紙一覧の取得中にエラーが発生しました: {e}")
+            return []
+    
+    async def update_letter_status(
+        self, 
+        letter_id: str, 
+        status: LetterStatus,
+        error_message: Optional[str] = None
+    ) -> bool:
+        """
+        手紙のステータスを更新する
+        
+        Args:
+            letter_id: 手紙のID
+            status: 新しいステータス
+            error_message: エラーメッセージ（エラー時）
+            
+        Returns:
+            更新が成功したかどうか
+        """
+        try:
+            letter = await self.get_letter(letter_id)
+            if not letter:
+                self.logger.warning(f"更新対象の手紙が見つかりませんでした: {letter_id}")
+                return False
+            
+            letter.update_status(status, error_message)
+            
+            # ストレージを更新
+            await self._update_letter_in_storage(letter)
+            
+            self.logger.info(f"手紙ステータスを更新しました: {letter_id} -> {status}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"手紙ステータスの更新中にエラーが発生しました: {e}")
+            return False
+    
+    async def set_letter_content(
+        self, 
+        letter_id: str, 
+        content: LetterContent
+    ) -> bool:
+        """
+        手��の内容を設定する
+        
+        Args:
+            letter_id: 手紙のID
+            content: 手紙の内容
+            
+        Returns:
+            設定が成功したかどうか
+        """
+        try:
+            letter = await self.get_letter(letter_id)
+            if not letter:
+                self.logger.warning(f"対象の手紙が見つかりませんでした: {letter_id}")
+                return False
+            
+            letter.set_content(content)
+            
+            # ストレージを更新
+            await self._update_letter_in_storage(letter)
+            
+            self.logger.info(f"手紙の内容を設定しました: {letter_id}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"手紙内容の設定中にエラーが発生しました: {e}")
+            return False
+    
+    async def delete_letter(self, letter_id: str) -> bool:
+        """
+        手紙を削除する
+        
+        Args:
+            letter_id: 削除する手紙のID
+            
+        Returns:
+            削除が成功したかどうか
+        """
+        try:
+            result = await self.storage.delete_letter(letter_id)
+            if result:
+                self.logger.info(f"手紙を削除しました: {letter_id}")
+            return result
+            
+        except Exception as e:
+            self.logger.error(f"手紙の削除中にエラーが発生しました: {e}")
+            return False
+    
+    async def get_pending_letters(self) -> List[Letter]:
+        """
+        処理待ちの手紙一覧を取得する
+        
+        Returns:
+            処理待ちの手紙リスト
+        """
+        try:
+            all_letters = await self.storage.load_letters()
+            pending_letters = []
+            
+            for letter_data in all_letters:
+                letter = Letter(**letter_data)
+                if letter.status == LetterStatus.PENDING:
+                    pending_letters.append(letter)
+            
+            # 作成日時でソート（古い順）
+            pending_letters.sort(key=lambda x: x.created_at)
+            
+            return pending_letters
+            
+        except Exception as e:
+            self.logger.error(f"処理待ち手紙一覧の取得中にエラーが発生しました: {e}")
+            return []
+    
+    async def _update_letter_in_storage(self, letter: Letter) -> None:
+        """内部用：ストレージ内の手紙データを更新する"""
+        # 既存データを削除
+        await self.storage.delete_letter(letter.id)
+        
+        # 新しいデータを保存
+        await self.storage.save_letter(letter.dict())
+
+# グローバルマネージャーインスタンス
+manager_instance = None
+
+def get_letter_manager() -> LetterManager:
+    """手紙マネージャーインスタンスを取得（シングルトン）"""
+    global manager_instance
+    
+    if manager_instance is None:
+        manager_instance = LetterManager()
+    
+    return manager_instance

letter_models.py

@@ -0,0 +1,324 @@
+"""
+手紙生成アプリのデータモデル定義
+LetterRequest、GeneratedLetter、UserProfileのデータクラスと
+バリデーション機能を提供します。
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+import re
+import json
+
+
+@dataclass
+class LetterRequest:
+    """手紙リクエストのデータクラス"""
+    user_id: str
+    theme: str
+    requested_at: datetime
+    generation_hour: int  # 2, 3, 4のいずれか
+    status: str = "pending"
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """辞書形式に変換"""
+        return {
+            "user_id": self.user_id,
+            "theme": self.theme,
+            "requested_at": self.requested_at.isoformat(),
+            "generation_hour": self.generation_hour,
+            "status": self.status
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'LetterRequest':
+        """辞書からインスタンスを作成"""
+        return cls(
+            user_id=data["user_id"],
+            theme=data["theme"],
+            requested_at=datetime.fromisoformat(data["requested_at"]),
+            generation_hour=data["generation_hour"],
+            status=data.get("status", "pending")
+        )
+
+
+@dataclass
+class GeneratedLetter:
+    """生成された手紙のデータクラス"""
+    user_id: str
+    theme: str
+    content: str
+    generated_at: datetime
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """辞書形式に変換"""
+        return {
+            "user_id": self.user_id,
+            "theme": self.theme,
+            "content": self.content,
+            "generated_at": self.generated_at.isoformat(),
+            "metadata": self.metadata
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'GeneratedLetter':
+        """辞書からインスタンスを作成"""
+        return cls(
+            user_id=data["user_id"],
+            theme=data["theme"],
+            content=data["content"],
+            generated_at=datetime.fromisoformat(data["generated_at"]),
+            metadata=data.get("metadata", {})
+        )
+
+
+@dataclass
+class UserProfile:
+    """ユーザープロファイルのデータクラス"""
+    user_id: str
+    created_at: datetime
+    last_request: Optional[str] = None
+    total_letters: int = 0
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """辞書形式に変換"""
+        return {
+            "user_id": self.user_id,
+            "created_at": self.created_at.isoformat(),
+            "last_request": self.last_request,
+            "total_letters": self.total_letters
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'UserProfile':
+        """辞書からインスタンスを作成"""
+        return cls(
+            user_id=data["user_id"],
+            created_at=datetime.fromisoformat(data["created_at"]),
+            last_request=data.get("last_request"),
+            total_letters=data.get("total_letters", 0)
+        )
+
+
+class ValidationError(Exception):
+    """バリデーションエラー"""
+    pass
+
+
+class ThemeValidator:
+    """テーマのバリデーション機能"""
+    
+    MIN_LENGTH = 1
+    MAX_LENGTH = 100
+    
+    # 禁止されている文字パターン
+    FORBIDDEN_PATTERNS = [
+        r'<[^>]*>',  # HTMLタグ
+        r'javascript:',  # JavaScript
+        r'data:',  # データURL
+    ]
+    
+    @classmethod
+    def validate(cls, theme: str) -> bool:
+        """テーマの妥当性を検証"""
+        if not theme or not isinstance(theme, str):
+            raise ValidationError("テーマは文字列である必要があります")
+        
+        # 長さチェック
+        theme = theme.strip()
+        if len(theme) < cls.MIN_LENGTH:
+            raise ValidationError("テーマは1文字以上入力してください")
+        
+        if len(theme) > cls.MAX_LENGTH:
+            raise ValidationError(f"テーマは{cls.MAX_LENGTH}文字以内で入力してください")
+        
+        # 禁止パターンチェック
+        for pattern in cls.FORBIDDEN_PATTERNS:
+            if re.search(pattern, theme, re.IGNORECASE):
+                raise ValidationError("不正な文字が含まれています")
+        
+        return True
+    
+    @classmethod
+    def sanitize(cls, theme: str) -> str:
+        """テーマをサニタイズ"""
+        if not theme:
+            return ""
+        
+        # 前後の空白を削除
+        theme = theme.strip()
+        
+        # 改行文字を空白に変換
+        theme = re.sub(r'\s+', ' ', theme)
+        
+        return theme
+
+
+class GenerationTimeValidator:
+    """生成時刻のバリデーション機能"""
+    
+    VALID_HOURS = [2, 3, 4]  # 2時、3時、4時のみ有効
+    
+    @classmethod
+    def validate(cls, hour: int) -> bool:
+        """生成時刻の妥当性を検証"""
+        if not isinstance(hour, int):
+            raise ValidationError("生成時刻は整数である必要があります")
+        
+        if hour not in cls.VALID_HOURS:
+            valid_hours_str = "、".join(map(str, cls.VALID_HOURS))
+            raise ValidationError(f"生成時刻は{valid_hours_str}時のいずれかを選択してください")
+        
+        return True
+
+
+class DataValidator:
+    """データ全般のバリデーション機能"""
+    
+    @staticmethod
+    def validate_user_id(user_id: str) -> bool:
+        """ユーザーIDの妥当性を検証"""
+        if not user_id or not isinstance(user_id, str):
+            raise ValidationError("ユーザーIDは文字列である必要があります")
+        
+        # UUIDv4形式のチェック（簡易版）
+        uuid_pattern = r'^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$'
+        if not re.match(uuid_pattern, user_id, re.IGNORECASE):
+            raise ValidationError("ユーザーIDの形式が正しくありません")
+        
+        return True
+    
+    @staticmethod
+    def validate_letter_request(request: LetterRequest) -> bool:
+        """手紙リクエストの妥当性を検証"""
+        DataValidator.validate_user_id(request.user_id)
+        ThemeValidator.validate(request.theme)
+        GenerationTimeValidator.validate(request.generation_hour)
+        
+        # ステータスの検証
+        valid_statuses = ["pending", "processing", "completed", "failed"]
+        if request.status not in valid_statuses:
+            raise ValidationError(f"ステータスは{valid_statuses}のいずれかである必要があります")
+        
+        return True
+    
+    @staticmethod
+    def validate_generated_letter(letter: GeneratedLetter) -> bool:
+        """生成された手紙の妥当性を検証"""
+        DataValidator.validate_user_id(letter.user_id)
+        ThemeValidator.validate(letter.theme)
+        
+        # 手紙内容の検証
+        if not letter.content or not isinstance(letter.content, str):
+            raise ValidationError("手紙の内容は文字列である必要があります")
+        
+        if len(letter.content.strip()) < 10:
+            raise ValidationError("手紙の内容が短すぎます")
+        
+        return True
+    
+    @staticmethod
+    def validate_user_profile(profile: UserProfile) -> bool:
+        """ユーザープロファイルの妥当性を検証"""
+        DataValidator.validate_user_id(profile.user_id)
+        
+        # 手紙数の検証
+        if not isinstance(profile.total_letters, int) or profile.total_letters < 0:
+            raise ValidationError("手紙数は0以上の整数である必要があります")
+        
+        return True
+
+
+# テスト用のサンプルデータ作成関数
+def create_sample_data():
+    """テスト用のサンプルデータを作成"""
+    import uuid
+    
+    user_id = str(uuid.uuid4())
+    now = datetime.now()
+    
+    # サンプルリクエスト
+    request = LetterRequest(
+        user_id=user_id,
+        theme="春の思い出",
+        requested_at=now,
+        generation_hour=2
+    )
+    
+    # サンプル手紙
+    letter = GeneratedLetter(
+        user_id=user_id,
+        theme="春の思い出",
+        content="桜の花びらが舞い散る季節になりました。あなたとの思い出が蘇ります...",
+        generated_at=now,
+        metadata={
+            "groq_model": "compound-beta",
+            "Together_model": "Qwen/Qwen3-235B-A22B-Instruct-2507-tput",
+            "generation_time": 12.5
+        }
+    )
+    
+    # サンプルプロファイル
+    profile = UserProfile(
+        user_id=user_id,
+        created_at=now,
+        last_request="2024-01-20",
+        total_letters=1
+    )
+    
+    return request, letter, profile
+
+
+if __name__ == "__main__":
+    # テスト実行
+    try:
+        request, letter, profile = create_sample_data()
+        
+        print("=== バリデーションテスト ===")
+        
+        # リクエストのバリデーション
+        DataValidator.validate_letter_request(request)
+        print("✓ LetterRequestのバリデーション成功")
+        
+        # 手紙のバリデーション
+        DataValidator.validate_generated_letter(letter)
+        print("✓ GeneratedLetterのバリデーション成功")
+        
+        # プロファイルのバリデーション
+        DataValidator.validate_user_profile(profile)
+        print("✓ UserProfileのバリデーション成功")
+        
+        print("\n=== シリアライゼーションテスト ===")
+        
+        # 辞書変換テスト
+        request_dict = request.to_dict()
+        request_restored = LetterRequest.from_dict(request_dict)
+        print("✓ LetterRequestのシリアライゼーション成功")
+        
+        letter_dict = letter.to_dict()
+        letter_restored = GeneratedLetter.from_dict(letter_dict)
+        print("✓ GeneratedLetterのシリアライゼーション成功")
+        
+        profile_dict = profile.to_dict()
+        profile_restored = UserProfile.from_dict(profile_dict)
+        print("✓ UserProfileのシリアライゼーション成功")
+        
+        print("\n=== エラーケーステスト ===")
+        
+        # 不正なテーマのテスト
+        try:
+            ThemeValidator.validate("")
+        except ValidationError as e:
+            print(f"✓ 空のテーマエラー: {e}")
+        
+        # 不正な生成時刻のテスト
+        try:
+            GenerationTimeValidator.validate(5)
+        except ValidationError as e:
+            print(f"✓ 不正な生成時刻エラー: {e}")
+        
+        print("\n全てのテストが完了しました！")
+        
+    except Exception as e:
+        print(f"エラーが発生しました: {e}")

letter_request_manager.py

@@ -0,0 +1,462 @@
+"""
+リクエスト管理クラス
+テーマと生成時刻を含むリクエスト送信機能と
+時刻別の未処理リクエスト取得機能を提供します。
+"""
+
+import asyncio
+import os
+from datetime import datetime, timedelta
+from typing import Dict, Any, List, Optional, Tuple
+import logging
+import uuid
+
+# ログ設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class RequestError(Exception):
+    """リクエスト関連のエラー"""
+    pass
+
+
+class RequestManager:
+    """リクエスト管理クラス"""
+    
+    def __init__(self, storage_manager, rate_limiter):
+        self.storage = storage_manager
+        self.rate_limiter = rate_limiter
+        
+        # 設定値
+        self.valid_generation_hours = [2, 3, 4]  # 2時、3時、4時
+        self.max_theme_length = int(os.getenv("MAX_THEME_LENGTH", "200"))
+        self.min_theme_length = int(os.getenv("MIN_THEME_LENGTH", "1"))
+        
+        logger.info(f"RequestManager初期化完了 - 有効な生成時刻: {self.valid_generation_hours}")
+    
+    async def submit_request(self, user_id: str, theme: str, generation_hour: int, affection: int = None) -> Tuple[bool, str]:
+        """
+        リクエストを送信する
+        
+        Args:
+            user_id: ユーザーID
+            theme: 手紙のテーマ
+            generation_hour: 生成時刻（2, 3, 4のいずれか）
+            affection: 現在の好感度（オプション）
+            
+        Returns:
+            Tuple[bool, str]: (成功フラグ, メッセージ)
+        """
+        try:
+            # 入力バリデーション
+            if not self.validate_theme(theme):
+                return False, f"テーマは{self.min_theme_length}文字以上{self.max_theme_length}文字以下で入力してください"
+            
+            if not self.validate_generation_hour(generation_hour):
+                return False, f"生成時刻は{self.valid_generation_hours}のいずれかを選択してください"
+            
+            # レート制限チェック
+            allowed, limit_message = await self.rate_limiter.is_request_allowed(user_id)
+            if not allowed:
+                return False, limit_message
+            
+            # 既存のリクエストチェック（同日の重複防止）
+            today = datetime.now().strftime("%Y-%m-%d")
+            existing_request = await self._get_user_request_for_date(user_id, today)
+            
+            if existing_request:
+                return False, "本日は既にリクエストを送信済みです。1日1回までリクエスト可能です。"
+            
+            # リクエストデータの作成
+            request_data = {
+                "theme": theme.strip(),
+                "status": "pending",
+                "requested_at": datetime.now().isoformat(),
+                "generation_hour": generation_hour,
+                "request_id": str(uuid.uuid4()),
+                "affection": affection  # 好感度情報を追加
+            }
+            
+            # ユーザーデータの取得と更新
+            user_data = await self.storage.get_user_data(user_id)
+            user_data["requests"][today] = request_data
+            
+            # ストレージに保存
+            await self.storage.update_user_data(user_id, user_data)
+            
+            # レート制限の記録
+            await self.rate_limiter.record_request(user_id)
+            
+            logger.info(f"リクエスト送信成功 - ユーザー: {user_id}, テーマ: {theme[:50]}..., 生成時刻: {generation_hour}時")
+            
+            return True, f"リクエストを受け付けました。{generation_hour}時頃に手紙を生成します。"
+            
+        except Exception as e:
+            logger.error(f"リクエスト送信エラー: {e}")
+            return False, f"リクエストの送信中にエラーが発生しました: {str(e)}"
+    
+    async def get_pending_requests_by_hour(self, hour: int) -> List[Dict[str, Any]]:
+        """
+        指定時刻の未処理リクエストを取得する
+        
+        Args:
+            hour: 生成時刻（2, 3, 4のいずれか）
+            
+        Returns:
+            List[Dict]: 未処理リクエストのリスト
+        """
+        try:
+            if hour not in self.valid_generation_hours:
+                logger.warning(f"無効な生成時刻が指定されました: {hour}")
+                return []
+            
+            all_users = await self.storage.get_all_users()
+            pending_requests = []
+            today = datetime.now().strftime("%Y-%m-%d")
+            
+            for user_id in all_users:
+                user_data = await self.storage.get_user_data(user_id)
+                
+                # 今日のリクエストをチェック
+                if today in user_data["requests"]:
+                    request = user_data["requests"][today]
+                    
+                    # 指定時刻かつ未処理のリクエストを抽出
+                    if (request.get("generation_hour") == hour and 
+                        request.get("status") == "pending"):
+                        
+                        pending_requests.append({
+                            "user_id": user_id,
+                            "theme": request["theme"],
+                            "requested_at": request["requested_at"],
+                            "generation_hour": request["generation_hour"],
+                            "request_id": request.get("request_id", ""),
+                            "date": today
+                        })
+            
+            logger.info(f"{hour}時の未処理リクエスト数: {len(pending_requests)}")
+            return pending_requests
+            
+        except Exception as e:
+            logger.error(f"未処理リクエスト取得エラー: {e}")
+            return []
+    
+    async def mark_request_processed(self, user_id: str, date: str, status: str = "completed") -> bool:
+        """
+        リクエストを処理済みにマークする
+        
+        Args:
+            user_id: ユーザーID
+            date: 日付（YYYY-MM-DD形式）
+            status: 新しいステータス（completed, failed等）
+            
+        Returns:
+            bool: 成功フラグ
+        """
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            
+            if date not in user_data["requests"]:
+                logger.warning(f"指定された日付のリクエストが見つかりません - ユーザー: {user_id}, 日付: {date}")
+                return False
+            
+            # ステータスを更新
+            user_data["requests"][date]["status"] = status
+            user_data["requests"][date]["processed_at"] = datetime.now().isoformat()
+            
+            await self.storage.update_user_data(user_id, user_data)
+            
+            logger.info(f"リクエストを{status}にマークしました - ユーザー: {user_id}, 日付: {date}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"リクエスト処理マークエラー: {e}")
+            return False
+    
+    async def mark_request_failed(self, user_id: str, date: str, error_message: str) -> bool:
+        """
+        リクエストを失敗にマークする
+        
+        Args:
+            user_id: ユーザーID
+            date: 日付（YYYY-MM-DD形式）
+            error_message: エラーメッセージ
+            
+        Returns:
+            bool: 成功フラグ
+        """
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            
+            if date not in user_data["requests"]:
+                logger.warning(f"指定された日付のリクエストが見つかりません - ユーザー: {user_id}, 日付: {date}")
+                return False
+            
+            # ステータスとエラー情報を更新
+            user_data["requests"][date]["status"] = "failed"
+            user_data["requests"][date]["processed_at"] = datetime.now().isoformat()
+            user_data["requests"][date]["error_message"] = error_message
+            
+            await self.storage.update_user_data(user_id, user_data)
+            
+            logger.error(f"リクエストを失敗にマークしました - ユーザー: {user_id}, 日付: {date}, エラー: {error_message}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"リクエスト失敗マークエラー: {e}")
+            return False
+    
+    def validate_theme(self, theme: str) -> bool:
+        """
+        テーマのバリデーション
+        
+        Args:
+            theme: テーマ文字列
+            
+        Returns:
+            bool: バリデーション結果
+        """
+        if not theme or not isinstance(theme, str):
+            return False
+        
+        theme = theme.strip()
+        
+        # 長さチェック
+        if len(theme) < self.min_theme_length or len(theme) > self.max_theme_length:
+            return False
+        
+        # 不正な文字のチェック（基本的な制御文字のみ）
+        if any(ord(char) < 32 and char not in ['\n', '\r', '\t'] for char in theme):
+            return False
+        
+        return True
+    
+    def validate_generation_hour(self, hour: int) -> bool:
+        """
+        生成時刻のバリデーション
+        
+        Args:
+            hour: 生成時刻
+            
+        Returns:
+            bool: バリデーション結果
+        """
+        return isinstance(hour, int) and hour in self.valid_generation_hours
+    
+    async def get_user_request_status(self, user_id: str, date: Optional[str] = None) -> Dict[str, Any]:
+        """
+        ユーザーのリクエスト状況を取得する
+        
+        Args:
+            user_id: ユーザーID
+            date: 日付（指定しない場合は今日）
+            
+        Returns:
+            Dict: リクエスト状況
+        """
+        try:
+            if date is None:
+                date = datetime.now().strftime("%Y-%m-%d")
+            
+            user_data = await self.storage.get_user_data(user_id)
+            
+            if date not in user_data["requests"]:
+                return {
+                    "has_request": False,
+                    "date": date,
+                    "can_request": True
+                }
+            
+            request = user_data["requests"][date]
+            
+            return {
+                "has_request": True,
+                "date": date,
+                "theme": request["theme"],
+                "status": request["status"],
+                "generation_hour": request["generation_hour"],
+                "requested_at": request["requested_at"],
+                "processed_at": request.get("processed_at"),
+                "error_message": request.get("error_message"),
+                "can_request": False  # 既にリクエスト済み
+            }
+            
+        except Exception as e:
+            logger.error(f"リクエスト状況取得エラー: {e}")
+            return {"error": str(e)}
+    
+    async def _get_user_request_for_date(self, user_id: str, date: str) -> Optional[Dict[str, Any]]:
+        """
+        指定日のユーザーリクエストを取得する（内部使用）
+        
+        Args:
+            user_id: ユーザーID
+            date: 日付（YYYY-MM-DD形式）
+            
+        Returns:
+            Optional[Dict]: リクエストデータ（存在しない場合はNone）
+        """
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            return user_data["requests"].get(date)
+        except Exception as e:
+            logger.error(f"ユーザーリクエスト取得エラー: {e}")
+            return None
+    
+    async def get_all_pending_requests(self) -> Dict[int, List[Dict[str, Any]]]:
+        """
+        全ての未処理リクエストを時刻別に取得する
+        
+        Returns:
+            Dict[int, List]: 時刻別の未処理リクエスト
+        """
+        try:
+            all_pending = {}
+            
+            for hour in self.valid_generation_hours:
+                pending_requests = await self.get_pending_requests_by_hour(hour)
+                all_pending[hour] = pending_requests
+            
+            return all_pending
+            
+        except Exception as e:
+            logger.error(f"全未処理リクエスト取得エラー: {e}")
+            return {}
+    
+    async def cleanup_old_requests(self, days: int = 30) -> int:
+        """
+        古いリクエストデータを削除する
+        
+        Args:
+            days: 保持日数
+            
+        Returns:
+            int: 削除されたリクエスト数
+        """
+        try:
+            cutoff_date = datetime.now() - timedelta(days=days)
+            cutoff_str = cutoff_date.strftime("%Y-%m-%d")
+            
+            all_users = await self.storage.get_all_users()
+            deleted_count = 0
+            
+            for user_id in all_users:
+                user_data = await self.storage.get_user_data(user_id)
+                
+                # 古いリクエストを削除
+                requests_to_delete = []
+                for date_str in user_data["requests"]:
+                    if date_str < cutoff_str:
+                        requests_to_delete.append(date_str)
+                
+                for date_str in requests_to_delete:
+                    del user_data["requests"][date_str]
+                    deleted_count += 1
+                
+                if requests_to_delete:
+                    await self.storage.update_user_data(user_id, user_data)
+            
+            if deleted_count > 0:
+                logger.info(f"{deleted_count}件の古いリクエストを削除しました")
+            
+            return deleted_count
+            
+        except Exception as e:
+            logger.error(f"古いリクエスト削除エラー: {e}")
+            return 0
+    
+    async def get_request_statistics(self) -> Dict[str, Any]:
+        """
+        リクエストの統計情報を取得する
+        
+        Returns:
+            Dict: 統計情報
+        """
+        try:
+            all_users = await self.storage.get_all_users()
+            today = datetime.now().strftime("%Y-%m-%d")
+            
+            stats = {
+                "total_users": len(all_users),
+                "today_requests": 0,
+                "pending_requests": 0,
+                "completed_requests": 0,
+                "failed_requests": 0,
+                "requests_by_hour": {hour: 0 for hour in self.valid_generation_hours},
+                "date": today
+            }
+            
+            for user_id in all_users:
+                user_data = await self.storage.get_user_data(user_id)
+                
+                # 今日のリクエストをカウント
+                if today in user_data["requests"]:
+                    request = user_data["requests"][today]
+                    stats["today_requests"] += 1
+                    
+                    # ステータス別カウント
+                    status = request.get("status", "unknown")
+                    if status == "pending":
+                        stats["pending_requests"] += 1
+                    elif status == "completed":
+                        stats["completed_requests"] += 1
+                    elif status == "failed":
+                        stats["failed_requests"] += 1
+                    
+                    # 時刻別カウント
+                    hour = request.get("generation_hour")
+                    if hour in stats["requests_by_hour"]:
+                        stats["requests_by_hour"][hour] += 1
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"統計情報取得エラー: {e}")
+            return {"error": str(e)}
+
+
+# テスト用の関数
+async def test_request_manager():
+    """RequestManagerのテスト"""
+    import tempfile
+    from async_storage_manager import AsyncStorageManager
+    from async_rate_limiter import AsyncRateLimitManager
+    
+    # 一時ディレクトリでテスト
+    with tempfile.TemporaryDirectory() as temp_dir:
+        test_file = os.path.join(temp_dir, "test_letters.json")
+        storage = AsyncStorageManager(test_file)
+        rate_limiter = AsyncRateLimitManager(storage)
+        request_manager = RequestManager(storage, rate_limiter)
+        
+        print("=== RequestManagerテスト開始 ===")
+        
+        user_id = str(uuid.uuid4())
+        
+        # リクエスト送信テスト
+        success, message = await request_manager.submit_request(user_id, "春の思い出", 2)
+        print(f"✓ リクエスト送信テスト: {success} - {message}")
+        
+        # 未処理リクエスト取得テスト
+        pending = await request_manager.get_pending_requests_by_hour(2)
+        print(f"✓ 未処理リクエスト取得テスト: {len(pending)}件")
+        
+        # リクエスト状況確認テスト
+        status = await request_manager.get_user_request_status(user_id)
+        print(f"✓ リクエスト状況確認テスト: {status}")
+        
+        # リクエスト処理マークテスト
+        today = datetime.now().strftime("%Y-%m-%d")
+        marked = await request_manager.mark_request_processed(user_id, today)
+        print(f"✓ リクエスト処理マークテスト: {marked}")
+        
+        # 統計情報取得テスト
+        stats = await request_manager.get_request_statistics()
+        print(f"✓ 統計情報取得テスト: {stats}")
+        
+        print("=== 全てのテストが完了しました！ ===")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_request_manager())

letter_storage.py

@@ -0,0 +1,190 @@
+"""
+ストレージ管理モジュール
+Storage management module
+"""
+
+import json
+import asyncio
+import aiofiles
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+from letter_config import Config
+from letter_logger import get_storage_logger
+
+logger = get_storage_logger()
+
+class LetterStorage:
+    """手紙データのストレージ管理クラス"""
+    
+    def __init__(self):
+        self.config = Config()
+        self.storage_path = Path(self.config.STORAGE_PATH)
+        self.backup_path = Path(self.config.BACKUP_PATH)
+        self.logger = logger
+    
+    async def save_letter(self, letter_data: Dict[str, Any]) -> bool:
+        """
+        手紙データを保存する
+        
+        Args:
+            letter_data: 保存する手紙データ
+            
+        Returns:
+            保存が成功したかどうか
+        """
+        try:
+            # タイムスタンプを追加
+            letter_data['saved_at'] = datetime.now().isoformat()
+            
+            # 既存データを読み込み
+            existing_data = await self._load_data()
+            
+            # 新しいデータを追加
+            if 'letters' not in existing_data:
+                existing_data['letters'] = []
+            
+            existing_data['letters'].append(letter_data)
+            
+            # データを保存
+            await self._save_data(existing_data)
+            
+            self.logger.info(f"手紙データを保存しました: {letter_data.get('id', 'unknown')}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"手紙データの保存中にエラーが発生しました: {e}")
+            return False
+    
+    async def load_letters(self) -> List[Dict[str, Any]]:
+        """
+        保存された手紙データを読み込む
+        
+        Returns:
+            手紙データのリスト
+        """
+        try:
+            data = await self._load_data()
+            return data.get('letters', [])
+            
+        except Exception as e:
+            self.logger.error(f"手紙データの読み込み中にエラーが発生しました: {e}")
+            return []
+    
+    async def get_letter_by_id(self, letter_id: str) -> Optional[Dict[str, Any]]:
+        """
+        IDで手紙データを取得する
+        
+        Args:
+            letter_id: 手紙のID
+            
+        Returns:
+            手紙データ（見つからない場合はNone）
+        """
+        try:
+            letters = await self.load_letters()
+            for letter in letters:
+                if letter.get('id') == letter_id:
+                    return letter
+            return None
+            
+        except Exception as e:
+            self.logger.error(f"手紙データの取得中にエラーが発生しました: {e}")
+            return None
+    
+    async def delete_letter(self, letter_id: str) -> bool:
+        """
+        手紙データを削除する
+        
+        Args:
+            letter_id: 削除する手紙のID
+            
+        Returns:
+            削除が成功したかどうか
+        """
+        try:
+            data = await self._load_data()
+            letters = data.get('letters', [])
+            
+            # 指定されたIDの手紙を削除
+            original_count = len(letters)
+            letters = [letter for letter in letters if letter.get('id') != letter_id]
+            
+            if len(letters) < original_count:
+                data['letters'] = letters
+                await self._save_data(data)
+                self.logger.info(f"手紙データを削除しました: {letter_id}")
+                return True
+            else:
+                self.logger.warning(f"削除対象の手紙が見つかりませんでした: {letter_id}")
+                return False
+                
+        except Exception as e:
+            self.logger.error(f"手紙データの削除中にエラーが発生しました: {e}")
+            return False
+    
+    async def backup_data(self) -> bool:
+        """
+        データをバックアップする
+        
+        Returns:
+            バックアップが成功したかどうか
+        """
+        try:
+            if not self.storage_path.exists():
+                self.logger.warning("バックアップ対象のファイルが存在しません")
+                return False
+            
+            # バックアップディレクトリを作成
+            self.backup_path.mkdir(parents=True, exist_ok=True)
+            
+            # タイムスタンプ付きのバックアップファイル名
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_file = self.backup_path / f"letters_backup_{timestamp}.json"
+            
+            # ファイルをコピー
+            async with aiofiles.open(self.storage_path, 'r', encoding='utf-8') as src:
+                content = await src.read()
+                async with aiofiles.open(backup_file, 'w', encoding='utf-8') as dst:
+                    await dst.write(content)
+            
+            self.logger.info(f"データをバックアップしました: {backup_file}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"データのバックアップ中にエラーが発生しました: {e}")
+            return False
+    
+    async def _load_data(self) -> Dict[str, Any]:
+        """内部用：データファイルを読み込む"""
+        try:
+            if not self.storage_path.exists():
+                return {}
+            
+            async with aiofiles.open(self.storage_path, 'r', encoding='utf-8') as f:
+                content = await f.read()
+                return json.loads(content) if content.strip() else {}
+                
+        except Exception as e:
+            self.logger.error(f"データファイルの読み込み中にエラーが発生しました: {e}")
+            return {}
+    
+    async def _save_data(self, data: Dict[str, Any]) -> None:
+        """内部用：データファイルに保存する"""
+        # ディレクトリを作成
+        self.storage_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        async with aiofiles.open(self.storage_path, 'w', encoding='utf-8') as f:
+            await f.write(json.dumps(data, ensure_ascii=False, indent=2))
+
+# グローバルストレージインスタンス
+storage_instance = None
+
+def get_storage() -> LetterStorage:
+    """ストレージインスタンスを取得（シングルトン）"""
+    global storage_instance
+    
+    if storage_instance is None:
+        storage_instance = LetterStorage()
+    
+    return storage_instance

letter_user_manager.py

@@ -0,0 +1,666 @@
+"""
+ユーザー管理クラス
+ユーザープロファイル管理機能と
+ユーザー履歴の更新・取得機能を提供します。
+"""
+
+import asyncio
+import os
+from datetime import datetime, timedelta
+from typing import Dict, Any, List, Optional, Tuple
+import logging
+import uuid
+import hashlib
+import secrets
+
+# ログ設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class UserError(Exception):
+    """ユーザー関連のエラー"""
+    pass
+
+
+class UserManager:
+    """ユーザー管理クラス"""
+    
+    def __init__(self, storage_manager):
+        self.storage = storage_manager
+        
+        # 設定値
+        self.session_timeout_hours = int(os.getenv("SESSION_TIMEOUT_HOURS", "24"))
+        self.max_history_entries = int(os.getenv("MAX_HISTORY_ENTRIES", "100"))
+        self.user_data_retention_days = int(os.getenv("USER_DATA_RETENTION_DAYS", "90"))
+        
+        logger.info(f"UserManager初期化完了 - セッションタイムアウト: {self.session_timeout_hours}時間")
+    
+    def generate_user_id(self) -> str:
+        """
+        新しいユーザーIDを生成する
+        
+        Returns:
+            str: 生成されたユーザーID（UUID4形式）
+        """
+        return str(uuid.uuid4())
+    
+    def generate_session_id(self) -> str:
+        """
+        新しいセッションIDを生成する
+        
+        Returns:
+            str: 生成されたセッションID
+        """
+        return secrets.token_urlsafe(32)
+    
+    async def get_user_profile(self, user_id: str) -> Dict[str, Any]:
+        """
+        ユーザープロファイルを取得する
+        
+        Args:
+            user_id: ユーザーID
+            
+        Returns:
+            Dict: ユーザープロファイル
+        """
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            profile = user_data["profile"].copy()
+            
+            # 追加の統計情報を計算
+            profile["total_requests"] = len(user_data["requests"])
+            profile["completed_letters"] = len([
+                letter for letter in user_data["letters"].values()
+                if letter.get("status") == "completed"
+            ])
+            profile["pending_requests"] = len([
+                request for request in user_data["requests"].values()
+                if request.get("status") == "pending"
+            ])
+            
+            # 最後のアクティビティ時刻を計算
+            last_activity = self._calculate_last_activity(user_data)
+            if last_activity:
+                profile["last_activity"] = last_activity
+            
+            return profile
+            
+        except Exception as e:
+            logger.error(f"ユーザープロファイル取得エラー: {e}")
+            raise UserError(f"ユーザープロファイルの取得に失敗しました: {e}")
+    
+    async def update_user_profile(self, user_id: str, profile_updates: Dict[str, Any]) -> bool:
+        """
+        ユーザープロファイルを更新する
+        
+        Args:
+            user_id: ユーザーID
+            profile_updates: 更新するプロファイル情報
+            
+        Returns:
+            bool: 更新成功フラグ
+        """
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            
+            # 更新可能なフィールドのみを許可
+            allowed_fields = {
+                "display_name", "preferences", "timezone", "language",
+                "notification_settings", "theme_preferences"
+            }
+            
+            for key, value in profile_updates.items():
+                if key in allowed_fields:
+                    user_data["profile"][key] = value
+            
+            # 更新時刻を記録
+            user_data["profile"]["updated_at"] = datetime.now().isoformat()
+            
+            await self.storage.update_user_data(user_id, user_data)
+            
+            logger.info(f"ユーザープロファイルを更新しました: {user_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"ユーザープロファイル更新エラー: {e}")
+            return False
+    
+    async def update_user_history(self, user_id: str, interaction: Dict[str, Any]) -> bool:
+        """
+        ユーザー履歴を更新する
+        
+        Args:
+            user_id: ユーザーID
+            interaction: インタラクション情報
+            
+        Returns:
+            bool: 更新成功フラグ
+        """
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            
+            # 履歴エントリの作成
+            history_entry = {
+                "timestamp": datetime.now().isoformat(),
+                "type": interaction.get("type", "unknown"),
+                "action": interaction.get("action", ""),
+                "details": interaction.get("details", {}),
+                "session_id": interaction.get("session_id", ""),
+                "entry_id": str(uuid.uuid4())
+            }
+            
+            # 履歴配列の初期化（存在しない場合）
+            if "history" not in user_data:
+                user_data["history"] = []
+            
+            # 履歴エントリを追加
+            user_data["history"].append(history_entry)
+            
+            # 履歴の上限チェックと古いエントリの削除
+            if len(user_data["history"]) > self.max_history_entries:
+                # 古いエントリから削除
+                user_data["history"] = user_data["history"][-self.max_history_entries:]
+            
+            # プロファイルの統計情報を更新
+            await self._update_profile_stats(user_data, interaction)
+            
+            await self.storage.update_user_data(user_id, user_data)
+            
+            logger.info(f"ユーザー履歴を更新しました: {user_id} - {interaction.get('type', 'unknown')}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"ユーザー履歴更新エラー: {e}")
+            return False
+    
+    async def get_user_letter_history(self, user_id: str, limit: Optional[int] = None) -> List[Dict[str, Any]]:
+        """
+        ユーザーの手紙履歴を取得する
+        
+        Args:
+            user_id: ユーザーID
+            limit: 取得件数の上限
+            
+        Returns:
+            List[Dict]: 手紙履歴のリスト
+        """
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            letters = user_data["letters"]
+            
+            # 手紙データを日付順（新しい順）でソート
+            sorted_letters = []
+            for date, letter_data in letters.items():
+                letter_info = {
+                    "date": date,
+                    "theme": letter_data.get("theme", ""),
+                    "status": letter_data.get("status", "unknown"),
+                    "generated_at": letter_data.get("generated_at"),
+                    "content_length": len(letter_data.get("content", "")),
+                    "metadata": letter_data.get("metadata", {})
+                }
+                sorted_letters.append(letter_info)
+            
+            # 日付順でソート（新しい順）
+            sorted_letters.sort(key=lambda x: x["date"], reverse=True)
+            
+            # 上限が指定されている場合は制限
+            if limit:
+                sorted_letters = sorted_letters[:limit]
+            
+            return sorted_letters
+            
+        except Exception as e:
+            logger.error(f"手紙履歴取得エラー: {e}")
+            return []
+    
+    async def get_user_interaction_history(self, user_id: str, 
+                                         interaction_type: Optional[str] = None,
+                                         limit: Optional[int] = None) -> List[Dict[str, Any]]:
+        """
+        ユーザーのインタラクション履歴を取得する
+        
+        Args:
+            user_id: ユーザーID
+            interaction_type: フィルタするインタラクションタイプ
+            limit: 取得件数の上限
+            
+        Returns:
+            List[Dict]: インタラクション履歴のリスト
+        """
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            history = user_data.get("history", [])
+            
+            # タイプでフィルタ
+            if interaction_type:
+                history = [entry for entry in history if entry.get("type") == interaction_type]
+            
+            # 時刻順でソート（新しい順）
+            history.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+            
+            # 上限が指定されている場合は制限
+            if limit:
+                history = history[:limit]
+            
+            return history
+            
+        except Exception as e:
+            logger.error(f"インタラクション履歴取得エラー: {e}")
+            return []
+    
+    async def create_user_session(self, user_id: str, session_info: Dict[str, Any]) -> str:
+        """
+        ユーザーセッションを作成する
+        
+        Args:
+            user_id: ユーザーID
+            session_info: セッション情報
+            
+        Returns:
+            str: セッションID
+        """
+        try:
+            session_id = self.generate_session_id()
+            user_data = await self.storage.get_user_data(user_id)
+            
+            # セッション情報の作成
+            session_data = {
+                "session_id": session_id,
+                "created_at": datetime.now().isoformat(),
+                "expires_at": (datetime.now() + timedelta(hours=self.session_timeout_hours)).isoformat(),
+                "ip_address": session_info.get("ip_address", ""),
+                "user_agent": session_info.get("user_agent", ""),
+                "is_active": True
+            }
+            
+            # セッション配列の初期化（存在しない場合）
+            if "sessions" not in user_data:
+                user_data["sessions"] = []
+            
+            # 古いセッションを無効化
+            await self._cleanup_expired_sessions(user_data)
+            
+            # 新しいセッションを追加
+            user_data["sessions"].append(session_data)
+            
+            await self.storage.update_user_data(user_id, user_data)
+            
+            logger.info(f"ユーザーセッションを作成しました: {user_id} - {session_id}")
+            return session_id
+            
+        except Exception as e:
+            logger.error(f"セッション作成エラー: {e}")
+            raise UserError(f"セッションの作成に失敗しました: {e}")
+    
+    async def validate_user_session(self, user_id: str, session_id: str) -> bool:
+        """
+        ユーザーセッションを検証する
+        
+        Args:
+            user_id: ユーザーID
+            session_id: セッションID
+            
+        Returns:
+            bool: セッション有効フラグ
+        """
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            sessions = user_data.get("sessions", [])
+            
+            for session in sessions:
+                if (session.get("session_id") == session_id and 
+                    session.get("is_active", False)):
+                    
+                    # 有効期限チェック
+                    expires_at = datetime.fromisoformat(session["expires_at"])
+                    if datetime.now() < expires_at:
+                        return True
+                    else:
+                        # 期限切れセッションを無効化
+                        session["is_active"] = False
+                        await self.storage.update_user_data(user_id, user_data)
+            
+            return False
+            
+        except Exception as e:
+            logger.error(f"セッション検証エラー: {e}")
+            return False
+    
+    async def invalidate_user_session(self, user_id: str, session_id: str) -> bool:
+        """
+        ユーザーセッションを無効化する
+        
+        Args:
+            user_id: ユーザーID
+            session_id: セッションID
+            
+        Returns:
+            bool: 無効化成功フラグ
+        """
+        try:
+            user_data = await self.storage.get_user_data(user_id)
+            sessions = user_data.get("sessions", [])
+            
+            for session in sessions:
+                if session.get("session_id") == session_id:
+                    session["is_active"] = False
+                    session["invalidated_at"] = datetime.now().isoformat()
+                    
+                    await self.storage.update_user_data(user_id, user_data)
+                    
+                    logger.info(f"セッションを無効化しました: {user_id} - {session_id}")
+                    return True
+            
+            return False
+            
+        except Exception as e:
+            logger.error(f"セッション無効化エラー: {e}")
+            return False
+    
+    async def get_user_preferences(self, user_id: str) -> Dict[str, Any]:
+        """
+        ユーザーの設定を取得する
+        
+        Args:
+            user_id: ユーザーID
+            
+        Returns:
+            Dict: ユーザー設定
+        """
+        try:
+            profile = await self.get_user_profile(user_id)
+            
+            # デフォルト設定
+            default_preferences = {
+                "theme": "light",
+                "language": "ja",
+                "timezone": "Asia/Tokyo",
+                "notification_enabled": True,
+                "generation_time_preference": 2,  # デフォルトは2時
+                "theme_suggestions": True,
+                "history_retention": True
+            }
+            
+            # ユーザー設定をマージ
+            preferences = default_preferences.copy()
+            if "preferences" in profile:
+                preferences.update(profile["preferences"])
+            
+            return preferences
+            
+        except Exception as e:
+            logger.error(f"ユーザー設定取得エラー: {e}")
+            return {}
+    
+    async def update_user_preferences(self, user_id: str, preferences: Dict[str, Any]) -> bool:
+        """
+        ユーザーの設定を更新する
+        
+        Args:
+            user_id: ユーザーID
+            preferences: 更新する設定
+            
+        Returns:
+            bool: 更新成功フラグ
+        """
+        try:
+            current_preferences = await self.get_user_preferences(user_id)
+            current_preferences.update(preferences)
+            
+            return await self.update_user_profile(user_id, {"preferences": current_preferences})
+            
+        except Exception as e:
+            logger.error(f"ユーザー設定更新エラー: {e}")
+            return False
+    
+    async def _update_profile_stats(self, user_data: Dict[str, Any], interaction: Dict[str, Any]) -> None:
+        """
+        プロファイルの統計情報を更新する（内部使用）
+        
+        Args:
+            user_data: ユーザーデータ
+            interaction: インタラクション情報
+        """
+        try:
+            profile = user_data["profile"]
+            interaction_type = interaction.get("type", "")
+            
+            # インタラクションタイプ別の統計更新
+            if interaction_type == "letter_request":
+                profile["total_letters"] = profile.get("total_letters", 0) + 1
+            elif interaction_type == "letter_generated":
+                # 生成完了時の統計更新は別途処理
+                pass
+            elif interaction_type == "app_access":
+                profile["last_access"] = datetime.now().isoformat()
+            
+            # 最終アクティビティ時刻を更新
+            profile["last_activity"] = datetime.now().isoformat()
+            
+        except Exception as e:
+            logger.error(f"プロファイル統計更新エラー: {e}")
+    
+    def _calculate_last_activity(self, user_data: Dict[str, Any]) -> Optional[str]:
+        """
+        最後のアクティビティ時刻を計算する（内部使用）
+        
+        Args:
+            user_data: ユーザーデータ
+            
+        Returns:
+            Optional[str]: 最後のアクティビティ時刻
+        """
+        try:
+            timestamps = []
+            
+            # プロファイルの最終アクセス時刻
+            if "last_access" in user_data["profile"]:
+                timestamps.append(user_data["profile"]["last_access"])
+            
+            # 履歴の最新エントリ
+            history = user_data.get("history", [])
+            if history:
+                latest_history = max(history, key=lambda x: x.get("timestamp", ""))
+                timestamps.append(latest_history["timestamp"])
+            
+            # リクエストの最新エントリ
+            requests = user_data.get("requests", {})
+            if requests:
+                latest_request = max(requests.values(), key=lambda x: x.get("requested_at", ""))
+                timestamps.append(latest_request["requested_at"])
+            
+            if timestamps:
+                return max(timestamps)
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"最終アクティビティ計算エラー: {e}")
+            return None
+    
+    async def _cleanup_expired_sessions(self, user_data: Dict[str, Any]) -> None:
+        """
+        期限切れセッションをクリーンアップする（内部使用）
+        
+        Args:
+            user_data: ユーザーデータ
+        """
+        try:
+            sessions = user_data.get("sessions", [])
+            current_time = datetime.now()
+            
+            for session in sessions:
+                if session.get("is_active", False):
+                    expires_at = datetime.fromisoformat(session["expires_at"])
+                    if current_time >= expires_at:
+                        session["is_active"] = False
+                        session["expired_at"] = current_time.isoformat()
+            
+        except Exception as e:
+            logger.error(f"セッションクリーンアップエラー: {e}")
+    
+    async def cleanup_old_user_data(self, days: int = None) -> int:
+        """
+        古いユーザーデータを削除する
+        
+        Args:
+            days: 保持日数（指定しない場合は設定値を使用）
+            
+        Returns:
+            int: 削除されたエントリ数
+        """
+        try:
+            if days is None:
+                days = self.user_data_retention_days
+            
+            cutoff_date = datetime.now() - timedelta(days=days)
+            cutoff_str = cutoff_date.strftime("%Y-%m-%d")
+            
+            all_users = await self.storage.get_all_users()
+            deleted_count = 0
+            
+            for user_id in all_users:
+                user_data = await self.storage.get_user_data(user_id)
+                
+                # 古い履歴エントリを削除
+                history = user_data.get("history", [])
+                original_count = len(history)
+                
+                user_data["history"] = [
+                    entry for entry in history
+                    if entry.get("timestamp", "").split("T")[0] >= cutoff_str
+                ]
+                
+                deleted_count += original_count - len(user_data["history"])
+                
+                # 古いセッションを削除
+                sessions = user_data.get("sessions", [])
+                original_session_count = len(sessions)
+                
+                user_data["sessions"] = [
+                    session for session in sessions
+                    if session.get("created_at", "").split("T")[0] >= cutoff_str
+                ]
+                
+                deleted_count += original_session_count - len(user_data["sessions"])
+                
+                if (original_count != len(user_data["history"]) or 
+                    original_session_count != len(user_data["sessions"])):
+                    await self.storage.update_user_data(user_id, user_data)
+            
+            if deleted_count > 0:
+                logger.info(f"{deleted_count}件の古いユーザーデータを削除しました")
+            
+            return deleted_count
+            
+        except Exception as e:
+            logger.error(f"古いユーザーデータ削除エラー: {e}")
+            return 0
+    
+    async def get_user_statistics(self) -> Dict[str, Any]:
+        """
+        ユーザーの統計情報を取得する
+        
+        Returns:
+            Dict: 統計情報
+        """
+        try:
+            all_users = await self.storage.get_all_users()
+            today = datetime.now().strftime("%Y-%m-%d")
+            week_ago = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
+            
+            stats = {
+                "total_users": len(all_users),
+                "active_users_today": 0,
+                "active_users_week": 0,
+                "total_letters": 0,
+                "total_requests": 0,
+                "total_sessions": 0,
+                "active_sessions": 0,
+                "date": today
+            }
+            
+            for user_id in all_users:
+                user_data = await self.storage.get_user_data(user_id)
+                
+                # 手紙とリクエストの総数
+                stats["total_letters"] += len(user_data.get("letters", {}))
+                stats["total_requests"] += len(user_data.get("requests", {}))
+                
+                # セッション統計
+                sessions = user_data.get("sessions", [])
+                stats["total_sessions"] += len(sessions)
+                
+                for session in sessions:
+                    if session.get("is_active", False):
+                        expires_at = datetime.fromisoformat(session["expires_at"])
+                        if datetime.now() < expires_at:
+                            stats["active_sessions"] += 1
+                
+                # アクティブユーザー統計
+                last_activity = self._calculate_last_activity(user_data)
+                if last_activity:
+                    activity_date = last_activity.split("T")[0]
+                    if activity_date >= today:
+                        stats["active_users_today"] += 1
+                    if activity_date >= week_ago:
+                        stats["active_users_week"] += 1
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"ユーザー統計取得エラー: {e}")
+            return {"error": str(e)}
+
+
+# テスト用の関数
+async def test_user_manager():
+    """UserManagerのテスト"""
+    import tempfile
+    from async_storage_manager import AsyncStorageManager
+    
+    # 一時ディレクトリでテスト
+    with tempfile.TemporaryDirectory() as temp_dir:
+        test_file = os.path.join(temp_dir, "test_letters.json")
+        storage = AsyncStorageManager(test_file)
+        user_manager = UserManager(storage)
+        
+        print("=== UserManagerテスト開始 ===")
+        
+        # ユーザーID生成テスト
+        user_id = user_manager.generate_user_id()
+        print(f"✓ ユーザーID生成テスト: {user_id}")
+        
+        # プロファイル取得テスト
+        profile = await user_manager.get_user_profile(user_id)
+        print(f"✓ プロファイル取得テスト: {profile}")
+        
+        # 履歴更新テスト
+        interaction = {
+            "type": "letter_request",
+            "action": "submit_request",
+            "details": {"theme": "テストテーマ"}
+        }
+        updated = await user_manager.update_user_history(user_id, interaction)
+        print(f"✓ 履歴更新テスト: {updated}")
+        
+        # セッション作成テスト
+        session_info = {"ip_address": "127.0.0.1", "user_agent": "test"}
+        session_id = await user_manager.create_user_session(user_id, session_info)
+        print(f"✓ セッション作成テスト: {session_id}")
+        
+        # セッション検証テスト
+        valid = await user_manager.validate_user_session(user_id, session_id)
+        print(f"✓ セッション検証テスト: {valid}")
+        
+        # 統計情報取得テスト
+        stats = await user_manager.get_user_statistics()
+        print(f"✓ 統計情報取得テスト: {stats}")
+        
+        print("=== 全てのテストが完了しました！ ===")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_user_manager())

local_user_id_manager.py

@@ -0,0 +1,241 @@
+"""
+ユーザーID永続化管理モジュール
+ローカル環境でユーザーIDをファイルに保存し、仮想環境を閉じても継続してプレイできるようにする
+"""
+import os
+import json
+import uuid
+import logging
+from datetime import datetime
+from typing import Optional, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+class UserIDManager:
+    """ユーザーIDの永続化を管理するクラス"""
+    
+    def __init__(self, storage_dir: str = "user_data"):
+        """
+        Args:
+            storage_dir: ユーザーデータを保存するディレクトリ
+        """
+        self.storage_dir = storage_dir
+        self.user_id_file = os.path.join(storage_dir, "user_id.json")
+        self._ensure_storage_dir()
+    
+    def _ensure_storage_dir(self):
+        """ストレージディレクトリが存在することを確認"""
+        try:
+            if not os.path.exists(self.storage_dir):
+                os.makedirs(self.storage_dir)
+                logger.info(f"ユーザーデータディレクトリを作成: {self.storage_dir}")
+        except Exception as e:
+            logger.error(f"ストレージディレクトリ作成エラー: {e}")
+    
+    def get_or_create_user_id(self) -> str:
+        """
+        保存されたユーザーIDを取得するか、新規作成する
+        
+        Returns:
+            ユーザーID
+        """
+        try:
+            # 既存のユーザーIDファイルをチェック
+            if os.path.exists(self.user_id_file):
+                user_data = self._load_user_data()
+                if user_data and "user_id" in user_data:
+                    user_id = user_data["user_id"]
+                    logger.info(f"既存のユーザーIDを読み込み: {user_id[:8]}...")
+                    
+                    # 最終アクセス時刻を更新
+                    self._update_last_access(user_id)
+                    return user_id
+            
+            # 新規ユーザーIDを作成
+            user_id = self._generate_new_user_id()
+            self._save_user_data(user_id)
+            logger.info(f"新規ユーザーIDを作成: {user_id[:8]}...")
+            return user_id
+            
+        except Exception as e:
+            logger.error(f"ユーザーID取得エラー: {e}")
+            # フォールバック: 一時的なIDを生成
+            return str(uuid.uuid4())
+    
+    def _generate_new_user_id(self) -> str:
+        """新しいユーザーIDを生成"""
+        return str(uuid.uuid4())
+    
+    def _load_user_data(self) -> Optional[Dict[str, Any]]:
+        """ユーザーデータファイルを読み込み"""
+        try:
+            with open(self.user_id_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                return data
+        except Exception as e:
+            logger.error(f"ユーザーデータ読み込みエラー: {e}")
+            return None
+    
+    def _save_user_data(self, user_id: str, game_data: Optional[Dict[str, Any]] = None):
+        """ユーザーデータをファイルに保存"""
+        try:
+            user_data = {
+                "user_id": user_id,
+                "created_at": datetime.now().isoformat(),
+                "last_access": datetime.now().isoformat(),
+                "version": "1.0",
+                "game_data": game_data or {}
+            }
+            
+            with open(self.user_id_file, 'w', encoding='utf-8') as f:
+                json.dump(user_data, f, ensure_ascii=False, indent=2)
+            
+            logger.info(f"ユーザーデータを保存: {self.user_id_file}")
+            
+        except Exception as e:
+            logger.error(f"ユーザーデータ保存エラー: {e}")
+    
+    def _update_last_access(self, user_id: str):
+        """最終アクセス時刻を更新"""
+        try:
+            user_data = self._load_user_data()
+            if user_data:
+                user_data["last_access"] = datetime.now().isoformat()
+                
+                with open(self.user_id_file, 'w', encoding='utf-8') as f:
+                    json.dump(user_data, f, ensure_ascii=False, indent=2)
+                
+                logger.debug(f"最終アクセス時刻を更新: {user_id[:8]}...")
+                
+        except Exception as e:
+            logger.error(f"最終アクセス時刻更新エラー: {e}")
+    
+    def get_user_info(self) -> Optional[Dict[str, Any]]:
+        """ユーザー情報を取得"""
+        return self._load_user_data()
+    
+    def delete_user_data(self) -> bool:
+        """
+        ユーザーデータを削除（フルリセット用）
+        
+        Returns:
+            削除成功かどうか
+        """
+        try:
+            if os.path.exists(self.user_id_file):
+                os.remove(self.user_id_file)
+                logger.info(f"ユーザーデータファイルを削除: {self.user_id_file}")
+                return True
+            else:
+                logger.info("削除対象のユーザーデータファイルが存在しません")
+                return True
+                
+        except Exception as e:
+            logger.error(f"ユーザーデータ削除エラー: {e}")
+            return False
+    
+    def reset_user_id(self) -> str:
+        """
+        ユーザーIDをリセットして新規作成
+        
+        Returns:
+            新しいユーザーID
+        """
+        try:
+            # 既存データを削除
+            self.delete_user_data()
+            
+            # 新規IDを作成
+            new_user_id = self._generate_new_user_id()
+            self._save_user_data(new_user_id)
+            
+            logger.info(f"ユーザーIDをリセット: {new_user_id[:8]}...")
+            return new_user_id
+            
+        except Exception as e:
+            logger.error(f"ユーザーIDリセットエラー: {e}")
+            return str(uuid.uuid4())
+    
+    def is_user_data_exists(self) -> bool:
+        """ユーザーデータファイルが存在するかチェック"""
+        return os.path.exists(self.user_id_file)
+    
+    def get_storage_info(self) -> Dict[str, Any]:
+        """ストレージ情報を取得（デバッグ用）"""
+        try:
+            info = {
+                "storage_dir": self.storage_dir,
+                "user_id_file": self.user_id_file,
+                "file_exists": os.path.exists(self.user_id_file),
+                "dir_exists": os.path.exists(self.storage_dir)
+            }
+            
+            if info["file_exists"]:
+                stat = os.stat(self.user_id_file)
+                info["file_size"] = stat.st_size
+                info["modified_time"] = datetime.fromtimestamp(stat.st_mtime).isoformat()
+            
+            return info
+            
+        except Exception as e:
+            logger.error(f"ストレージ情報取得エラー: {e}")
+            return {"error": str(e)}
+    
+    def save_game_data(self, user_id: str, game_data: Dict[str, Any]) -> bool:
+        """
+        ゲームデータを保存
+        
+        Args:
+            user_id: ユーザーID
+            game_data: 保存するゲームデータ
+            
+        Returns:
+            保存成功かどうか
+        """
+        try:
+            user_data = self._load_user_data()
+            if not user_data:
+                # ユーザーデータが存在しない場合は新規作成
+                user_data = {
+                    "user_id": user_id,
+                    "created_at": datetime.now().isoformat(),
+                    "version": "1.0"
+                }
+            
+            # ゲームデータを更新
+            user_data["game_data"] = game_data
+            user_data["last_access"] = datetime.now().isoformat()
+            
+            with open(self.user_id_file, 'w', encoding='utf-8') as f:
+                json.dump(user_data, f, ensure_ascii=False, indent=2)
+            
+            logger.info(f"ゲームデータを保存: {user_id[:8]}...")
+            return True
+            
+        except Exception as e:
+            logger.error(f"ゲームデータ保存エラー: {e}")
+            return False
+    
+    def load_game_data(self, user_id: str) -> Optional[Dict[str, Any]]:
+        """
+        ゲームデータを読み込み
+        
+        Args:
+            user_id: ユーザーID
+            
+        Returns:
+            ゲームデータ（存在しない場合はNone）
+        """
+        try:
+            user_data = self._load_user_data()
+            if user_data and user_data.get("user_id") == user_id:
+                game_data = user_data.get("game_data", {})
+                logger.info(f"ゲームデータを読み込み: {user_id[:8]}... (データサイズ: {len(str(game_data))}文字)")
+                return game_data
+            else:
+                logger.info(f"ゲームデータが見つかりません: {user_id[:8]}...")
+                return None
+                
+        except Exception as e:
+            logger.error(f"ゲームデータ読み込みエラー: {e}")
+            return None

persistent_user_manager.py

@@ -0,0 +1,463 @@
+"""
+Hugging Face Spaces永続ストレージ対応ユーザー管理システム
+Cookieベースのユーザー識別と/mnt/dataでの状態永続化を提供
+"""
+import os
+import json
+import uuid
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any, List
+import streamlit as st
+from streamlit_cookies_manager import EncryptedCookieManager
+
+logger = logging.getLogger(__name__)
+
+class PersistentUserManager:
+    """永続ストレージ対応ユーザー管理クラス"""
+    
+    def __init__(self, storage_base_path: str = "/mnt/data"):
+        """
+        初期化
+        
+        Args:
+            storage_base_path: 永続ストレージのベースパス（HF Spacesでは/mnt/data）
+        """
+        # Hugging Face Spacesの永続ストレージパス
+        self.storage_base_path = storage_base_path
+        self.user_data_dir = os.path.join(storage_base_path, "mari_users")
+        self.session_data_dir = os.path.join(storage_base_path, "mari_sessions")
+        
+        # Cookie管理設定
+        self.cookie_name = "mari_user_id"
+        self.cookie_expiry_days = 30
+        
+        # ディレクトリ作成
+        self._ensure_directories()
+        
+        # Cookie管理の初期化
+        self.cookies = self._init_cookie_manager()
+        
+        logger.info(f"永続ユーザー管理システム初期化: {self.user_data_dir}")
+    
+    def _ensure_directories(self):
+        """必要なディレクトリを作成"""
+        try:
+            os.makedirs(self.user_data_dir, exist_ok=True)
+            os.makedirs(self.session_data_dir, exist_ok=True)
+            logger.info(f"ストレージディレクトリ確認完了: {self.user_data_dir}")
+        except Exception as e:
+            logger.error(f"ディレクトリ作成エラー: {e}")
+            # フォールバック: ローカルディレクトリを使用
+            self.user_data_dir = "local_mari_users"
+            self.session_data_dir = "local_mari_sessions"
+            os.makedirs(self.user_data_dir, exist_ok=True)
+            os.makedirs(self.session_data_dir, exist_ok=True)
+            logger.warning(f"フォールバック: ローカルディレクトリを使用 {self.user_data_dir}")
+    
+    def _init_cookie_manager(self) -> EncryptedCookieManager:
+        """Cookie管理システムを初期化"""
+        try:
+            # セキュアなパスワードを生成（環境変数から取得、なければ生成）
+            cookie_password = os.getenv("MARI_COOKIE_PASSWORD", "mari_chat_secure_key_2024")
+            
+            cookies = EncryptedCookieManager(
+                prefix="mari_",
+                password=cookie_password
+            )
+            
+            # Cookieが準備できるまで待機
+            if not cookies.ready():
+                st.stop()
+            
+            logger.info("Cookie管理システム初期化完了")
+            return cookies
+            
+        except Exception as e:
+            logger.error(f"Cookie管理初期化エラー: {e}")
+            # フォールバック: セッション状態のみ使用
+            return None
+    
+    def get_or_create_user_id(self) -> str:
+        """
+        ユーザーIDを取得または新規作成（Cookie連携）
+        
+        Returns:
+            ユーザーID
+        """
+        try:
+            # 1. CookieからユーザーIDを取得
+            user_id = self._get_user_id_from_cookie()
+            
+            if user_id and self._is_valid_user_id(user_id):
+                # 有効なユーザーIDが存在
+                self._update_user_access_time(user_id)
+                logger.info(f"既存ユーザーID使用: {user_id[:8]}...")
+                return user_id
+            
+            # 2. セッション状態から取得を試行
+            user_id = st.session_state.get('persistent_user_id')
+            if user_id and self._is_valid_user_id(user_id):
+                # セッション状態にあるIDを使用してCookieを更新
+                self._set_user_id_cookie(user_id)
+                self._update_user_access_time(user_id)
+                logger.info(f"セッション状態からユーザーID復元: {user_id[:8]}...")
+                return user_id
+            
+            # 3. 新規ユーザーIDを作成
+            user_id = self._create_new_user()
+            logger.info(f"新規ユーザーID作成: {user_id[:8]}...")
+            return user_id
+            
+        except Exception as e:
+            logger.error(f"ユーザーID取得エラー: {e}")
+            # フォールバック: 一時的なIDを生成
+            fallback_id = str(uuid.uuid4())
+            st.session_state.persistent_user_id = fallback_id
+            return fallback_id
+    
+    def _get_user_id_from_cookie(self) -> Optional[str]:
+        """CookieからユーザーIDを取得"""
+        try:
+            if self.cookies is None:
+                return None
+            
+            user_id = self.cookies.get(self.cookie_name)
+            if user_id and self._is_valid_uuid(user_id):
+                return user_id
+            
+            return None
+            
+        except Exception as e:
+            logger.warning(f"Cookie取得エラー: {e}")
+            return None
+    
+    def _set_user_id_cookie(self, user_id: str):
+        """ユーザーIDをCookieに設定"""
+        try:
+            if self.cookies is None:
+                return
+            
+            # Cookieの有効期限を設定
+            expiry_date = datetime.now() + timedelta(days=self.cookie_expiry_days)
+            
+            self.cookies[self.cookie_name] = user_id
+            self.cookies.save()
+            
+            logger.debug(f"ユーザーIDをCookieに保存: {user_id[:8]}...")
+            
+        except Exception as e:
+            logger.warning(f"Cookie設定エラー: {e}")
+    
+    def _is_valid_uuid(self, uuid_string: str) -> bool:
+        """UUIDの形式チェック"""
+        try:
+            uuid.UUID(uuid_string, version=4)
+            return True
+        except (ValueError, TypeError):
+            return False
+    
+    def _is_valid_user_id(self, user_id: str) -> bool:
+        """ユーザーIDの有効性チェック"""
+        try:
+            if not self._is_valid_uuid(user_id):
+                return False
+            
+            user_file = os.path.join(self.user_data_dir, f"{user_id}.json")
+            return os.path.exists(user_file)
+            
+        except Exception as e:
+            logger.warning(f"ユーザーID検証エラー: {e}")
+            return False
+    
+    def _create_new_user(self) -> str:
+        """新規ユーザーを作成"""
+        try:
+            user_id = str(uuid.uuid4())
+            
+            # ユーザーデータを作成
+            user_data = {
+                "user_id": user_id,
+                "created_at": datetime.now().isoformat(),
+                "last_access": datetime.now().isoformat(),
+                "version": "1.0",
+                "game_data": {
+                    "affection": 30,
+                    "messages": [{"role": "assistant", "content": "何の用？遊びに来たの？", "is_initial": True}],
+                    "scene_params": {"theme": "default"},
+                    "ura_mode": False
+                },
+                "settings": {
+                    "notifications_enabled": True,
+                    "auto_save": True
+                }
+            }
+            
+            # ファイルに保存
+            user_file = os.path.join(self.user_data_dir, f"{user_id}.json")
+            with open(user_file, 'w', encoding='utf-8') as f:
+                json.dump(user_data, f, ensure_ascii=False, indent=2)
+            
+            # Cookieとセッション状態に保存
+            self._set_user_id_cookie(user_id)
+            st.session_state.persistent_user_id = user_id
+            
+            logger.info(f"新規ユーザー作成完了: {user_id[:8]}...")
+            return user_id
+            
+        except Exception as e:
+            logger.error(f"新規ユーザー作成エラー: {e}")
+            # フォールバック
+            fallback_id = str(uuid.uuid4())
+            st.session_state.persistent_user_id = fallback_id
+            return fallback_id
+    
+    def _update_user_access_time(self, user_id: str):
+        """ユーザーの最終アクセス時刻を更新"""
+        try:
+            user_file = os.path.join(self.user_data_dir, f"{user_id}.json")
+            
+            if os.path.exists(user_file):
+                with open(user_file, 'r', encoding='utf-8') as f:
+                    user_data = json.load(f)
+                
+                user_data["last_access"] = datetime.now().isoformat()
+                
+                with open(user_file, 'w', encoding='utf-8') as f:
+                    json.dump(user_data, f, ensure_ascii=False, indent=2)
+                
+                logger.debug(f"ユーザーアクセス時刻更新: {user_id[:8]}...")
+            
+        except Exception as e:
+            logger.warning(f"アクセス時刻更新エラー: {e}")
+    
+    def load_user_game_data(self, user_id: str) -> Optional[Dict[str, Any]]:
+        """
+        ユーザーのゲームデータを読み込み
+        
+        Args:
+            user_id: ユーザーID
+            
+        Returns:
+            ゲームデータ（存在しない場合はNone）
+        """
+        try:
+            user_file = os.path.join(self.user_data_dir, f"{user_id}.json")
+            
+            if not os.path.exists(user_file):
+                logger.info(f"ユーザーファイルが存在しません: {user_id[:8]}...")
+                return None
+            
+            with open(user_file, 'r', encoding='utf-8') as f:
+                user_data = json.load(f)
+            
+            game_data = user_data.get("game_data", {})
+            logger.info(f"ゲームデータ読み込み完了: {user_id[:8]}... (データサイズ: {len(str(game_data))}文字)")
+            
+            return game_data
+            
+        except Exception as e:
+            logger.error(f"ゲームデータ読み込みエラー: {e}")
+            return None
+    
+    def save_user_game_data(self, user_id: str, game_data: Dict[str, Any]) -> bool:
+        """
+        ユーザーのゲームデータを保存
+        
+        Args:
+            user_id: ユーザーID
+            game_data: 保存するゲームデータ
+            
+        Returns:
+            保存成功時True
+        """
+        try:
+            user_file = os.path.join(self.user_data_dir, f"{user_id}.json")
+            
+            # 既存データを読み込み
+            if os.path.exists(user_file):
+                with open(user_file, 'r', encoding='utf-8') as f:
+                    user_data = json.load(f)
+            else:
+                # 新規ユーザーデータを作成
+                user_data = {
+                    "user_id": user_id,
+                    "created_at": datetime.now().isoformat(),
+                    "version": "1.0"
+                }
+            
+            # ゲームデータを更新
+            user_data["game_data"] = game_data
+            user_data["last_access"] = datetime.now().isoformat()
+            user_data["last_save"] = datetime.now().isoformat()
+            
+            # ファイルに保存
+            with open(user_file, 'w', encoding='utf-8') as f:
+                json.dump(user_data, f, ensure_ascii=False, indent=2)
+            
+            logger.info(f"ゲームデータ保存完了: {user_id[:8]}...")
+            return True
+            
+        except Exception as e:
+            logger.error(f"ゲームデータ保存エラー: {e}")
+            return False
+    
+    def get_user_info(self, user_id: str) -> Optional[Dict[str, Any]]:
+        """
+        ユーザー情報を取得
+        
+        Args:
+            user_id: ユーザーID
+            
+        Returns:
+            ユーザー情報
+        """
+        try:
+            user_file = os.path.join(self.user_data_dir, f"{user_id}.json")
+            
+            if os.path.exists(user_file):
+                with open(user_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"ユーザー情報取得エラー: {e}")
+            return None
+    
+    def delete_user_data(self, user_id: str) -> bool:
+        """
+        ユーザーデータを削除
+        
+        Args:
+            user_id: 削除するユーザーID
+            
+        Returns:
+            削除成功時True
+        """
+        try:
+            user_file = os.path.join(self.user_data_dir, f"{user_id}.json")
+            
+            if os.path.exists(user_file):
+                os.remove(user_file)
+                logger.info(f"ユーザーデータ削除: {user_id[:8]}...")
+            
+            # Cookieも削除
+            if self.cookies:
+                if self.cookie_name in self.cookies:
+                    del self.cookies[self.cookie_name]
+                    self.cookies.save()
+            
+            # セッション状態からも削除
+            if 'persistent_user_id' in st.session_state:
+                del st.session_state.persistent_user_id
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"ユーザーデータ削除エラー: {e}")
+            return False
+    
+    def list_all_users(self) -> List[Dict[str, Any]]:
+        """
+        全ユーザーの一覧を取得（管理用）
+        
+        Returns:
+            ユーザー情報のリスト
+        """
+        try:
+            users = []
+            
+            for filename in os.listdir(self.user_data_dir):
+                if filename.endswith('.json'):
+                    user_file = os.path.join(self.user_data_dir, filename)
+                    
+                    try:
+                        with open(user_file, 'r', encoding='utf-8') as f:
+                            user_data = json.load(f)
+                        
+                        # 基本情報のみ抽出
+                        user_info = {
+                            "user_id": user_data.get("user_id", "unknown")[:8] + "...",
+                            "created_at": user_data.get("created_at", "unknown"),
+                            "last_access": user_data.get("last_access", "unknown"),
+                            "has_game_data": "game_data" in user_data,
+                            "file_size": os.path.getsize(user_file)
+                        }
+                        
+                        users.append(user_info)
+                        
+                    except Exception as e:
+                        logger.warning(f"ユーザーファイル読み込みエラー {filename}: {e}")
+            
+            return users
+            
+        except Exception as e:
+            logger.error(f"ユーザー一覧取得エラー: {e}")
+            return []
+    
+    def cleanup_old_users(self, days_threshold: int = 30) -> int:
+        """
+        古いユーザーデータをクリーンアップ
+        
+        Args:
+            days_threshold: 削除対象の日数閾値
+            
+        Returns:
+            削除されたユーザー数
+        """
+        try:
+            current_time = datetime.now()
+            deleted_count = 0
+            
+            for filename in os.listdir(self.user_data_dir):
+                if filename.endswith('.json'):
+                    user_file = os.path.join(self.user_data_dir, filename)
+                    
+                    try:
+                        with open(user_file, 'r', encoding='utf-8') as f:
+                            user_data = json.load(f)
+                        
+                        last_access = datetime.fromisoformat(user_data.get("last_access", ""))
+                        if (current_time - last_access).days > days_threshold:
+                            os.remove(user_file)
+                            deleted_count += 1
+                            logger.info(f"古いユーザーデータ削除: {filename}")
+                    
+                    except Exception as e:
+                        logger.warning(f"クリーンアップ処理エラー {filename}: {e}")
+            
+            logger.info(f"ユーザーデータクリーンアップ完了: {deleted_count}件削除")
+            return deleted_count
+            
+        except Exception as e:
+            logger.error(f"クリーンアップエラー: {e}")
+            return 0
+    
+    def get_storage_stats(self) -> Dict[str, Any]:
+        """
+        ストレージ使用状況を取得
+        
+        Returns:
+            ストレージ統計情報
+        """
+        try:
+            stats = {
+                "user_count": 0,
+                "total_size": 0,
+                "storage_path": self.user_data_dir,
+                "cookie_enabled": self.cookies is not None
+            }
+            
+            if os.path.exists(self.user_data_dir):
+                for filename in os.listdir(self.user_data_dir):
+                    if filename.endswith('.json'):
+                        user_file = os.path.join(self.user_data_dir, filename)
+                        stats["user_count"] += 1
+                        stats["total_size"] += os.path.getsize(user_file)
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"ストレージ統計取得エラー: {e}")
+            return {"error": str(e)}

requirements.txt

@@ -0,0 +1,18 @@
+streamlit>=1.28.0
+python-dotenv>=1.0.0
+openai>=1.0.0
+groq>=0.4.0
+requests>=2.25.0
+unidic-lite
+typing-extensions>=4.0.0
+transformers>=4.20.0
+torch>=1.12.0
+sentencepiece>=0.1.95
+fugashi>=1.1.0
+ipadic>=1.0.0
+aiohttp>=3.8.0
+aiofiles>=23.0.0
+asyncio-throttle>=1.0.0
+pydantic>=2.0.0
+fastapi>=0.104.0
+uvicorn>=0.24.0

requirements_persistent.txt

@@ -0,0 +1,2 @@
+# 永続ストレージ対応ユーザー管理システム用の追加依存関係
+streamlit-cookies-manager==0.2.0

requirements_session.txt

@@ -0,0 +1,4 @@
+# FastAPIセッション管理サーバー用の追加依存関係
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+requests==2.31.0

session_api_client.py

@@ -0,0 +1,494 @@
+"""
+FastAPIセッション管理クライアント
+HttpOnlyクッキーによるセキュアなセッション管理のクライアント側実装
+"""
+import requests
+import json
+import os
+from datetime import datetime
+from typing import Optional, Dict, Any
+import streamlit as st
+import logging
+
+logger = logging.getLogger(__name__)
+
+class SessionAPIClient:
+    """FastAPIセッションサーバーとの通信クライアント"""
+    
+    def __init__(self, api_base_url: str = None):
+        """
+        初期化
+        
+        Args:
+            api_base_url: FastAPIサーバーのベースURL（Noneの場合は自動決定）
+        """
+        # Hugging Face Spacesでの実行を考慮してベースURLを自動決定
+        if api_base_url is None:
+            is_spaces = os.getenv("SPACE_ID") is not None
+            if is_spaces:
+                # Hugging Face Spacesでは同一コンテナ内なのでlocalhostを使用
+                api_base_url = "http://localhost:8000"
+            else:
+                api_base_url = "http://127.0.0.1:8000"
+        
+        self.api_base_url = api_base_url
+        self.session = requests.Session()
+        
+        # リクエストタイムアウト設定
+        self.timeout = 10
+        
+        # セッション情報をStreamlitの状態に保存
+        if 'session_info' not in st.session_state:
+            st.session_state.session_info = {}
+    
+    def create_session(self) -> Optional[str]:
+        """
+        新しいセッションを作成
+        
+        Returns:
+            セッションID（成功時）、None（失敗時）
+        """
+        try:
+            url = f"{self.api_base_url}/session/create"
+            response = self.session.post(url, timeout=self.timeout)
+            
+            if response.status_code == 200:
+                data = response.json()
+                session_id = data.get('session_id')
+                
+                # セッション情報を保存
+                st.session_state.session_info = {
+                    'session_id': session_id,
+                    'created_at': datetime.now().isoformat(),
+                    'status': 'active'
+                }
+                
+                logger.info(f"新規セッション作成成功: {session_id[:8]}...")
+                return session_id
+            else:
+                logger.error(f"セッション作成失敗: {response.status_code}")
+                return None
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"セッション作成リクエストエラー: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"セッション作成エラー: {e}")
+            return None
+    
+    def validate_session(self) -> bool:
+        """
+        現在のセッションの有効性を検証
+        
+        Returns:
+            有効な場合True
+        """
+        try:
+            # session_infoが存在しない場合は無効とみなす
+            if 'session_info' not in st.session_state:
+                logger.debug("session_info未存在 - セッション無効")
+                return False
+            
+            url = f"{self.api_base_url}/session/validate"
+            response = self.session.post(url, timeout=self.timeout)
+            
+            if response.status_code == 200:
+                data = response.json()
+                is_valid = data.get('valid', False)
+                
+                if is_valid:
+                    # セッション情報を更新
+                    session_id = data.get('session_id')
+                    st.session_state.session_info.update({
+                        'session_id': session_id,
+                        'last_validated': datetime.now().isoformat(),
+                        'status': 'active'
+                    })
+                    logger.debug(f"セッション検証成功: {session_id[:8]}...")
+                else:
+                    # 無効なセッション
+                    if 'session_info' in st.session_state:
+                        st.session_state.session_info['status'] = 'invalid'
+                    logger.warning("セッション検証失敗: 無効なセッション")
+                
+                return is_valid
+            else:
+                logger.error(f"セッション検証失敗: {response.status_code}")
+                return False
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"セッション検証リクエストエラー: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"セッション検証エラー: {e}")
+            return False
+    
+    def get_session_info(self) -> Optional[Dict[str, Any]]:
+        """
+        セッション情報を取得
+        
+        Returns:
+            セッション情報（成功時）、None（失敗時）
+        """
+        try:
+            url = f"{self.api_base_url}/session/info"
+            response = self.session.get(url, timeout=self.timeout)
+            
+            if response.status_code == 200:
+                data = response.json()
+                
+                # セッション情報を更新
+                st.session_state.session_info.update({
+                    'session_id': data.get('session_id'),
+                    'created_at': data.get('created_at'),
+                    'last_access': data.get('last_access'),
+                    'status': 'active'
+                })
+                
+                return data
+            else:
+                logger.error(f"セッション情報取得失敗: {response.status_code}")
+                return None
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"セッション情報取得リクエストエラー: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"セッション情報取得エラー: {e}")
+            return None
+    
+    def delete_session(self) -> bool:
+        """
+        現在のセッションを削除
+        
+        Returns:
+            削除成功時True
+        """
+        try:
+            url = f"{self.api_base_url}/session/delete"
+            response = self.session.delete(url, timeout=self.timeout)
+            
+            if response.status_code == 200:
+                # セッション情報をクリア
+                st.session_state.session_info = {
+                    'status': 'deleted',
+                    'deleted_at': datetime.now().isoformat()
+                }
+                
+                logger.info("セッション削除成功")
+                return True
+            else:
+                logger.error(f"セッション削除失敗: {response.status_code}")
+                return False
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"セッション削除リクエストエラー: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"セッション削除エラー: {e}")
+            return False
+    
+    def get_or_create_session_id(self) -> str:
+        """
+        セッションIDを取得または新規作成
+        複数セッション生成を防ぐため、既存セッション情報を最優先でチェック
+        
+        Returns:
+            セッションID
+        """
+        try:
+            # 既存のセッション情報をチェック
+            existing_session_info = st.session_state.get('session_info', {})
+            existing_session_id = existing_session_info.get('session_id')
+            
+            # 既存セッションがある場合は、基本的にそれを使用（検証は最小限に）
+            if existing_session_id:
+                logger.debug(f"既存セッション情報発見: {existing_session_id[:8]}...")
+                
+                # セッション状態をチェック
+                session_status = existing_session_info.get('status', 'unknown')
+                
+                # 明示的に無効とマークされていない限り、既存セッションを使用
+                if session_status != 'invalid':
+                    logger.debug(f"既存セッション使用: {existing_session_id[:8]}... (status: {session_status})")
+                    return existing_session_id
+                else:
+                    logger.info(f"無効セッション検出: {existing_session_id[:8]}... - 新規作成")
+            
+            # 新しいセッションを作成（一度だけ）
+            logger.info("新規セッション作成開始...")
+            
+            # セッション作成中フラグを設定（重複作成防止）
+            if st.session_state.get('session_creating', False):
+                logger.warning("セッション作成中 - 待機")
+                # 既存のセッション情報があればそれを返す
+                if existing_session_id:
+                    return existing_session_id
+                # なければフォールバック
+                import uuid
+                return str(uuid.uuid4())
+            
+            st.session_state.session_creating = True
+            
+            try:
+                if self.is_server_available():
+                    session_id = self.create_session()
+                    if session_id:
+                        logger.info(f"新規セッション作成成功: {session_id[:8]}...")
+                        return session_id
+                
+                # フォールバック: ローカルセッションID生成
+                import uuid
+                fallback_id = str(uuid.uuid4())
+                logger.warning(f"フォールバックセッションID生成: {fallback_id[:8]}...")
+                
+                # フォールバックセッション情報を保存
+                st.session_state.session_info = {
+                    'session_id': fallback_id,
+                    'created_at': datetime.now().isoformat(),
+                    'fallback_mode': True,
+                    'server_available': False,
+                    'status': 'fallback'
+                }
+                
+                return fallback_id
+                
+            finally:
+                # セッション作成中フラグをクリア
+                st.session_state.session_creating = False
+            
+        except Exception as e:
+            logger.error(f"セッションID取得エラー: {e}")
+            # セッション作成中フラグをクリア
+            st.session_state.session_creating = False
+            
+            # 最終フォールバック
+            import uuid
+            fallback_id = str(uuid.uuid4())
+            logger.error(f"最終フォールバックセッションID: {fallback_id[:8]}...")
+            return fallback_id
+    
+    def is_server_available(self) -> bool:
+        """
+        FastAPIサーバーが利用可能かチェック
+        
+        Returns:
+            利用可能な場合True
+        """
+        try:
+            url = f"{self.api_base_url}/health"
+            response = self.session.get(url, timeout=5)
+            return response.status_code == 200
+        except:
+            return False
+    
+    def get_session_status(self) -> Dict[str, Any]:
+        """
+        現在のセッション状態を取得
+        
+        Returns:
+            セッション状態の辞書
+        """
+        session_info = st.session_state.get('session_info', {})
+        
+        return {
+            'session_id': session_info.get('session_id', 'unknown')[:8] + "..." if session_info.get('session_id') else 'none',
+            'status': session_info.get('status', 'unknown'),
+            'created_at': session_info.get('created_at'),
+            'last_access': session_info.get('last_access'),
+            'last_validated': session_info.get('last_validated'),
+            'server_available': self.is_server_available()
+        }
+    
+    def reset_session(self) -> str:
+        """
+        セッションをリセット（削除して新規作成）
+        
+        Returns:
+            新しいセッションID
+        """
+        try:
+            # 既存セッションを削除
+            self.delete_session()
+            
+            # 新しいセッションを作成
+            new_session_id = self.create_session()
+            if new_session_id:
+                logger.info(f"セッションリセット完了: {new_session_id[:8]}...")
+                return new_session_id
+            
+            # フォールバック
+            import uuid
+            fallback_id = str(uuid.uuid4())
+            logger.warning(f"セッションリセット失敗、フォールバック使用: {fallback_id[:8]}...")
+            return fallback_id
+            
+        except Exception as e:
+            logger.error(f"セッションリセットエラー: {e}")
+            import uuid
+            return str(uuid.uuid4())
+    
+    def get_cookie_status(self) -> Dict[str, Any]:
+        """
+        現在のCookie状態を取得
+        
+        Returns:
+            Cookie状態の辞書
+        """
+        try:
+            cookie_info = {
+                'count': len(self.session.cookies),
+                'cookies': [],
+                'has_session_cookie': False,
+                'timestamp': datetime.now().isoformat()
+            }
+            
+            for cookie in self.session.cookies:
+                cookie_data = {
+                    'name': cookie.name,
+                    'domain': cookie.domain,
+                    'path': cookie.path,
+                    'secure': cookie.secure,
+                    'expires': cookie.expires
+                }
+                cookie_info['cookies'].append(cookie_data)
+                
+                # セッション関連のCookieをチェック
+                if 'session' in cookie.name.lower():
+                    cookie_info['has_session_cookie'] = True
+            
+            return cookie_info
+            
+        except Exception as e:
+            logger.error(f"Cookie状態取得エラー: {e}")
+            return {
+                'count': 0,
+                'cookies': [],
+                'has_session_cookie': False,
+                'error': str(e),
+                'timestamp': datetime.now().isoformat()
+            }
+    
+    def full_reset_session(self) -> Dict[str, Any]:
+        """
+        フルリセット（Cookie削除 + 新規セッション作成）
+        サーバー接続エラーでも動作するフォールバック機能付き
+        
+        Returns:
+            リセット結果の辞書
+        """
+        try:
+            result = {
+                'success': False,
+                'old_session_id': None,
+                'new_session_id': None,
+                'message': '',
+                'timestamp': datetime.now().isoformat(),
+                'cookie_reset': False,
+                'session_created': False,
+                'server_available': False,
+                'fallback_mode': False
+            }
+            
+            # 現在のセッションIDを記録
+            current_session_info = st.session_state.get('session_info', {})
+            old_session_id = current_session_info.get('session_id', st.session_state.get('user_id', 'unknown'))
+            result['old_session_id'] = old_session_id[:8] + "..." if len(old_session_id) > 8 else old_session_id
+            
+            logger.info(f"フルリセット開始 - 旧セッション: {result['old_session_id']}")
+            
+            # 1. サーバー接続テスト
+            server_available = self._test_server_connection()
+            result['server_available'] = server_available
+            
+            if server_available:
+                # サーバーが利用可能な場合の通常処理
+                logger.info("サーバー利用可能 - 通常のフルリセット実行")
+                delete_success = self.delete_session()
+                logger.info(f"セッション削除結果: {delete_success}")
+            else:
+                # サーバーが利用できない場合のフォールバック処理
+                logger.warning("サーバー接続不可 - フォールバックモードでリセット実行")
+                result['fallback_mode'] = True
+            
+            # 2. セッション情報を完全クリア
+            if 'session_info' in st.session_state:
+                del st.session_state.session_info
+            
+            # 3. 新しいrequestsセッションを作成（Cookie完全クリア）
+            old_session = self.session
+            cookie_count_before = len(old_session.cookies)
+            
+            self.session.close()
+            self.session = requests.Session()
+            
+            # Cookieが完全にクリアされたことを確認
+            cookie_count_after = len(self.session.cookies)
+            result['cookie_reset'] = cookie_count_after == 0
+            
+            logger.info(f"Cookie状態 - 削除前: {cookie_count_before}個, 削除後: {cookie_count_after}個")
+            
+            # 4. 新しいセッションを作成
+            if server_available:
+                # サーバー経由でセッション作成
+                new_session_id = self.create_session()
+            else:
+                # フォールバック: ローカルでセッションID生成
+                import uuid
+                new_session_id = str(uuid.uuid4())
+                logger.info(f"フォールバックモード: ローカルセッションID生成 - {new_session_id[:8]}...")
+            
+            if new_session_id:
+                result['success'] = True
+                result['session_created'] = True
+                result['new_session_id'] = new_session_id[:8] + "..."
+                
+                if result['fallback_mode']:
+                    result['message'] = 'フルリセット成功（フォールバックモード） - Cookie削除＆ローカルセッション作成完了'
+                else:
+                    result['message'] = 'フルリセット成功 - Cookie削除＆新規セッション作成完了'
+                
+                logger.info(f"フルリセット成功: {result['old_session_id']} → {result['new_session_id']}")
+                
+                # 新しいセッション情報をStreamlitセッションに保存
+                st.session_state.session_info = {
+                    'session_id': new_session_id,
+                    'created_at': datetime.now().isoformat(),
+                    'reset_count': st.session_state.get('reset_count', 0) + 1,
+                    'fallback_mode': result['fallback_mode'],
+                    'server_available': result['server_available']
+                }
+                
+            else:
+                result['message'] = 'Cookie削除成功、セッション作成失敗'
+                logger.error("フルリセット: 新規セッション作成失敗")
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"フルリセットエラー: {e}")
+            return {
+                'success': False,
+                'old_session_id': 'error',
+                'new_session_id': None,
+                'message': f'エラー: {str(e)}',
+                'timestamp': datetime.now().isoformat(),
+                'cookie_reset': False,
+                'session_created': False,
+                'server_available': False,
+                'fallback_mode': True
+            }
+    
+    def _test_server_connection(self) -> bool:
+        """
+        サーバー接続をテストする
+        
+        Returns:
+            接続可能かどうか
+        """
+        try:
+            response = requests.get(f"{self.base_url}/health", timeout=2)
+            return response.status_code == 200
+        except Exception as e:
+            logger.debug(f"サーバー接続テスト失敗: {e}")
+            return False

session_api_server.py

@@ -0,0 +1,298 @@
+"""
+FastAPIベースのセッション管理サーバー
+HttpOnlyクッキーによるセキュアなセッション管理を提供
+"""
+from fastapi import FastAPI, Request, Response, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import uuid
+import json
+import os
+import time
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any
+import logging
+
+# ログ設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Mari Session API", version="1.0.0")
+
+# CORS設定（Streamlitからのアクセスを許可）
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:8501", 
+        "https://localhost:8501",
+        "http://127.0.0.1:8501",
+        "https://127.0.0.1:8501",
+        "*"  # Hugging Face Spacesでの実行を考慮
+    ],
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE"],
+    allow_headers=["*"],
+)
+
+class SessionManager:
+    """セッション管理クラス"""
+    
+    def __init__(self, storage_path: str = "session_data"):
+        self.storage_path = storage_path
+        self.cookie_name = "mari_session_id"
+        self.session_duration_days = 7
+        self.cleanup_interval_hours = 24
+        
+        # ストレージディレクトリを作成
+        os.makedirs(self.storage_path, exist_ok=True)
+        
+        # 最後のクリーンアップ時刻を記録するファイル
+        self.cleanup_file = os.path.join(self.storage_path, "last_cleanup.json")
+    
+    def create_session(self) -> str:
+        """新しいセッションを作成"""
+        session_id = str(uuid.uuid4())
+        
+        session_data = {
+            'session_id': session_id,
+            'created_at': datetime.now().isoformat(),
+            'last_access': datetime.now().isoformat(),
+            'user_data': {}
+        }
+        
+        # セッションファイルに保存
+        session_file = os.path.join(self.storage_path, f"{session_id}.json")
+        with open(session_file, 'w', encoding='utf-8') as f:
+            json.dump(session_data, f, ensure_ascii=False, indent=2)
+        
+        logger.info(f"新規セッション作成: {session_id[:8]}...")
+        return session_id
+    
+    def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """セッションデータを取得"""
+        try:
+            session_file = os.path.join(self.storage_path, f"{session_id}.json")
+            
+            if not os.path.exists(session_file):
+                return None
+            
+            with open(session_file, 'r', encoding='utf-8') as f:
+                session_data = json.load(f)
+            
+            # 期限チェック
+            last_access = datetime.fromisoformat(session_data.get('last_access', ''))
+            expiry_time = last_access + timedelta(days=self.session_duration_days)
+            
+            if datetime.now() > expiry_time:
+                # 期限切れセッションを削除
+                os.remove(session_file)
+                logger.info(f"期限切れセッション削除: {session_id[:8]}...")
+                return None
+            
+            return session_data
+            
+        except Exception as e:
+            logger.error(f"セッション取得エラー: {e}")
+            return None
+    
+    def update_session_access(self, session_id: str) -> bool:
+        """セッションの最終アクセス時刻を更新"""
+        try:
+            session_file = os.path.join(self.storage_path, f"{session_id}.json")
+            
+            if not os.path.exists(session_file):
+                return False
+            
+            with open(session_file, 'r', encoding='utf-8') as f:
+                session_data = json.load(f)
+            
+            session_data['last_access'] = datetime.now().isoformat()
+            
+            with open(session_file, 'w', encoding='utf-8') as f:
+                json.dump(session_data, f, ensure_ascii=False, indent=2)
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"セッションアクセス時刻更新エラー: {e}")
+            return False
+    
+    def delete_session(self, session_id: str) -> bool:
+        """セッションを削除"""
+        try:
+            session_file = os.path.join(self.storage_path, f"{session_id}.json")
+            
+            if os.path.exists(session_file):
+                os.remove(session_file)
+                logger.info(f"セッション削除: {session_id[:8]}...")
+                return True
+            
+            return False
+            
+        except Exception as e:
+            logger.error(f"セッション削除エラー: {e}")
+            return False
+    
+    def cleanup_expired_sessions(self):
+        """期限切れセッションのクリーンアップ"""
+        try:
+            current_time = datetime.now()
+            cleaned_count = 0
+            
+            for filename in os.listdir(self.storage_path):
+                if filename.endswith('.json') and filename != 'last_cleanup.json':
+                    session_file = os.path.join(self.storage_path, filename)
+                    
+                    try:
+                        with open(session_file, 'r', encoding='utf-8') as f:
+                            session_data = json.load(f)
+                        
+                        last_access = datetime.fromisoformat(session_data.get('last_access', ''))
+                        expiry_time = last_access + timedelta(days=self.session_duration_days)
+                        
+                        if current_time > expiry_time:
+                            os.remove(session_file)
+                            cleaned_count += 1
+                    
+                    except Exception as e:
+                        logger.warning(f"セッションファイル処理エラー {filename}: {e}")
+            
+            if cleaned_count > 0:
+                logger.info(f"期限切れセッション {cleaned_count}件を削除")
+                
+        except Exception as e:
+            logger.error(f"セッションクリーンアップエラー: {e}")
+
+# セッションマネージャーのインスタンス
+session_manager = SessionManager()
+
+@app.post("/session/create")
+async def create_session(response: Response):
+    """新しいセッションを作成してCookieを設定"""
+    try:
+        # 期限切れセッションのクリーンアップ
+        session_manager.cleanup_expired_sessions()
+        
+        # 新しいセッションを作成
+        session_id = session_manager.create_session()
+        
+        # HttpOnlyクッキーを設定（Hugging Face Spaces対応）
+        is_production = os.getenv("SPACE_ID") is not None  # Hugging Face Spacesの環境変数
+        
+        response.set_cookie(
+            key=session_manager.cookie_name,
+            value=session_id,
+            max_age=session_manager.session_duration_days * 24 * 60 * 60,  # 7日間
+            httponly=True,
+            secure=is_production,  # 本番環境（HTTPS）でのみSecure属性を有効
+            samesite="lax" if is_production else "strict"  # 本番環境では緩和
+        )
+        
+        return {
+            "status": "success",
+            "session_id": session_id,
+            "message": "セッションが作成されました"
+        }
+        
+    except Exception as e:
+        logger.error(f"セッション作成エラー: {e}")
+        raise HTTPException(status_code=500, detail="セッション作成に失敗しました")
+
+@app.get("/session/info")
+async def get_session_info(request: Request):
+    """現在のセッション情報を取得"""
+    try:
+        # CookieからセッションIDを取得
+        session_id = request.cookies.get(session_manager.cookie_name)
+        
+        if not session_id:
+            raise HTTPException(status_code=401, detail="セッションが見つかりません")
+        
+        # セッションデータを取得
+        session_data = session_manager.get_session(session_id)
+        
+        if not session_data:
+            raise HTTPException(status_code=401, detail="無効なセッションです")
+        
+        # アクセス時刻を更新
+        session_manager.update_session_access(session_id)
+        
+        return {
+            "status": "success",
+            "session_id": session_id,
+            "created_at": session_data.get('created_at'),
+            "last_access": session_data.get('last_access')
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"セッション情報取得エラー: {e}")
+        raise HTTPException(status_code=500, detail="セッション情報の取得に失敗しました")
+
+@app.post("/session/validate")
+async def validate_session(request: Request):
+    """セッションの有効性を検証"""
+    try:
+        # CookieからセッションIDを取得
+        session_id = request.cookies.get(session_manager.cookie_name)
+        
+        if not session_id:
+            return {"valid": False, "message": "セッションが見つかりません"}
+        
+        # セッションデータを取得
+        session_data = session_manager.get_session(session_id)
+        
+        if not session_data:
+            return {"valid": False, "message": "無効なセッションです"}
+        
+        # アクセス時刻を更新
+        session_manager.update_session_access(session_id)
+        
+        return {
+            "valid": True,
+            "session_id": session_id,
+            "message": "有効なセッションです"
+        }
+        
+    except Exception as e:
+        logger.error(f"セッション検証エラー: {e}")
+        return {"valid": False, "message": "セッション検証に失敗しました"}
+
+@app.delete("/session/delete")
+async def delete_session(request: Request, response: Response):
+    """セッションを削除"""
+    try:
+        # CookieからセッションIDを取得
+        session_id = request.cookies.get(session_manager.cookie_name)
+        
+        if session_id:
+            # セッションファイルを削除
+            session_manager.delete_session(session_id)
+        
+        # Cookieを削除（Hugging Face Spaces対応）
+        is_production = os.getenv("SPACE_ID") is not None
+        
+        response.delete_cookie(
+            key=session_manager.cookie_name,
+            httponly=True,
+            secure=is_production,
+            samesite="lax" if is_production else "strict"
+        )
+        
+        return {
+            "status": "success",
+            "message": "セッションが削除されました"
+        }
+        
+    except Exception as e:
+        logger.error(f"セッション削除エラー: {e}")
+        raise HTTPException(status_code=500, detail="セッション削除に失敗しました")
+
+@app.get("/health")
+async def health_check():
+    """ヘルスチェック"""
+    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=8000, log_level="info")

session_cookie_manager.py

@@ -0,0 +1,383 @@
+"""
+セッションCookie管理システム
+UUIDベースのユーザー識別とCookie管理を提供する
+"""
+import uuid
+import json
+import os
+import time
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any
+import streamlit as st
+import logging
+
+logger = logging.getLogger(__name__)
+
+class SessionCookieManager:
+    """セッションCookie管理クラス"""
+    
+    def __init__(self, storage_path: str = "session_data"):
+        """
+        初期化
+        
+        Args:
+            storage_path: セッションデータの保存パス
+        """
+        self.storage_path = storage_path
+        self.cookie_name = "mari_session_id"
+        self.session_duration_days = 7
+        self.cleanup_interval_hours = 24
+        
+        # ストレージディレクトリを作成
+        os.makedirs(self.storage_path, exist_ok=True)
+        
+        # 最後のクリーンアップ時刻を記録するファイル
+        self.cleanup_file = os.path.join(self.storage_path, "last_cleanup.json")
+    
+    def get_or_create_session_id(self) -> str:
+        """
+        セッションIDを取得または新規作成
+        
+        Returns:
+            セッションID（UUID4形式）
+        """
+        try:
+            # 既存のセッションIDを確認
+            session_id = self._get_session_id_from_state()
+            
+            if session_id and self._is_valid_session(session_id):
+                # 有効なセッションIDが存在する場合
+                self._update_session_access_time(session_id)
+                logger.info(f"既存セッションID使用: {session_id[:8]}...")
+                return session_id
+            
+            # 新しいセッションIDを生成
+            session_id = str(uuid.uuid4())
+            self._create_new_session(session_id)
+            logger.info(f"新規セッションID生成: {session_id[:8]}...")
+            
+            return session_id
+            
+        except Exception as e:
+            logger.error(f"セッションID取得エラー: {e}")
+            # フォールバック：一時的なセッションID
+            return str(uuid.uuid4())
+    
+    def _get_session_id_from_state(self) -> Optional[str]:
+        """
+        Streamlitの状態からセッションIDを取得
+        
+        Returns:
+            セッションID（存在しない場合はNone）
+        """
+        # Streamlitのセッション状態から取得
+        session_id = st.session_state.get('mari_session_id')
+        
+        if session_id:
+            return session_id
+        
+        # URLパラメータから取得を試行（フォールバック）
+        query_params = st.query_params
+        if 'session_id' in query_params:
+            session_id = query_params['session_id']
+            if self._is_valid_uuid(session_id):
+                return session_id
+        
+        return None
+    
+    def _is_valid_uuid(self, uuid_string: str) -> bool:
+        """
+        UUIDの形式が正しいかチェック
+        
+        Args:
+            uuid_string: チェックするUUID文字列
+            
+        Returns:
+            有効な場合True
+        """
+        try:
+            uuid.UUID(uuid_string, version=4)
+            return True
+        except (ValueError, TypeError):
+            return False
+    
+    def _is_valid_session(self, session_id: str) -> bool:
+        """
+        セッションが有効かチェック
+        
+        Args:
+            session_id: チェックするセッションID
+            
+        Returns:
+            有効な場合True
+        """
+        try:
+            session_file = os.path.join(self.storage_path, f"{session_id}.json")
+            
+            if not os.path.exists(session_file):
+                return False
+            
+            with open(session_file, 'r', encoding='utf-8') as f:
+                session_data = json.load(f)
+            
+            # 最終アクセス時刻をチェック
+            last_access = datetime.fromisoformat(session_data.get('last_access', ''))
+            expiry_time = last_access + timedelta(days=self.session_duration_days)
+            
+            return datetime.now() < expiry_time
+            
+        except Exception as e:
+            logger.warning(f"セッション検証エラー: {e}")
+            return False
+    
+    def _create_new_session(self, session_id: str) -> None:
+        """
+        新しいセッションを作成
+        
+        Args:
+            session_id: 新しいセッションID
+        """
+        try:
+            # セッションデータを作成
+            session_data = {
+                'session_id': session_id,
+                'created_at': datetime.now().isoformat(),
+                'last_access': datetime.now().isoformat(),
+                'user_agent': self._get_user_agent(),
+                'ip_hash': self._get_ip_hash()
+            }
+            
+            # セッションファイルに保存
+            session_file = os.path.join(self.storage_path, f"{session_id}.json")
+            with open(session_file, 'w', encoding='utf-8') as f:
+                json.dump(session_data, f, ensure_ascii=False, indent=2)
+            
+            # Streamlitの状態に保存
+            st.session_state.mari_session_id = session_id
+            
+            # Cookie設定のJavaScriptを生成（セキュア設定）
+            self._set_secure_cookie(session_id)
+            
+        except Exception as e:
+            logger.error(f"新規セッション作成エラー: {e}")
+    
+    def _update_session_access_time(self, session_id: str) -> None:
+        """
+        セッションの最終アクセス時刻を更新
+        
+        Args:
+            session_id: 更新するセッションID
+        """
+        try:
+            session_file = os.path.join(self.storage_path, f"{session_id}.json")
+            
+            if os.path.exists(session_file):
+                with open(session_file, 'r', encoding='utf-8') as f:
+                    session_data = json.load(f)
+                
+                session_data['last_access'] = datetime.now().isoformat()
+                
+                with open(session_file, 'w', encoding='utf-8') as f:
+                    json.dump(session_data, f, ensure_ascii=False, indent=2)
+            
+        except Exception as e:
+            logger.warning(f"セッションアクセス時刻更新エラー: {e}")
+    
+    def _set_secure_cookie(self, session_id: str) -> None:
+        """
+        セキュアなCookieを設定
+        
+        Args:
+            session_id: 設定するセッションID
+        """
+        try:
+            # セキュアCookie設定のJavaScript
+            cookie_js = f"""
+            <script>
+            // セキュアCookieの設定
+            function setSecureCookie() {{
+                const sessionId = '{session_id}';
+                const expiryDays = {self.session_duration_days};
+                const expiryDate = new Date();
+                expiryDate.setTime(expiryDate.getTime() + (expiryDays * 24 * 60 * 60 * 1000));
+                
+                // セキュア属性付きCookieを設定
+                let cookieString = `{self.cookie_name}=${{sessionId}}; expires=${{expiryDate.toUTCString()}}; path=/; SameSite=Strict`;
+                
+                // HTTPS環境の場合はSecure属性を追加
+                if (location.protocol === 'https:') {{
+                    cookieString += '; Secure';
+                }}
+                
+                // HttpOnly属性は JavaScript では設定できないため、サーバーサイドで設定が必要
+                document.cookie = cookieString;
+                
+                console.log('セッションCookie設定完了:', sessionId.substring(0, 8) + '...');
+            }}
+            
+            // ページ読み込み時にCookieを設定
+            if (document.readyState === 'loading') {{
+                document.addEventListener('DOMContentLoaded', setSecureCookie);
+            }} else {{
+                setSecureCookie();
+            }}
+            </script>
+            """
+            
+            st.markdown(cookie_js, unsafe_allow_html=True)
+            
+        except Exception as e:
+            logger.error(f"セキュアCookie設定エラー: {e}")
+    
+    def _get_user_agent(self) -> str:
+        """
+        ユーザーエージェントを取得（可能な場合）
+        
+        Returns:
+            ユーザーエージェント文字列
+        """
+        try:
+            # Streamlitでは直接取得できないため、JavaScriptで取得
+            return "Streamlit-Client"
+        except Exception:
+            return "Unknown"
+    
+    def _get_ip_hash(self) -> str:
+        """
+        IPアドレスのハッシュを取得（プライバシー保護）
+        
+        Returns:
+            IPアドレスのハッシュ
+        """
+        try:
+            import hashlib
+            # 実際のIPアドレスは取得せず、セッション識別用のハッシュのみ
+            session_hash = hashlib.sha256(str(time.time()).encode()).hexdigest()[:16]
+            return session_hash
+        except Exception:
+            return "unknown"
+    
+    def cleanup_expired_sessions(self) -> None:
+        """
+        期限切れセッションのクリーンアップ
+        """
+        try:
+            # 前回のクリーンアップ時刻をチェック
+            if not self._should_cleanup():
+                return
+            
+            current_time = datetime.now()
+            cleaned_count = 0
+            
+            # セッションファイルをスキャン
+            for filename in os.listdir(self.storage_path):
+                if filename.endswith('.json') and filename != 'last_cleanup.json':
+                    session_file = os.path.join(self.storage_path, filename)
+                    
+                    try:
+                        with open(session_file, 'r', encoding='utf-8') as f:
+                            session_data = json.load(f)
+                        
+                        last_access = datetime.fromisoformat(session_data.get('last_access', ''))
+                        expiry_time = last_access + timedelta(days=self.session_duration_days)
+                        
+                        if current_time > expiry_time:
+                            os.remove(session_file)
+                            cleaned_count += 1
+                            logger.info(f"期限切れセッション削除: {filename}")
+                    
+                    except Exception as e:
+                        logger.warning(f"セッションファイル処理エラー {filename}: {e}")
+            
+            # クリーンアップ時刻を記録
+            self._update_cleanup_time()
+            
+            if cleaned_count > 0:
+                logger.info(f"セッションクリーンアップ完了: {cleaned_count}件削除")
+            
+        except Exception as e:
+            logger.error(f"セッションクリーンアップエラー: {e}")
+    
+    def _should_cleanup(self) -> bool:
+        """
+        クリーンアップが必要かチェック
+        
+        Returns:
+            クリーンアップが必要な場合True
+        """
+        try:
+            if not os.path.exists(self.cleanup_file):
+                return True
+            
+            with open(self.cleanup_file, 'r', encoding='utf-8') as f:
+                cleanup_data = json.load(f)
+            
+            last_cleanup = datetime.fromisoformat(cleanup_data.get('last_cleanup', ''))
+            next_cleanup = last_cleanup + timedelta(hours=self.cleanup_interval_hours)
+            
+            return datetime.now() > next_cleanup
+            
+        except Exception:
+            return True
+    
+    def _update_cleanup_time(self) -> None:
+        """
+        クリーンアップ時刻を更新
+        """
+        try:
+            cleanup_data = {
+                'last_cleanup': datetime.now().isoformat()
+            }
+            
+            with open(self.cleanup_file, 'w', encoding='utf-8') as f:
+                json.dump(cleanup_data, f, ensure_ascii=False, indent=2)
+                
+        except Exception as e:
+            logger.warning(f"クリーンアップ時刻更新エラー: {e}")
+    
+    def get_session_info(self, session_id: str) -> Dict[str, Any]:
+        """
+        セッション情報を取得
+        
+        Args:
+            session_id: セッションID
+            
+        Returns:
+            セッション情報の辞書
+        """
+        try:
+            session_file = os.path.join(self.storage_path, f"{session_id}.json")
+            
+            if os.path.exists(session_file):
+                with open(session_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            
+            return {}
+            
+        except Exception as e:
+            logger.error(f"セッション情報取得エラー: {e}")
+            return {}
+    
+    def delete_session(self, session_id: str) -> bool:
+        """
+        セッションを削除
+        
+        Args:
+            session_id: 削除するセッションID
+            
+        Returns:
+            削除成功時True
+        """
+        try:
+            session_file = os.path.join(self.storage_path, f"{session_id}.json")
+            
+            if os.path.exists(session_file):
+                os.remove(session_file)
+                logger.info(f"セッション削除: {session_id[:8]}...")
+                return True
+            
+            return False
+            
+        except Exception as e:
+            logger.error(f"セッション削除エラー: {e}")
+            return False