docs: v1.7.1 STABLE リリース・バックアップ作成

STATUS.md

@@ -1,14 +1,27 @@
-# プロジェクト: 超天才クイズ v1.7.0
+# プロジェクト: 超天才クイズ v1.7.1
 
 ## ステータス概要
-- **現在地**: v1.7.0 制限時間機能 実装完了 → E2Eテスト待ち
-- **完成度**: 95%（テスト未実施）
-- **最大課題**: HFデプロイ後のE2Eテスト
+- **現在地**: v1.7.1 STABLE リリース完了
+- **完成度**: 100%
+- **最大課題**: なし（安定運用中）
+
+## v1.7.1 修正内容
+
+### E2Eテスト結果（2025-12-21）
+- ✅ タイマー表示・カウントダウン正常動作
+- ✅ 時間切れダイアログ正常表示
+- ✅ 未回答の不正解処理
+- ⚠️ 制限時間5分は長い → 3分に短縮
+- ⚠️ 算数27問生成 → 10問制限のスライス処理追加
+
+### v1.7.1 修正
+1. **制限時間短縮**: 5分 → 3分（180秒）に変更
+2. **問題数制限**: Geminiが10問超生成時にスライスで10問に制限
 
 ## v1.7.0 新機能: 制限時間
 
 ### 実装内容
-- 1科目あたり5分（300秒）の制限時間
+- 1科目あたり3分（180秒）の制限時間
 - カウントダウンタイマーをヘッダー右上に常時表示
 - 時間切れ時: ダイアログ表示 → OK → 未回答は不正解 → 結果画面へ
 - 各問題の回答時間（time_taken_seconds）をGASに記録
@@ -97,6 +110,7 @@
 
 | フォルダ | バージョン | 説明 |
 |---------|-----------|------|
+| `V1.7.1/` | v1.7.1 STABLE | 制限時間機能追加版（RECOVERY.md含む） |
 | `V1.6.15/` | v1.6.15 STABLE | 完全復旧可能なバックアップ（RECOVERY.md含む） |
 
 ## 今後の構想

V1.7.1/CLAUDE.md

@@ -0,0 +1,759 @@
+# CLAUDE.md — ClaudeCode単体運用 プロジェクト管理ガイド
+
+> **対象**: ClaudeCode（Sonnet 4.5以降）による単独開発プロジェクト
+> **原則**: 一次情報最優先 ／ 小さく回す ／ 差分最小 ／ 再現・ロールバック可能
+> **目的**: 要件整理・設計・実装・レビューを一人で回し、確実に進める
+
+---
+
+## 【最重要】作業開始時の必須手順
+
+**すべての作業開始前に、以下を実行すること：**
+
+1. ✅ **`STATUS.md` を最優先で確認**（プロジェクトの現在地を3行で把握）
+2. ✅ **`log/LOG.md` の最新エントリを確認**（直近の変更と未解決事項を把握）
+3. ✅ **不明点があれば、関連するドキュメントを確認**（`DOCS_INDEX.md` 参照）
+
+**STATUS.md の位置づけ**:
+- プロジェクトの現在地、完成度、次のステップを一元管理
+- このファイルを読まずに作業を開始してはならない
+- 必要に応じて各セッション開始時に更新
+
+---
+
+## 0) 原則（ポリシー・意思決定の優先順位）
+
+### 0.1 一次情報と再現性
+
+- **一次情報最優先**: 公式Docs・標準・リリースノート・ソースコード
+- **根拠の可搬性**: 決定にはリンク/バージョン/日付/コミットIDを必ず添付
+- **不確実性の明示**: わからない点は「仮説」として明示し、検証方法と期限をセット
+
+### 0.2 小さく早く、失敗に強く
+
+- **スコープ最小化**: 1サイクル = 60–120分、1目的、1–2コミット
+- **ロールバック容易性**: 常に「1つのrevertで戻せる」サイズに分割
+- **破壊的操作の標準手順**: Dry-run → Diff確認 → Backup確認 → 最小適用
+
+### 0.3 品質の定義（Quality Gates）
+
+- **必須ゲート**: lint / type-check / 主要ケースのテスト
+- **任意ゲート**: security scan / performance（閾値定義時）
+- **運用ルール**: ゲート未達は次のサイクルで是正
+
+### 0.4 リスクと不確実性
+
+- 不確実は**仮説**として扱う（H0/H1・測定方法・合否基準・期限）
+- 主要リスク最大3点に圧縮し、Plan B と撤退条件も併記
+
+---
+
+## 1) ClaudeCode単体の役割設計
+
+### 1.1 ClaudeCodeの責務（このプロセスの全フェーズ）
+
+| フェーズ | 責務 | 成果物 |
+|--------|------|--------|
+| **要件整理** | 曖昧な要件を言語化、スコープ確定 | PLAN（目的/最小スコープ/受入基準） |
+| **設計** | アーキテクチャ・設計方針・技術選定 | 設計ドキュメント / 参照Docs リスト |
+| **実装** | 実装・テスト・差分生成・機械的修正 | ソースコード / `git diff` / テスト結果 |
+| **レビュー** | 自己レビュー・品質ゲート判定・承認 | REVIEW（合否/修正指示/ロールバック手順） |
+| **ドキュメント** | 変更の理由・根拠・計測結果を記録 | LOG.md更新 / 次のタスク定義 |
+
+### 1.2 ClaudeCodeの得意領域
+
+- 曖昧要件の言語化、長文脈での整合性判定
+- 非機能要求の網羅（性能/セキュリティ/拡張性）
+- 機械的変換・差分最適化・型整合
+- テストコード雛形、lint/security要約
+- ドキュメント構造化・時系列管理
+
+### 1.3 非責務（外部リソース等に依存する場合は明示）
+
+- サードパーティの商用API利用（費用承認が必要な場合）
+- 大規模インフラの構築（本ガイド外の決定が必要な場合）
+
+---
+
+## 2) 基本ループ（イベント駆動で小さく回す）
+
+### 2.1 サイクルの流れ
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  1. PLAN（目的・スコープ・受入基準・リスク）            │
+│     ↓                                                    │
+│  2. BUILD（実装・テスト・差分生成）                      │
+│     ↓                                                    │
+│  3. REVIEW（自己レビュー・品質ゲート判定）              │
+│     ↓                                                    │
+│  4. APPLY（差し戻しか採用か）                            │
+│     ├─→ 採用 → DOC記録 → 次のサイクルへ                 │
+│     └─→ 修正 → 新PLANへ                                 │
+└─────────────────────────────────────────────────────────┘
+```
+
+### 2.2 各フェーズの詳細
+
+#### フェーズ 1: PLAN（Claude）
+
+**入力**: 要件・背景・リスク・参考情報
+**出力**: 以下を含むPLAN文書
+
+```
+## PLAN: [タスク名]
+
+### 目的（1行）
+[やること・なぜやるか]
+
+### 最小スコープ（3–5項目）
+- [ ] タスク1
+- [ ] タスク2
+- [ ] タスク3
+
+### 受入基準
+- **機能**: [仕様リンク]の動作を満たす
+- **品質**: lint/type OK、主要テスト Green
+- **性能**: [SLO]（ある場合）
+- **互換性**: 破壊的変更なし or 合意あり
+
+### 参照Docs（一次情報）
+- [公式Docs URL + 版/日付]
+- [リリースノート/コミット]
+- [既存実装リンク]
+
+### 主要リスク（最大3）
+1. [リスク]（発生確度：High/Med/Low）→ 代替案: [Plan B]
+2. [リスク]
+3. [リスク]
+
+### 測定方法
+- [合否判定の具体的手段]
+- [ロールバック手順]
+```
+
+#### フェーズ 2: BUILD（実装・自動テスト）
+
+**入力**: PLAN
+**出力**: 以下を含むBUILD成果物
+
+```
+## BUILD RESULT
+
+### 実装内容
+- ファイル A: [変更内容]
+- ファイル B: [変更内容]
+
+### git diff
+[標準的なdiff形式、または patch ファイル]
+
+### テスト結果
+- Unit: [テスト数] / [成功数] ✅
+- Integration: [テスト数] / [成功数] ✅
+- Manual: [確認内容] ✅
+
+### 品質ゲート結果
+- lint: ✅ OK
+- type-check: ✅ OK
+- security: ✅ OK / ⚠️ 注意 / ❌ NG
+- license: ✅ OK
+
+### オープン質問（仕様疑義があれば）
+- Q1: [質問]
+- Q2: [質問]
+
+### 再現手順
+```bash
+npm install
+npm run build
+npm run test
+```
+
+### 予想される次のステップ
+- [修正が必要な場合の内容]
+- [採用時の次タスク]
+```
+
+#### フェーズ 3: REVIEW（自己レビュー）
+
+**入力**: BUILD成果物
+**出力**: REVIEW判定 + 修正指示
+
+```
+## REVIEW DECISION
+
+### 設計整合性
+- 元の PLAN と一致しているか: ✅ / ❌
+- スコープの逸脱: ✅ なし / ❌ [逸脱内容]
+
+### 品質ゲート判定
+- 全ゲート合格: ✅ YES / ❌ NO [NG項目]
+
+### 差分最小性
+- 必要最小限か: ✅ / ❌ [削除可能な変更]
+
+### 採否判定
+- 【採用】- そのままmerge可能
+- 【軽微修正で採用】- 以下の修正後adopt:
+  - [ ] 修正1
+  - [ ] 修正2
+- 【差し戻し】- 再検討が必要：
+  - 理由: [具体的な理由]
+  - 新PLAN: [方針]
+
+### ロールバック手順
+```bash
+git revert [commit-id]
+# または
+git reset --hard [previous-commit]
+```
+```
+
+#### フェーズ 4: APPLY
+
+**決定内容**:
+- ✅ **採用** → DOC記録 → commit & push → 次サイクル開始
+- ⚠️ **軽微修正で採用** → 修正実施 → 再REVIEW → APPLY
+- ❌ **差し戻し** → 新PLAN作成 → BUILD再実施
+
+---
+
+### 2.3 タイムボックス・粒度
+
+- **1サイクル**: 60–120分 目安
+- **1コミット**: 1目的原則（複合変更を避ける）
+- **粒度**: 1つのrevertで戻せるサイズ
+
+### 2.4 受入基準テンプレ（カスタマイズ例）
+
+```
+### 受入基準
+- **機能**: [仕様URL]の要件を実装・テスト済み
+- **品質**:
+  - lint: ✅ Green
+  - type: ✅ Green
+  - unit test: 主要ケース Green + カバレッジ +5%
+- **性能**: p95 < 200ms @ 標準負荷
+- **互換性**: 公開IF破壊なし or Majorバンプ合意済み
+- **運用**: コマンド再現可能 / ロールバック手順明記
+```
+
+---
+
+## 3) 作業ログ管理ルール（継続性の確保）
+
+### 3.1 STATUS.md 更新ルール【最優先】
+
+**更新タイミング**:
+- プロジェクト開始時に初期化
+- 主要コンポーネント完成度に変化があるとき
+- 開発フェーズが切り替わるとき
+- **新しいセッション開始前（現状確認）**
+
+**STATUS.md の内容**:
+
+```markdown
+# プロジェクト: [プロジェクト名]
+
+## ステータス概要（3行）
+- 現在地: [フェーズ]
+- 完成度: [%]
+- 最大課題: [1行]
+
+## コンポーネント完成度
+
+| コンポーネント | 完成度 | ステータス | 最終更新 |
+|-------------|--------|-----------|--------|
+| 基本構造 | 100% | ✅ 完了 | YYYY-MM-DD |
+| 機能A | 75% | 🔄 実装中 | YYYY-MM-DD |
+| テスト | 50% | 🔲 未着手 | - |
+| ドキュメント | 60% | 🔄 作成中 | YYYY-MM-DD |
+
+## 最近の主要変更
+- YYYY-MM-DD: [変更内容]
+- YYYY-MM-DD: [変更内容]
+
+## 次のステップ
+1. [タスク1]
+2. [タスク2]
+3. [タスク3]
+
+## ブロッカー / 未解決事項
+- [Issue1] → 予定解決日: YYYY-MM-DD
+- [Issue2] → 検討中
+
+---
+**最終更新**: YYYY-MM-DD HH:MM
+```
+
+### 3.2 タイムライン式作業ログ（LOG.md）
+
+**更新タイミング**: 編集・実装のたびに必ず更新
+**形式**: タイムライン形式（日付＋時刻でセクション分け）
+
+```markdown
+# 開発ログ
+
+### 2025-01-15 14:30 - ユーザー認証機能 実装完了 ✅
+
+#### 実施作業
+- `src/auth/` ディレクトリ作成
+- JWT認証ロジック実装
+- ユニットテスト追加（カバレッジ +8%）
+
+#### 完成したもの
+- ✅ ログイン機能
+- ✅ トークン検証
+- ✅ エラーハンドリング
+
+#### ステータス
+- ✅ 実装完了
+- ✅ テスト合格
+- 🔲 E2Eテスト（次回タスク）
+
+#### 備考
+- JWT秘密鍵は環境変数に移行
+- ロールバック: `git revert abc1234`
+
+#### 次回開始時の指針
+- 次: E2Eテスト追加（予定時間: 60分）
+- ブロッカーなし
+
+---
+
+### 2025-01-15 10:15 - DB接続テスト 🔄 中断
+
+#### 実施作業
+- `src/db/connection.ts` 実装開始
+- エラー: PostgreSQL接続タイムアウト
+
+#### 未解決の問題
+- ❌ コネクションプール設定不適切
+- 原因: [調査結果]
+- 次回対応: リトライロジック追加
+
+#### 次回再開時の指針
+- リトライのコード例を `docs/db-retry.md` に記載
+- 予定時間: 90分
+```
+
+### 3.3 ログ記録の実例フォーマット
+
+```markdown
+### YYYY-MM-DD HH:MM - [タスク名] [ステータス記号]
+
+#### 実施作業
+- [変更内容1]
+- [変更内容2]
+- [ファイル追加/削除]
+
+#### 完成したもの
+- ✅ [機能1]
+- ✅ [機能2]
+
+#### ステータス
+- ✅ 完了
+- 🔄 作業中
+- 🔲 未着手
+- ❌ 未解決
+
+#### 品質ゲート結果
+- lint: ✅ OK
+- test: ✅ 12/12 Green
+- type: ✅ OK
+
+#### 未解決の問題 / ブロッカー
+- ❌ [Issue]: [詳細] → 予定解決: YYYY-MM-DD
+- ⚠️ [Caution]: [詳細]
+
+#### コミット情報
+- コミットID: `abc1234d`
+- ロールバック: `git revert abc1234`
+
+#### 次回開始時の指針
+- 次のタスク: [タスク名]
+- 予定時間: XX分
+- 継続的な注意点: [注記]
+```
+
+### 3.4 ステータス記号
+
+| 記号 | 意味 | 使用時機 |
+|------|------|---------|
+| ✅ | 完了 | タスク完成、テスト合格 |
+| 🔄 | 作業中 | 進行中、後続あり |
+| 🔲 | 未着手 | 今後のタスク |
+| ❌ | 未解決/失敗 | エラー、ブロック中 |
+| ⚠️ | 注意 | リスク、要観察 |
+
+### 3.5 ログ管理の運用ルール
+
+- **小さな変更でも記録**: 1ファイル編集でもログ更新を徹底
+- **時系列の一貫性**: 作業順に追記、過去エントリは編集しない
+- **検索可能性**: キーワード（機能名・ファイル名・エラー内容）を明記
+- **可読性重視**: 見出し・箇条書き・ステータス記号を活用
+
+---
+
+## 4) ディレクトリ構造（テンプレート）
+
+```
+[project-root]/
+├── STATUS.md ⭐ 最優先確認ファイル
+├── CLAUDE.md（このファイル）
+├── DOCS_INDEX.md（ドキュメント案内）
+│
+├── log/
+│   └── LOG.md ⭐ タイムライン式開発ログ
+│
+├── docs/
+│   ├── architecture.md（アーキテクチャ）
+│   ├── api.md（API仕様）
+│   ├── setup.md（セットアップ手順）
+│   └── [その他ドキュメント]
+│
+├── src/
+│   ├── index.ts
+│   ├── components/
+│   ├── utils/
+│   └── ...
+│
+├── tests/
+│   ├── unit/
+│   ├── integration/
+│   └── ...
+│
+├── .env.example
+├── package.json
+├── tsconfig.json
+├── jest.config.js
+└── .gitignore
+```
+
+---
+
+## 5) 実装フロー（PLAN → BUILD → REVIEW → APPLY の具体例）
+
+### 例: 「ユーザー認証機能の追加」
+
+#### Step 1: PLAN
+
+```
+## PLAN: ユーザー認証機能（JWT）の実装
+
+### 目的
+ユーザーのログイン・ログアウト機能を実装し、
+API エンドポイントを JWT で保護する
+
+### 最小スコープ
+- [ ] JWT ライブラリ統合（jsonwebtoken）
+- [ ] ログイン エンドポイント作成（POST /auth/login）
+- [ ] トークン検証ミドルウェア実装
+- [ ] 主要ケースのユニットテスト
+- [ ] 環境変数管理（秘密鍵）
+
+### 受入基準
+- 機能: [Docs: JWT認証仕様](https://....) を満たす
+- 品質: lint OK / type OK / unit test Green
+- 性能: ログイン応答時間 < 100ms
+- 互換性: 既存API との breaking change なし
+
+### 参照Docs
+- https://github.com/auth0/node-jsonwebtoken (v9.0+)
+- [既存認証パターン](./docs/auth-pattern.md)
+
+### 主要リスク
+1. 秘密鍵の漏洩 → Plan B: 環境変数化、ローテーション仕組み
+2. トークン有効期限の管理 → Plan B: リフレッシュトークン実装
+3. 既存ユーザー互換性 → Plan B: 段階的導入 + fallback
+
+### 測定方法
+- ユニットテスト全て Green
+- `npm run lint` / `npm run type-check` OK
+- 手動テスト: curl で /auth/login 確認
+```
+
+#### Step 2: BUILD
+
+```
+## BUILD RESULT
+
+### 実装内容
+- src/auth/jwt.ts: JWT処理関数（sign/verify）
+- src/routes/auth.ts: /auth/login エンドポイント
+- src/middleware/authGuard.ts: トークン検証ミドルウェア
+- tests/auth.test.ts: 12個のユニットテスト
+- .env.example: JWT_SECRET 追加
+
+### git diff
+[差分内容...]
+
+### テスト結果
+- Unit: 12/12 ✅ Green
+- Manual: /auth/login → token取得確認 ✅
+
+### 品質ゲート結果
+- lint: ✅ OK (eslint)
+- type-check: ✅ OK (tsc)
+- security: ✅ OK (no hardcoded secrets)
+
+### 再現手順
+npm run build
+npm run test
+npm run start
+# 別ウィンドウで:
+curl -X POST http://localhost:3000/auth/login -d '{"user":"test"}'
+```
+
+#### Step 3: REVIEW
+
+```
+## REVIEW DECISION
+
+### 設計整合性
+- 元の PLAN との一致: ✅ YES
+- スコープの逸脱: ✅ なし
+
+### 品質ゲート判定
+- 全ゲート合格: ✅ YES
+
+### 採否判定
+【採用】全ての基準をクリアしています。
+```
+
+#### Step 4: APPLY
+
+```
+✅ APPROVED - Merge & Commit
+
+commit abc1234d "feat: JWT認証機能の実装
+
+- JWT sign/verify ロジック実装
+- /auth/login エンドポイント追加
+- authGuard ミドルウェア実装
+- ユニットテスト 12個追加
+
+Refs: PLAN 2025-01-15-auth
+Tests: 12/12 Green
+"
+```
+
+#### Step 5: DOC & NEXT
+
+```markdown
+### 2025-01-15 15:45 - JWT認証機能 実装完了 ✅
+
+#### 実施作業
+- JWT認証ロジック実装
+- ログインエンドポイント作成
+- トークン検証ミドルウェア実装
+- ユニットテスト 12個追加
+
+#### ステータス
+- ✅ 実装完了
+- ✅ テスト合格
+- ✅ Commit: abc1234d
+
+#### 次回開始時の指針
+- 次: E2Eテスト追加（ユーザーフロー全体検証）
+- 予定時間: 60分
+- 注意: 環境変数 JWT_SECRET は .env に設定を忘れずに
+```
+
+---
+
+## 6) トラブルシューティング・アンチパターン
+
+### 6.1 避けるべきパターン
+
+| ❌ アンチパターン | ✅ 改善案 |
+|-------------|---------|
+| 仕様未確定のまま大きな実装に着手 | 必ず PLAN で仕様確認・スコープ確定 |
+| 受入基準なしのレビュー | PLAN 時点で受入基準を明確化 |
+| 差分未提示 / コミットメッセージ不備 | `git diff` + `git show` で常に確認 |
+| セキュリティ/ライセンス無視 | 品質ゲートに security スキャン追加 |
+| 証跡欠落（リンク/版/日付なし） | 一次情報リンク + 日付を必ず記載 |
+| 複合変更を1コミットに | 1目的 = 1コミット 原則 |
+| ログ更新を怠る | セッション終了時に必ず LOG.md 更新 |
+
+### 6.2 よくある失敗と対策
+
+**失敗1: 大きな機能を1サイクルで完結させようとする**
+- ❌ 100行のコード + 多数のテスト + ドキュメント
+- ✅ 20–30行 × 複数サイクル に分割
+
+**失敗2: テスト後に「やっぱり仕様変更」**
+- ❌ 受入基準なしのまま実装開始
+- ✅ PLAN時点で受入基準を明確化・検証
+
+**失敗3: ロールバック手順が不明**
+- ❌ 「git reset...」（どれだ？）
+- ✅ コミットID・コマンド・復帰手順を記録
+
+**失敗4: 新しいセッション開始時、前の状況が分からない**
+- ❌ ログがない、STATUS.md が古い
+- ✅ セッション終了時に LOG.md + STATUS.md を更新
+
+---
+
+## 7) チェックリスト（各フェーズ）
+
+### 7.1 PLAN チェックリスト
+
+- [ ] 目的が1行で言えるか
+- [ ] スコープが3–5項目か（多すぎないか）
+- [ ] 受入基準が具体的か（テスト可能か）
+- [ ] 参照Docs（一次情報）を記載したか
+- [ ] リスクを最大3点に限定したか
+- [ ] ロールバック手順が明記されているか
+
+### 7.2 BUILD チェックリスト
+
+- [ ] 実装内容がスコープ内か
+- [ ] テストコード を書いたか
+- [ ] lint / type-check を実行したか
+- [ ] 再現手順を記載したか
+- [ ] git diff が明確か
+- [ ] ブロッカー/疑義は「open_questions」で明示したか
+
+### 7.3 REVIEW チェックリスト
+
+- [ ] PLAN と一致しているか
+- [ ] スコープの逸脱はないか
+- [ ] 品質ゲート全て合格か
+- [ ] 差分は最小か（削除できる変更はないか）
+- [ ] ロールバック手順は実行可能か
+- [ ] 採否判定を明記したか
+
+### 7.4 APPLY チェックリスト
+
+- [ ] コミットメッセージは簡潔・明確か
+- [ ] コミットID を LOG.md に記載したか
+- [ ] STATUS.md を更新したか
+- [ ] 次のタスクを定義したか
+- [ ] ブロッカーはないか
+
+---
+
+## 8) コマンド集（よく使う操作）
+
+```bash
+# 状況確認
+git status
+git log --oneline -5
+
+# 差分確認
+git diff HEAD
+git diff HEAD~1
+
+# テスト実行
+npm run test
+npm run test -- --coverage
+
+# 品質ゲート
+npm run lint
+npm run type-check
+npm run security-audit
+
+# ロールバック
+git revert <commit-id>
+git reset --hard HEAD~1
+
+# ログ確認
+tail -50 log/LOG.md
+cat STATUS.md
+```
+
+---
+
+## 9) テンプレート集
+
+### 9.1 PLAN テンプレ（コピー＆ペースト用）
+
+```
+## PLAN: [タスク名]
+
+### 目的
+[1行]
+
+### 最小スコープ
+- [ ] タスク1
+- [ ] タスク2
+- [ ] タスク3
+
+### 受入基準
+- **機能**:
+- **品質**:
+- **性能**:
+- **互換性**:
+
+### 参照Docs
+- [URL + 版/日付]
+
+### 主要リスク（最大3）
+1. [リスク] → Plan B: [代替案]
+
+### 測定方法
+- [具体的な手段]
+```
+
+### 9.2 BUILD テンプレ
+
+```
+## BUILD RESULT
+
+### 実装内容
+- ファイルA: [変更]
+- ファイルB: [変更]
+
+### git diff
+[差分]
+
+### テスト結果
+- Unit: [数]/[数] ✅
+- Manual: [確認内容] ✅
+
+### 品質ゲート
+- lint: ✅ OK
+- type: ✅ OK
+
+### 再現手順
+[コマンド]
+```
+
+### 9.3 LOG エントリテンプレ
+
+```
+### YYYY-MM-DD HH:MM - [タスク名] [ステータス]
+
+#### 実施作業
+- [変更1]
+
+#### ステータス
+- ✅ 完了 / 🔄 中断 / ❌ 失敗
+
+#### 品質ゲート結果
+- lint: ✅
+- test: ✅
+
+#### 次回開始時の指針
+- 次のタスク: [タスク]
+- 予定時間: XX分
+```
+
+---
+
+## 最終的なルール（必読）
+
+✅ **作業を始める前**に STATUS.md + LOG.md の最新を確認
+✅ **すべての作業** を PLAN → BUILD → REVIEW → APPLY のループで実行
+✅ **毎セッション終了時** に LOG.md + STATUS.md を更新
+✅ **参照情報** には必ず一次情報・URL・日付・バージョンを添付
+✅ **小さく回す** — 1サイクル 60–120分、1目的、1コミット
+✅ **再現可能** — ロールバック・コマンド・再現手順を常に明記
+
+**これらのルールを守ることで、確実で透明性のある開発が実現します。**
+
+---
+
+**このファイルは各プロジェクトのルートに配置し、必要に応じてカスタマイズしてください。**

V1.7.1/Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# 依存パッケージインストール
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# アプリケーションコードをコピー
+COPY . .
+
+# ポート公開
+EXPOSE 7860
+
+# 起動コマンド
+CMD ["python", "app.py"]

V1.7.1/README.md

@@ -0,0 +1,78 @@
+---
+title: 超天才クイズ V3
+emoji: 🧠
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# 超天才クイズ V3
+
+中学受験対策4択クイズアプリ - Gemini AI搭載版
+
+## 概要
+
+このアプリは、中学受験を目指す生徒向けの4択クイズアプリです。Google Gemini APIを使用して、高品質な問題を自動生成します。
+
+## 主な機能
+
+- **4教科対応**: 国語・算数・理科・社会
+- **AI問題生成**: Gemini APIによる自動問題生成
+- **進捗管理**: ユーザーごとの学習履歴・統計
+- **評価フィードバック**: AIによる学習アドバイス
+
+## アーキテクチャ（v3）
+
+```
+Frontend (React+Tailwind)
+    ↓
+HF Spaces (FastAPI + Gemini直接)
+    ↓
+GAS API (Google Sheets操作)
+    ↓
+Google Sheets (データ永続化)
+```
+
+### v1からの改善点
+- Difyを排除、Gemini APIを直接呼び出し
+- GASはシート操作のみに限定（タイムアウト回避）
+- HF Spacesで長時間処理に対応
+
+## 環境変数
+
+このアプリは以下の環境変数が必要です（HF SpacesのSecretsで設定）:
+
+```
+GEMINI_API_KEY=xxx      # Google Gemini API Key
+GAS_API_URL=xxx         # Google Apps Script Web App URL
+```
+
+## 技術スタック
+
+- **Backend**: FastAPI (Python 3.11)
+- **AI**: Google Gemini API
+- **Frontend**: Vanilla JS + Tailwind CSS
+- **Database**: Google Sheets (via GAS API)
+- **Deployment**: HuggingFace Spaces (Docker SDK)
+
+## ローカル開発
+
+```bash
+# 依存関係インストール
+pip install -r requirements.txt
+
+# 環境変数設定
+cp .env.example .env
+# .envファイルを編集してAPIキーを設定
+
+# サーバー起動
+python app.py
+```
+
+アプリは http://localhost:7860 で起動します。
+
+## License
+
+MIT

V1.7.1/RECOVERY.md

@@ -0,0 +1,42 @@
+# v1.7.1 復旧手順書
+
+## バージョン情報
+- **バージョン**: v1.7.1
+- **リリース日**: 2025-12-21
+- **タグ**: v1.7.1
+- **コミット**: 15488d0
+
+## 新機能
+- 1科目3分（180秒）の制限時間
+- カウントダウンタイマー表示（ヘッダー右上）
+- 時間切れダイアログ → 未回答は不正解として処理
+- 各問題の回答時間（time_taken_seconds）をGASに記録
+- 各教科10問に制限（Gemini過剰生成対策）
+
+## 復旧手順
+
+### 方法1: Gitタグから復旧
+```bash
+cd /path/to/project
+git checkout v1.7.1
+```
+
+### 方法2: このフォルダから復旧
+```bash
+# 1. 現在の作業をバックアップ
+cp -r /path/to/project /path/to/project_backup
+
+# 2. このフォルダの内容をコピー
+cp -r V1.7.1/* /path/to/project/
+```
+
+## GAS情報
+- **Version**: @42 (v1.6.15から変更なし)
+- **URL**: `https://script.google.com/macros/s/AKfycbw52gHnVanyvr91As9BhXd2Tv-2bYjwns8dR-6tt59FR3K2xfktMLoiTPsEAIffJ5ED/exec`
+
+## 動作確認済み項目
+- [x] タイマー表示・カウントダウン
+- [x] 時間切れダイアログ
+- [x] 未回答の不正解処理
+- [x] time_spent記録（Answersシート）
+- [x] 各教科10問制限

V1.7.1/STATUS.md

@@ -0,0 +1,125 @@
+# プロジェクト: 超天才クイズ v1.7.0
+
+## ステータス概要
+- **現在地**: v1.7.1 制限時間機能 修正完了 → E2Eテスト待ち
+- **完成度**: 98%
+- **最大課題**: 問題数・タイマー動作確認
+
+## v1.7.1 修正内容
+
+### E2Eテスト結果（2025-12-21）
+- ✅ タイマー表示・カウントダウン正常動作
+- ✅ 時間切れダイアログ正常表示
+- ✅ 未回答の不正解処理
+- ⚠️ 制限時間5分は長い → 3分に短縮
+- ⚠️ 算数27問生成 → 10問制限のスライス処理追加
+
+### v1.7.1 修正
+1. **制限時間短縮**: 5分 → 3分（180秒）に変更
+2. **問題数制限**: Geminiが10問超生成時にスライスで10問に制限
+
+## v1.7.0 新機能: 制限時間
+
+### 実装内容
+- 1科目あたり3分（180秒）の制限時間
+- カウントダウンタイマーをヘッダー右上に常時表示
+- 時間切れ時: ダイアログ表示 → OK → 未回答は不正解 → 結果画面へ
+- 各問題の回答時間（time_taken_seconds）をGASに記録
+
+### 変更ファイル
+- `static/js/components.js`: App, SubjectSelectScreen, QuizScreen修正
+
+### GAS変更
+- なし（既存の`time_taken_seconds`インフラを活用）
+
+---
+
+## v1.6.15 修正内容
+
+### USAGE_COUNT抽出時更新 ✅
+- **問題**: v1.6.14でもUSAGE_COUNTが更新されなかった
+- **原因**: Gemini生成結果に`answer_id`が含まれないため、app.pyからの更新呼び出しが空リストになっていた
+- **修正**:
+  - GAS: `get_questions_by_genre_config`で問題抽出時にUSAGE_COUNT+1
+  - app.py: 不要な`update_usage_count`呼び出しを削除
+- **GAS Version**: @42
+
+### v1.6.13 累積成績問題修正 ✅
+- app.pyの`get_statistics`をGASの新形式に対応
+- **コミット**: bd111b9
+
+## 機能一覧
+
+| 項目 | ステータス | 備考 |
+|------|-----------|------|
+| ログイン | ✅ OK | 正常動作 |
+| 問題生成 | ✅ OK | Gemini API連携 |
+| 正解判定 | ✅ OK | 動作確認済み |
+| SCORE表示 | ✅ OK | 正常表示 |
+| 累積成績 | ✅ OK | v1.6.13で修正 |
+| **均等出題** | ✅ OK | v1.6.14で実装 |
+
+## デプロイ情報
+
+| 項目 | 値 |
+|------|-----|
+| **HF Space** | leave-everything/ChoTensai_V3 |
+| **GAS Version** | @42（v1.6.15） |
+| **GAS URL** | `https://script.google.com/macros/s/AKfycbw52gHnVanyvr91As9BhXd2Tv-2bYjwns8dR-6tt59FR3K2xfktMLoiTPsEAIffJ5ED/exec` |
+| **Spreadsheet ID** | `10JLP5ds2CNDOEYTxEzDyY82dErbD-InkTeuyzS_w_3U` |
+
+## コンポーネント完成度
+
+| コンポーネント | 完成度 | ステータス | 備考 |
+|-------------|--------|-----------|------|
+| 基本構造 | 100% | ✅ 完了 | - |
+| 問題生成(Dify) | 100% | ✅ 完了 | temperature=1.0統一済み |
+| GAS API | 100% | ✅ 完了 | SCORE問題修正済み |
+| Backend(app.py) | 100% | ✅ 完了 | v1.6.13で累積成績修正 |
+| フロントエンド | 100% | ✅ 完了 | - |
+| E2Eテスト | 100% | ✅ 完了 | 全項目合格 |
+
+## 作業環境
+
+**唯一の作業フォルダ**:
+```
+/mnt/c/Users/tomo2/OneDrive/デスクトップ/開発/HuggingFace/超天才クイズv3/
+```
+
+## 次のステップ
+
+1. **運用開始**
+   - 全機能が正常動作することを確認済み
+   - ユーザーからのフィードバック収集
+
+2. **今後の改善候補**（優先度: 低）
+   - パフォーマンス最適化
+   - UI/UX改善
+
+## 最新の変更履歴
+
+- **2025-12-21**: v1.6.15 STABLEバックアップ作成（V1.6.15フォルダ）
+- **2025-12-21**: 今後の構想ドキュメント作成（docs/FUTURE_VISION.md）
+- **2025-12-21**: v1.6.15リリース（USAGE_COUNT抽出時更新）
+- **2025-12-21**: v1.6.14リリース（USAGE_COUNT均等出題機能）
+- **2025-12-21**: v1.6.13リリース（累積成績問題修正）
+- **2025-12-20**: v1.6.12 E2Eテスト実施（SCORE表示正常化確認）
+- **2025-12-20**: v1.6.11リリース（SCORE問題修正）
+
+## バックアップ
+
+| フォルダ | バージョン | 説明 |
+|---------|-----------|------|
+| `V1.6.15/` | v1.6.15 STABLE | 完全復旧可能なバックアップ（RECOVERY.md含む） |
+
+## 今後の構想
+
+詳細は `docs/FUTURE_VISION.md` を参照
+
+| 区分 | 内容 |
+|------|------|
+| 【A】本体改善 | ユーザー単位管理、制限時間設定 |
+| 【B】派生サービス | 問題配信、ランキング、クラス制 |
+
+---
+**最終更新**: 2025-12-21

V1.7.1/app.py

@@ -0,0 +1,689 @@
+"""
+超天才クイズ v3 - FastAPI Backend
+HuggingFace Spaces Docker SDK
+
+Difyを排除し、Gemini APIを直接呼び出すアーキテクチャ
+"""
+
+import os
+import json
+import logging
+import asyncio
+from pathlib import Path
+from fastapi import FastAPI, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import List, Optional, Dict
+from dotenv import load_dotenv
+
+# .envファイルを読み込み
+load_dotenv()
+
+# サービス
+from src.services.gemini_service import GeminiService
+from src.services.gas_client import GASClient, extract_exclude_keywords
+# KnowledgeService削除 - QuestionDB駆動に移行（v1.6.0）
+from src.services.auth_service import AuthService
+from src.services.questiondb_service import QuestionDBService
+
+# ロギング設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# FastAPIアプリ
+app = FastAPI(
+    title="超天才クイズ v3 API",
+    description="中学受験対策4択クイズ - Gemini直接統合版",
+    version="3.0.0"
+)
+
+# サービス初期化
+gemini_service = GeminiService()
+gas_client = GASClient()
+# KnowledgeService削除 - QuestionDB駆動に移行（v1.6.0）
+questiondb_service = QuestionDBService(gas_client=gas_client, gemini_service=gemini_service)
+
+
+# =============================================================================
+# リクエスト/レスポンスモデル
+# =============================================================================
+
+class RegisterUserRequest(BaseModel):
+    username: str
+    password: str
+    invite_code: str
+
+class StartSessionRequest(BaseModel):
+    user_id: str
+    subjects: List[str]
+
+class GenerateQuestionsRequest(BaseModel):
+    session_id: str
+    subjects: List[str]
+    user_id: Optional[str] = None  # v1.4.0: 要約・ジャンルカウント取得用
+
+class Answer(BaseModel):
+    question_id: str
+    selected_answer: int
+    user_answer: Optional[int] = None  # GAS APIに渡す用（数値型で統一）
+    correct_answer: Optional[int] = None  # GAS APIに渡す用
+    subject: Optional[str] = None
+    category: Optional[str] = None
+    time_taken_seconds: Optional[int] = 0
+
+class SubmitAnswersRequest(BaseModel):
+    session_id: str
+    answers: List[Answer]
+
+class GetStatisticsRequest(BaseModel):
+    user_id: str
+    subjects: Optional[List[str]] = None
+
+class GetEvaluationRequest(BaseModel):
+    session_id: str
+    subjects: Optional[List[str]] = None
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+# =============================================================================
+# バックグラウンドタスク
+# =============================================================================
+
+async def background_summary_generation(
+    session_id: str,
+    validated_by_subject: Dict[str, List[Dict]]
+):
+    """
+    バックグラウンドでサマリー生成→GAS保存
+
+    Args:
+        session_id: セッションID
+        validated_by_subject: 教科別問題辞書
+    """
+    try:
+        logger.info(f"background_summary_generation: Starting for session_id={session_id}")
+
+        # 各教科のサマリーを生成
+        for subject, questions in validated_by_subject.items():
+            if not questions:
+                continue
+
+            try:
+                # Geminiでサマリー生成
+                logger.info(f"background_summary_generation: Generating summary for {subject} ({len(questions)} questions)")
+                summary_data = await gemini_service.generate_summary(subject, questions)
+
+                # GASに保存
+                logger.info(f"background_summary_generation: Saving summary for {subject} to GAS")
+                save_result = await gas_client.save_summary(
+                    session_id=session_id,
+                    subject=subject,
+                    summary_data=summary_data
+                )
+
+                if save_result.get("success"):
+                    logger.info(f"background_summary_generation: Summary saved successfully for {subject}")
+                else:
+                    logger.warning(f"background_summary_generation: Failed to save summary for {subject}: {save_result}")
+
+            except Exception as subject_error:
+                logger.error(f"background_summary_generation: Error processing {subject}: {subject_error}")
+                # 1教科の失敗は他に影響させない
+                continue
+
+        logger.info(f"background_summary_generation: Completed for session_id={session_id}")
+
+    except Exception as e:
+        logger.error(f"background_summary_generation: Fatal error for session_id={session_id}: {e}")
+        # バックグラウンドタスクなので例外は握りつぶす
+
+
+# =============================================================================
+# APIエンドポイント
+# =============================================================================
+
+@app.get("/api/health")
+async def health_check():
+    """ヘルスチェック"""
+    return {
+        "status": "healthy",
+        "version": "3.0.0",
+        "services": {
+            "gemini": gemini_service.is_available(),
+            "gas": gas_client.is_available(),
+            "questiondb": True  # QuestionDB駆動に移行（v1.6.0）
+        }
+    }
+
+
+@app.post("/api/register_user")
+async def register_user(request: RegisterUserRequest):
+    """ユーザー登録"""
+    try:
+        # 招待コード検証
+        valid_invite_code = os.environ.get("INVITE_CODE", "")
+
+        if not valid_invite_code:
+            logger.error("register_user: INVITE_CODE environment variable is not set")
+            raise HTTPException(status_code=403, detail="招待コードが設定されていません")
+
+        if request.invite_code != valid_invite_code:
+            logger.warning(f"register_user: Invalid invite code attempt for user '{request.username}'")
+            raise HTTPException(status_code=403, detail="招待コードが無効です")
+
+        logger.info(f"register_user: Invite code verified for user '{request.username}'")
+
+        # パスワードをハッシュ化
+        hashed_password = AuthService.hash_password(request.password)
+        logger.info(f"register_user: Password hashed for user '{request.username}'")
+
+        # GAS連携処理（ハッシュ化されたパスワードを渡す）
+        result = await gas_client.register_user(request.username, hashed_password)
+
+        # 既存ユーザーの場合はエラー
+        if result.get("data", {}).get("is_new") == False:
+            raise HTTPException(status_code=409, detail="このユーザー名は既に登録されています")
+
+        return result
+    except HTTPException:
+        # HTTPExceptionはそのまま再送出
+        raise
+    except Exception as e:
+        logger.error(f"register_user error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/login")
+async def login(request: LoginRequest):
+    """ログイン"""
+    try:
+        # GASからユーザー情報取得
+        result = await gas_client.login(request.username)
+
+        # ユーザーが見つからない場合
+        if not result.get("found"):
+            logger.warning(f"login: User not found: '{request.username}'")
+            raise HTTPException(status_code=401, detail="ユーザー名またはパスワードが正しくありません")
+
+        data = result.get("data", {})
+        stored_hash = data.get("password_hash")
+
+        # パスワード未設定の既存ユーザー（v1.0からの移行ユーザー）
+        if not stored_hash:
+            logger.info(f"login: User '{request.username}' needs password migration")
+            raise HTTPException(
+                status_code=403,
+                detail="パスワードが未設定です。新規登録画面からパスワードを設定してください。"
+            )
+
+        # パスワード検証
+        if not AuthService.verify_password(request.password, stored_hash):
+            logger.warning(f"login: Invalid password for user '{request.username}'")
+            raise HTTPException(status_code=401, detail="ユーザー名またはパスワードが正しくありません")
+
+        logger.info(f"login: User '{request.username}' logged in successfully")
+
+        return {
+            "success": True,
+            "data": {
+                "user_id": data.get("user_id"),
+                "username": data.get("username")
+            }
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"login error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/start_session")
+async def start_session(request: StartSessionRequest):
+    """セッション開始"""
+    try:
+        result = await gas_client.start_session(request.user_id, request.subjects)
+        return result
+    except Exception as e:
+        logger.error(f"start_session error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/generate_questions")
+async def generate_questions(request: GenerateQuestionsRequest):
+    """問題生成 - QuestionDB駆動（高速版）
+
+    v1.6.0: QuestionDB駆動に移行
+    - Before: Gemini API 2回呼び出し（問題生成+検証）→ 20-60秒
+    - After: QuestionDB取得 + Gemini 1回（選択肢のみ）→ 2-5秒
+    """
+    try:
+        logger.info(f"generate_questions: Starting QuestionDB-driven generation for {len(request.subjects)} subjects: {request.subjects}")
+
+        # Phase 0: 統計・要約取得（優先ジャンル・除外ID用）
+        priority_genres = None
+        exclude_ids = None
+
+        if request.user_id:
+            try:
+                # 統計取得（ジャンルカウント含む）
+                stats_result = await gas_client.get_statistics(request.user_id, request.subjects)
+                priority_genres = stats_result.get("data", {}).get("priority_genres", {})
+                logger.info(f"generate_questions: Got priority_genres for {len(priority_genres)} subjects")
+
+                # 要約取得（重複問題除外用）
+                summaries_result = await gas_client.get_question_summaries(request.user_id, limit=5)
+                exclude_keywords = extract_exclude_keywords(summaries_result.get("data", summaries_result))
+                # TODO: exclude_keywords から exclude_ids に変換する処理（将来実装）
+                logger.info(f"generate_questions: Got {len(exclude_keywords)} exclude keywords")
+            except Exception as e:
+                logger.warning(f"generate_questions: Failed to get stats/summaries (non-fatal): {e}")
+
+        # Phase 1: QuestionDBから問題取得 + 選択肢生成
+        logger.info("generate_questions: Fetching questions from QuestionDB")
+        questions_by_subject = await questiondb_service.get_questions_from_db(
+            subjects=request.subjects,
+            count_per_subject=10,
+            priority_genres=priority_genres,
+            exclude_ids=exclude_ids
+        )
+
+        # 取得結果の確認
+        total_generated = sum(len(qs) for qs in questions_by_subject.values())
+        logger.info(f"generate_questions: Retrieved {total_generated} questions from DB")
+
+        # 取得失敗の確認
+        failed_subjects = [s for s in request.subjects if len(questions_by_subject.get(s, [])) == 0]
+        if len(failed_subjects) == len(request.subjects):
+            raise HTTPException(
+                status_code=500,
+                detail="QuestionDatabaseから問題を取得できませんでした。もう一度お試しください。"
+            )
+
+        # Phase 2: 並列保存
+        async def save_for_subject(subject: str, questions: list):
+            """教科ごとのGAS保存処理"""
+            saved = await gas_client.save_questions(
+                session_id=request.session_id,
+                subject=subject,
+                questions=questions
+            )
+            logger.info(f"generate_questions: Saved {len(saved)} questions for '{subject}'")
+            return {"subject": subject, "saved": saved}
+
+        save_tasks = [
+            save_for_subject(subject, questions)
+            for subject, questions in questions_by_subject.items()
+            if questions  # 空でない場合のみ保存
+        ]
+        save_results = await asyncio.gather(*save_tasks, return_exceptions=True)
+
+        # 教科名マッピング
+        subject_names = {
+            "jp": "国語",
+            "math": "算数",
+            "sci": "理科",
+            "soc": "社会"
+        }
+
+        # 保存結果を集約（元データ + question_id マージ）
+        all_questions = []
+        logger.info(f"generate_questions: Question save summary - total_subjects={len(save_results)}")
+        for idx, result in enumerate(save_results):
+            if isinstance(result, Exception):
+                logger.error(f"generate_questions: Save failed for task {idx}: {result}")
+            else:
+                subject = result.get("subject", "unknown")
+                saved = result.get("saved", [])
+                original = questions_by_subject.get(subject, [])  # 元のGemini生成データ
+
+                # question_id をマージして完全なデータを構築
+                for i, orig_q in enumerate(original):
+                    if i < len(saved):
+                        orig_q["question_id"] = saved[i].get("question_id")
+                    orig_q["subject"] = subject
+                    orig_q["subject_name"] = subject_names.get(subject, subject)
+
+                all_questions.extend(original)
+                logger.info(f"generate_questions: Saved summary - subject={subject}, saved_count={len(original)}")
+
+        logger.info(f"generate_questions: All questions saved - total_count={len(all_questions)}")
+
+        # Phase 3: usage_count更新
+        # v1.6.15: GAS側で抽出時に更新するため、ここでの呼び出しは不要
+        # （抽出時更新により、Gemini生成失敗時もカウントされるがシンプルさを優先）
+
+        # Phase 4: バックグラウンドでサマリー生成（UIレスポンスを待たせない）
+        asyncio.create_task(
+            background_summary_generation(
+                session_id=request.session_id,
+                validated_by_subject=questions_by_subject
+            )
+        )
+        logger.info(f"generate_questions: Background summary generation task created")
+
+        # レスポンス構築
+        response_data = {
+            "session_id": request.session_id,
+            "questions": all_questions,
+            "total_count": len(all_questions)
+        }
+
+        if failed_subjects:
+            response_data["warnings"] = {
+                "failed_subjects": failed_subjects,
+                "message": f"以下の教科で��題取得に失敗しました: {', '.join(failed_subjects)}"
+            }
+            logger.warning(f"generate_questions: Partial success - failed subjects: {failed_subjects}")
+
+        logger.info(f"generate_questions: Completed with {len(all_questions)} total questions")
+
+        return {
+            "success": True,
+            "data": response_data
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"generate_questions error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/submit_answers")
+async def submit_answers(request: SubmitAnswersRequest):
+    """解答送信"""
+    try:
+        result = await gas_client.submit_answers(
+            session_id=request.session_id,
+            answers=[a.model_dump() for a in request.answers]
+        )
+        logger.info(f"[submit_answers] GAS response: {result}")
+        return result
+    except Exception as e:
+        logger.error(f"submit_answers error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/get_statistics")
+async def get_statistics(request: GetStatisticsRequest):
+    """統計取得
+    
+    v1.6.13: GASからのcumulative/subjectsをそのまま使用するように修正
+    """
+    try:
+        result = await gas_client.get_statistics(
+            user_id=request.user_id,
+            subjects=request.subjects
+        )
+        
+        # GASレスポンスをフロントエンド期待形式に変換
+        if result.get("success"):
+            gas_data = result.get("data", {})
+            logger.debug(f"get_statistics: GAS response keys: {gas_data.keys()}")
+            
+            # v1.6.13: GASからの cumulative と subjects をそのまま使用
+            # GASは以下の形式で返す:
+            # {
+            #   "user_id": "...",
+            #   "subjects": [...],
+            #   "radar_chart": {...},
+            #   "cumulative": { "total_sessions", "total_questions", "total_correct", "overall_accuracy" }
+            # }
+            
+            gas_cumulative = gas_data.get("cumulative", {})
+            gas_subjects = gas_data.get("subjects", [])
+            
+            logger.debug(f"get_statistics: cumulative from GAS: {gas_cumulative}")
+            logger.debug(f"get_statistics: subjects count from GAS: {len(gas_subjects)}")
+            
+            # 教科名マッピング（GASにない場合のフォールバック用）
+            subject_names = {
+                "jp": "国語",
+                "math": "算数",
+                "sci": "理科",
+                "soc": "社会"
+            }
+            
+            # ジャンル名マッピング（CLAUDE.md準拠）
+            genre_names = {
+                # 国語
+                "JP01": "漢字・語彙（読み書き、四字熟語、慣用句、ことわざ）",
+                "JP02": "文法・言葉のきまり（品詞、敬語、文の成分、修飾関係）",
+                "JP03": "物語文読解（心情理解、場面把握、人物関係）",
+                "JP04": "説明文・論説文読解（要旨、段落構成、筆者の主張）",
+                "JP05": "随筆文読解（筆者の体験・感想の読み取り）",
+                "JP06": "詩・韻文（詩、短歌、俳句、表現技法）",
+                "JP07": "記述問題（理由説明、要約、意見記述）",
+                "JP08": "知識・文学史（作家、作品名、文学的常識）",
+                # 算数
+                "MA01": "計算",
+                "MA02": "数の性質",
+                "MA03": "割合・比",
+                "MA04": "速さ",
+                "MA05": "文章題（その他）",
+                "MA06": "平面図形",
+                "MA07": "立体図形",
+                "MA08": "場合の数・確率",
+                "MA09": "グラフ・表",
+                "MA10": "特殊算",
+                # 理科
+                "SC01": "力・運動",
+                "SC02": "電気",
+                "SC03": "光・音・熱",
+                "SC04": "物質の性質",
+                "SC05": "水溶液",
+                "SC06": "燃焼・化学変化",
+                "SC07": "植物",
+                "SC08": "動物",
+                "SC09": "人体",
+                "SC10": "天体",
+                "SC11": "気象",
+                "SC12": "地学",
+                # 社会
+                "SO01": "日本地理（国土・自然）",
+                "SO02": "日本地理（産業）",
+                "SO03": "世界地理",
+                "SO04": "歴史（古代〜平安）",
+                "SO05": "歴史（鎌倉〜室町）",
+                "SO06": "歴史（安土桃山〜江戸）",
+                "SO07": "歴史（明治〜現代）",
+                "SO08": "公民（政治・憲法）",
+                "SO09": "公民（経済・国際）",
+                "SO10": "時事問題"
+            }
+            
+            # subjects配列を処理（ジャンル名を補完）
+            subjects_list = []
+            for subj in gas_subjects:
+                # subject_nameがない場合はマッピングから取得
+                if not subj.get("subject_name"):
+                    subj["subject_name"] = subject_names.get(subj.get("subject", ""), subj.get("subject", ""))
+                
+                # genresのジャンル名を補完
+                genres = subj.get("genres", [])
+                for genre in genres:
+                    if not genre.get("genre_name") or genre.get("genre_name") == "不明":
+                        genre["genre_name"] = genre_names.get(genre.get("genre_id", ""), genre.get("genre_id", ""))
+                
+                # total_attemptedフィールドを追加（フロントエンド互換）
+                if "total_attempted" not in subj:
+                    subj["total_attempted"] = subj.get("total_questions", 0)
+                
+                subjects_list.append(subj)
+            
+            # 累積統計を構築（GASからのデータを使用）
+            cumulative = {
+                "total_sessions": gas_cumulative.get("total_sessions", 0),
+                "total_questions": gas_cumulative.get("total_questions", 0),
+                "overall_accuracy": gas_cumulative.get("overall_accuracy", 0.0)
+            }
+            
+            transformed_result = {
+                "success": True,
+                "data": {
+                    "cumulative": cumulative,
+                    "subjects": subjects_list
+                }
+            }
+            
+            logger.info(f"get_statistics: Returning cumulative={cumulative}")
+            return transformed_result
+        else:
+            # GASがエラーを返した場合はそのまま返す
+            return result
+            
+    except Exception as e:
+        logger.error(f"get_statistics error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/get_evaluation")
+async def get_evaluation(request: GetEvaluationRequest):
+    """評価生成 - Gemini API直接呼び出し（一括評価対応）
+
+    v1.4.0: 要約ステータス・クイズ内容表示対応
+    """
+    try:
+        # セッションの統計・結果を取得
+        logger.info(f"get_evaluation: Fetching session results for {request.session_id}")
+        session_data = await gas_client.get_session_results(request.session_id)
+        logger.info(f"get_evaluation: Session data received: {session_data.get('success', 'no success key')}")
+
+        # v1.4.0: 要約ステータスチェック
+        summary_status = None
+        quiz_summary = None
+        try:
+            summary_result = await gas_client.check_summary_status(request.session_id)
+            if summary_result.get("success") or summary_result.get("completed"):
+                summary_status = summary_result
+                # 要約テキストを構築（今回のクイズ内容）
+                summaries = summary_result.get("summaries", [])
+                if summaries:
+                    quiz_summary = "、".join([s.get("summary", "") for s in summaries if s.get("summary")])
+                logger.info(f"get_evaluation: Summary status - completed: {summary_result.get('completed')}, count: {summary_result.get('count')}")
+        except Exception as e:
+            logger.warning(f"get_evaluation: Failed to get summary status (non-fatal): {e}")
+
+        # セッションデータの検証
+        if not session_data.get('success') and not session_data.get('data'):
+            logger.warning(f"get_evaluation: No valid session data for {request.session_id}")
+            return {
+                "success": False,
+                "error": "セッションデータが見つかりません"
+            }
+
+        # GASからのデータを取得
+        raw_data = session_data.get('data', session_data)
+
+        # resultsをresults_by_subject形式に変換
+        results = raw_data.get('results', [])
+        results_by_subject = {}
+        for r in results:
+            subject = r.get('subject', '')
+            if subject:
+                if subject not in results_by_subject:
+                    results_by_subject[subject] = []
+                results_by_subject[subject].append(r)
+
+        # 変換したデータ構造を作成
+        transformed_data = {
+            'session_id': raw_data.get('session_id'),
+            'results': results,
+            'results_by_subject': results_by_subject,
+            'summary': raw_data.get('summary', {}),
+            'statistics': {}  # 必要に応じて統計データも追加
+        }
+
+        logger.info(f"get_evaluation: Transformed data - subjects: {list(results_by_subject.keys())}, total_results: {len(results)}")
+
+        # Gemini APIで評価生成（一括評価）
+        logger.info(f"get_evaluation: Generating batch evaluation via Gemini")
+        batch_result = await gemini_service.generate_evaluation_batch(
+            session_data=transformed_data
+        )
+
+        # 結果をフロントエンド期待形式に変換
+        subject_evaluations = batch_result.get("subject_evaluations", {})
+        overall_evaluation = batch_result.get("overall_evaluation")
+
+        # evaluations配列を構築（フロントエンド互換）
+        evaluations = []
+        for subject, eval_data in subject_evaluations.items():
+            evaluations.append({
+                "subject": subject,
+                **eval_data
+            })
+
+        # 全体評価があれば追加
+        if overall_evaluation:
+            evaluations.append({
+                "subject": "overall",
+                **overall_evaluation
+            })
+
+        logger.info(f"get_evaluation: Generated {len(evaluations)} evaluations (including overall)")
+
+        # GASに評価を保存（エラーがあってもフロントエンドには成功を返す）
+        try:
+            save_result = await gas_client.save_evaluations(
+                session_id=request.session_id,
+                evaluations=evaluations
+            )
+            logger.info(f"get_evaluation: Save result: {save_result.get('success', 'unknown')}")
+        except Exception as save_error:
+            logger.error(f"get_evaluation: Failed to save evaluations: {save_error}")
+            # 保存に失敗しても、生成した評価は返す
+
+        # v1.4.0: 要約情報を含めたレスポンス構築
+        response_data = {
+            "session_id": request.session_id,
+            "evaluations": evaluations
+        }
+
+        if summary_status:
+            response_data["summary_status"] = {
+                "completed": summary_status.get("completed", False),
+                "count": summary_status.get("count", 0)
+            }
+        if quiz_summary:
+            response_data["quiz_summary"] = quiz_summary
+
+        return {
+            "success": True,
+            "data": response_data
+        }
+    except Exception as e:
+        logger.error(f"get_evaluation error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# =============================================================================
+# 静的ファイル配信
+# =============================================================================
+
+# 静的ファイル（CSS, JS）
+app.mount("/css", StaticFiles(directory="static/css"), name="css")
+app.mount("/js", StaticFiles(directory="static/js"), name="js")
+
+@app.get("/")
+async def root():
+    """メインページ"""
+    return FileResponse("static/index.html")
+
+
+# =============================================================================
+# エントリーポイント
+# =============================================================================
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=port,
+        timeout_keep_alive=300  # タイムアウト300秒に延長
+    )

V1.7.1/docs/FUTURE_VISION.md

@@ -0,0 +1,356 @@
+# 超天才クイズ - 今後の構想
+
+> このドキュメントは他のLLMとの壁打ち用です。
+> 自由にアイデアを膨らませ、洗練させてください。
+
+---
+
+## 現状のシステム概要
+
+### プロダクト名
+**超天才クイズ v1.6.15 (STABLE)**
+
+### 概要
+中学受験対策の4択クイズアプリ。AIが問題を生成し、学習者の理解度を分析してアドバイスを提供する。
+
+### 技術スタック
+- **フロントエンド**: HTML/CSS/JavaScript（静的ファイル）
+- **バックエンド**: FastAPI (Python)
+- **AI**: Gemini API（問題生成・評価生成）
+- **データ永続化**: Google Apps Script + Google Spreadsheet
+- **ホスティング**: Hugging Face Spaces (Docker)
+
+### 現在の機能
+- ユーザーログイン（簡易的、ユーザー名のみ）
+- 4教科対応（国語・算数・理科・社会）
+- QuestionDatabase（問題素材DB）からの問題生成
+- 4択クイズ出題・正誤判定
+- AI先生によるアドバイス（Gemini生成）
+- 累積成績・詳細分析
+- 均等出題（USAGE_COUNTで同じ問題の繰り返しを防止）
+
+### 対象ユーザー
+- 中学受験を目指す小学生（小4〜小6）
+- その保護者
+
+---
+
+## 今後の構想
+
+---
+
+## 【A】超天才クイズ 本体の改善
+
+> 現在のシステム（v1.6.15）への機能追加・改善
+
+### A-1. ユーザー単位での管理
+
+**現状の課題**:
+- 現在は全ユーザー共通でUSAGE_COUNTを管理
+- 成績も厳密なユーザー分離ができていない
+
+**やりたいこと**:
+- 成績をユーザーごとに分離・管理
+- USAGE_COUNTもユーザー単位で管理
+  - 同じ問題でも別ユーザーには出題される
+  - 各ユーザーが全問題を公平に体験できる
+- ユーザー別の苦手分野分析
+
+### A-2. 制限時間の設定
+
+**目的**:
+- 本番の試験を意識した緊張感
+- ダラダラ解くのを防止
+- 回答スピードの記録・分析
+
+**やりたいこと**:
+- 1科目あたり5分の制限時間
+- カウントダウンタイマーを常に表示
+- 時間切れ時の挙動:
+  - 強制終了
+  - 未回答問題は不正解扱い
+  - 自動的に評価画面へ遷移
+- 各問題の回答時間をシートに記録
+  - 「この問題に何秒かかったか」を分析に活用
+
+---
+
+## 【B】派生サービス：問題配信サービス（仮称）
+
+> 超天才クイズをベースにした**別サービス**として展開
+> ランキング・クラス制・定期配信などソーシャル要素を持つ
+
+### B-1. サービス概要
+
+**コンセプト**:
+- 超天才クイズの問題生成エンジンを活用
+- ソーシャルゲーム的なレート制で継続的な学習モチベーションを維持
+- 登録ユーザー向けの定期問題配信サービス
+
+---
+
+### B-2. 問題配信機能【確定】
+
+**配信スケジュール**:
+- **デイリー配信**（毎日）
+- 朝（登校前）：2教科
+- 夕方（下校前）：2教科
+- 1日合計4教科
+
+**出題形式**:
+- 1教科あたり10問
+- 制限時間：1教科5分（300秒）
+
+**回答期限**:
+- 当日23:59まで
+
+---
+
+### B-3. ポイント計算【確定】
+
+**計算式**:
+```
+正答ポイント = 正解数 × 100
+時間ボーナス = 残り秒数 × 正答率
+合計ポイント = 正答ポイント + 時間ボーナス
+```
+
+**設計意図**:
+- 正答率が時間ボーナスに係数として掛かることで、適当に連打するハックを防止
+- 正確さと速さの両方を評価
+- 中学受験本番を意識した設計
+
+**得点シミュレーション**:
+
+| ケース | 正答P | 時間B | 合計 |
+|--------|-------|-------|------|
+| 全問正解・残り180秒 | 1000 | 180 | **1180点** |
+| 全問正解・残り60秒 | 1000 | 60 | **1060点** |
+| 8問正解・残り120秒 | 800 | 96 | **896点** |
+| 5問正解・残り200秒 | 500 | 100 | **600点** |
+| 連打3問・残り270秒 | 300 | 81 | **381点** |
+
+理論上の最高点：約1300点/教科（全問正解+残り300秒）
+現実的な上限：1100〜1200点/教科
+
+---
+
+### B-4. ランキング機能【確定】
+
+**ランキング種類**（5種類）:
+- 国語
+- 算数
+- 理科
+- 社会
+- **総合**（4教科合算）
+
+**表示項目**:
+- 正答率
+- 回答時間
+- 獲得ポイント
+
+**ランキング表示期間**:
+- 当日分のテスト結果は、翌日まる1日ランキングとして表示
+- 例：12/21のテスト → 12/22の1日間ランキング表示
+
+---
+
+### B-5. クラス制【確定】
+
+**クラス構成**（6段階）:
+
+| クラス | 名称 | 難易度 | 対応レベル |
+|--------|------|--------|------------|
+| 6 | **超天才** | 難 | 最難関校受験 |
+| 5 | **天才** | 難 | 難関校上位 |
+| 4 | **もうすぐ天才** | 中 | 難関校受験 |
+| 3 | **天才かも** | 中 | 中堅校受験 |
+| 2 | **天才の見習い** | 易 | 基礎固め |
+| 1 | **天才のたまご** | 易 | 学校授業サポート |
+
+**成長ストーリー**:
+```
+たまご → 見習い → かも？ → もうすぐ！ → 天才！ → 超天才！！
+```
+
+**問題プール**:
+- 難易度別に3セット（易・中・難）で運用
+- クラス1-2：易
+- クラス3-4：中
+- クラス5-6：難
+
+**将来の拡張**:
+- ユーザー数が増えたら、正規分布の中央値付近のクラスを増設
+
+---
+
+### B-6. クラス判定方式【確定】
+
+**判定タイミング**:
+- 毎日判定（リアルタイムでクラスが変動）
+
+**判定方式**:
+- **過去7日間の加重移動平均**
+- 開始7日未満のユーザーは、経過日数で割った平均
+
+**加重の重み**（緩やか設定）:
+
+| 日 | 重み |
+|----|------|
+| 今日 | ×1.5 |
+| 1日前 | ×1.4 |
+| 2日前 | ×1.3 |
+| 3日前 | ×1.2 |
+| 4日前 | ×1.1 |
+| 5日前 | ×1.0 |
+| 6日前 | ×0.9 |
+
+**計算式**:
+```
+加重平均 = (今日の点数×1.5 + 1日前×1.4 + ... + 6日前×0.9) ÷ 7
+```
+※ 参加しなかった日は0点としてカウント（継続参加のインセンティブ）
+
+**クラス閾値**（加重平均点）:
+
+| クラス | 加重平均点 |
+|--------|------------|
+| 超天才 | 3572点以上 |
+| 天才 | 2858〜3571点 |
+| もうすぐ天才 | 2143〜2857点 |
+| 天才かも | 1429〜2142点 |
+| 天才の見習い | 715〜1428点 |
+| 天才のたまご | 0〜714点 |
+
+**設計意図**:
+- 毎日「今日頑張ればクラス上がるかも」という緊張感
+- 新規ユーザーは少ない日数で割るため、初日から上位クラス体験できる可能性
+- サボると徐々に落ちる（急降下ではない）
+- 継続参加しないとクラス維持できない
+
+---
+
+### B-7. 週間アイテム（鉛筆シリーズ）【確定】
+
+**コンセプト**:
+- 週間ポイントに応じてアイテム（鉛筆）を付与
+- アイテム所持中は毎日ポイントボーナス
+- 有効期間は1週間
+- 控えめなボーナスで逆転可能な設計
+
+**アイテム一覧**:
+
+| アイテム | 週間ポイント閾値 | ボーナス | 有効期間 |
+|----------|------------------|----------|----------|
+| 金の鉛筆 | 25000点以上 | +100点/日 | 1週間 |
+| 銀の鉛筆 | 20000点以上 | +50点/日 | 1週間 |
+| 銅の鉛筆 | 15000点以上 | +25点/日 | 1週間 |
+
+**週間ボーナス影響**:
+
+| アイテム | 週間合計ボーナス | 週間ポイントに対する影響度 |
+|----------|------------------|----------------------------|
+| 金の鉛筆 | +700点/週 | 約2〜3% |
+| 銀の鉛筆 | +350点/週 | 約1〜2% |
+| 銅の鉛筆 | +175点/週 | 約0.5〜1% |
+
+**設計意図**:
+- 「ないよりマシ」程度の恩恵で、実力勝負を維持
+- 強者がより強くなりすぎる問題を回避
+- 週間で頑張るモチベーションになる
+- 勉強道具（鉛筆）で教育サービスとしての統一感
+
+**その他の表彰**:
+- ゲーミフィケーションは控えめに（過度な演出は避ける）
+- 成果に対する表彰は大事
+  - 昇格時の表彰
+  - 週間ランキング上位者の発表
+  - 連続正解記録など
+
+---
+
+### B-8. 保護者向けの配慮
+
+**大前提**:
+- **利用料金無料**を維持
+- 保護者の理解・信頼を得ることが最重要
+
+**スマホ利用時間と学習効率のバランス**:
+- ダラダラ使わせない設計
+  - 配信回数が決まっているため自然と上限あり
+- 短時間で効果的な学習
+  - 1教科5分で完結
+  - 隙間時間で取り組める
+
+**保護者の理解を得る仕組み**:
+- 学習レポートの共有
+  - 「今週は算数の割合が苦手でした」
+  - メールorLINE通知？
+- 利用時間の可視化
+  - 「今週は合計45分学習しました」
+- 保護者向けダッシュボード？
+
+---
+
+## 検討が必要なポイント
+
+### ビジネスモデル
+- 無料維持の場合、どう運営コストを賄うか？
+- 広告？寄付？有料オプション？
+
+### 技術的課題
+- ユーザー認証の強化（現在は名前のみ）
+- リアルタイムランキングのスケーラビリティ
+- 問題数の拡充（現在は各カテゴリ数十問程度）
+
+### 教育的配慮
+- 競争を煽りすぎない設計
+- 「負け」の演出をどうするか（降格時など）
+- 学習の本質（理解）vs ゲーム的快感（勝利）のバランス
+
+### 法的・倫理的配慮
+- 小学生の個人情報保護
+- 保護者の同意取得フロー
+- 利用規約・プライバシーポリシー
+
+---
+
+## 未検討項目
+
+- 予告→予習の具体的な仕組み
+- 保護者通��の設計（手段・内容・頻度）
+- ランキング画面のUI詳細
+- 新規ユーザーの初期クラス設定方法
+
+---
+
+## 参考：現在のシステム構成図
+
+```
+[ユーザー]
+    ↓ ブラウザ
+[HuggingFace Spaces]
+    ├── static/ (HTML/CSS/JS)
+    └── FastAPI (app.py)
+           ↓ API呼び出し
+    [Gemini API] ← 問題生成・評価生成
+           ↓
+    [Google Apps Script]
+           ↓
+    [Google Spreadsheet]
+        ├── Users
+        ├── Sessions
+        ├── QuestionDatabase
+        ├── GeneratedQuestions
+        ├── Answers
+        ├── Evaluations
+        ├── Statistics
+        └── Summaries
+```
+
+---
+
+**作成日**: 2025-12-21
+**最終更新**: 2025-12-21
+**バージョン**: v1.6.15 STABLE ベース
+**ステータス**: 派生サービス設計進行中

V1.7.1/docs/GEMINI_API_CONFIG.md

@@ -0,0 +1,223 @@
+# Gemini API リクエスト設定
+
+> 超天才クイズ v3 における Gemini API 呼び出しの詳細設定
+
+---
+
+## 1. 基本設定
+
+| 項目 | 値 |
+|------|-----|
+| **モデル** | `gemini-2.5-flash` |
+| **API キー** | 環境変数 `GEMINI_API_KEY` |
+| **SDK** | `google-generativeai` (Python) |
+
+```python
+import google.generativeai as genai
+genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
+self.model = genai.GenerativeModel("gemini-2.5-flash")
+```
+
+---
+
+## 2. 用途別パラメータ設定
+
+### 2.1 問題生成 (`generate_questions`)
+
+| パラメータ | 値 | 説明 |
+|-----------|-----|------|
+| `temperature` | **0.7** | 創造性高め（多様な問題生成） |
+| `max_output_tokens` | **16384** | 5問分の出力を保証 |
+| `response_mime_type` | `application/json` | JSON形式で直接取得 |
+
+```python
+generation_config=genai.GenerationConfig(
+    temperature=0.7,
+    max_output_tokens=16384,
+    response_mime_type="application/json"
+)
+```
+
+### 2.2 教科別評価生成 (`generate_evaluation`)
+
+| パラメータ | 値 | 説明 |
+|-----------|-----|------|
+| `temperature` | **0.5** | 一貫性重視（安定した評価） |
+| `max_output_tokens` | **2048** | 1教科分の評価に十分 |
+| `response_mime_type` | `application/json` | JSON形式で直接取得 |
+
+```python
+generation_config=genai.GenerationConfig(
+    temperature=0.5,
+    max_output_tokens=2048,
+    response_mime_type="application/json"
+)
+```
+
+### 2.3 全体評価生成 (`_generate_overall_evaluation`)
+
+| パラメータ | 値 | 説明 |
+|-----------|-----|------|
+| `temperature` | **0.5** | 一貫性重視 |
+| `max_output_tokens` | **1024** | 全体サマリーに十分 |
+| `response_mime_type` | `application/json` | JSON形式で直接取得 |
+
+---
+
+## 3. システムインストラクション（プロンプト）
+
+### 3.1 問題生成プロンプト
+
+**ロール定義**:
+```
+あなたは中学受験対策の{教科名}問題作成の専門家です。
+```
+
+**主要指示**:
+- Knowledge Base（教材）に基づいた問題を生成
+- 指定されたジャンルID（JP01, MA01等）を使用
+- 難易度を「基本」「標準」「応用」でバランス
+- 5問生成
+
+**出力形式**:
+```json
+[
+  {
+    "category": "ジャンルID",
+    "difficulty": "標準",
+    "question": "問題文",
+    "choices": ["選択肢1", "選択肢2", "選択肢3", "選択肢4"],
+    "correct_answer": 0,
+    "explanation": "解説文"
+  }
+]
+```
+
+**オプション追加情報**:
+- ユーザー統計（正答率60%未満は基本中心、60%以上は標準・応用）
+- 直近20問の履歴（重複回避用）
+
+### 3.2 評価生成プロンプト
+
+**ロール定義**:
+```
+あなたは中学受験の{教科名}指導の専門家です。
+```
+
+**入力データ**:
+- 今回の結果（問題数、正解数、正答率）
+- カテゴリ別結果
+- 解答詳細（最大10問）
+- 累積統計（オプション）
+
+**出力形式**:
+```json
+{
+  "advice": "総合的なアドバイス（2-3文）",
+  "strengths": ["強み・得意分野1", "強み・得意分野2"],
+  "weaknesses": ["改善点・苦手分野1", "改善点・苦手分野2"],
+  "recommended_topics": ["おすすめの学習トピック1", "おすすめの学習トピック2"]
+}
+```
+
+**注意事項**:
+- 具体的で建設的なアドバイス
+- 小学生に分かりやすい表現
+- 励ましの言葉を含める
+
+### 3.3 全体評価プロンプト
+
+**入力**: 教科別評価のJSON
+
+**出力形式**:
+```json
+{
+  "overall_advice": "全体的なアドバイス（2-3文）",
+  "strengths": ["強み1", "強み2"],
+  "weaknesses": ["改善点1", "改善点2"],
+  "next_steps": ["次のステップ1", "次のステップ2"]
+}
+```
+
+---
+
+## 4. ジャンルID一覧
+
+### 国語 (jp)
+| ID | 名称 |
+|----|------|
+| JP01 | 漢字・語彙 |
+| JP02 | 文法・言葉のきまり |
+| JP03 | 物語文読解 |
+| JP04 | 説明文・論説文読解 |
+| JP05 | 随筆文読解 |
+| JP06 | 詩・韻文 |
+| JP07 | 記述問題 |
+| JP08 | 知識・文学史 |
+
+### 算数 (math)
+| ID | 名称 |
+|----|------|
+| MA01 | 計算 |
+| MA02 | 数の性質 |
+| MA03 | 割合・比 |
+| MA04 | 速さ |
+| MA05 | 文章題（その他） |
+| MA06 | 平面図形 |
+| MA07 | 立体図形 |
+| MA08 | 場合の数・確率 |
+| MA09 | グラフ・表 |
+| MA10 | 特殊算 |
+
+### 理科 (sci)
+| ID | 名称 |
+|----|------|
+| SC01 | 力・運動 |
+| SC02 | 電気 |
+| SC03 | 光・音・熱 |
+| SC04 | 物質の性質 |
+| SC05 | 水溶液 |
+| SC06 | 燃焼・化学変化 |
+| SC07 | 植物 |
+| SC08 | 動物 |
+| SC09 | 人体 |
+| SC10 | 天体 |
+| SC11 | 気象 |
+| SC12 | 地学 |
+
+### 社会 (soc)
+| ID | 名称 |
+|----|------|
+| SO01 | 日本地理（���土・自然） |
+| SO02 | 日本地理（産業） |
+| SO03 | 世界地理 |
+| SO04 | 歴史（古代〜平安） |
+| SO05 | 歴史（鎌倉〜室町） |
+| SO06 | 歴史（安土桃山〜江戸） |
+| SO07 | 歴史（明治〜現代） |
+| SO08 | 公民（政治・憲法） |
+| SO09 | 公民（経済・国際） |
+| SO10 | 時事問題 |
+
+---
+
+## 5. 関連ファイル
+
+| ファイル | 説明 |
+|---------|------|
+| `src/services/gemini_service.py` | Gemini API呼び出しメインロジック |
+| `src/prompts/question_prompts.py` | 問題生成プロンプト定義 |
+| `src/prompts/evaluation_prompts.py` | 評価生成プロンプト定義 |
+| `src/knowledge/*.md` | 教科別Knowledge Base |
+
+---
+
+## 6. 設定変更時の注意
+
+- **temperature**: 上げると多様性増加、下げると一貫性増加
+- **max_output_tokens**: 出力が途切れる場合は増やす
+- **モデル変更**: `gemini-2.5-flash` は高速・低コスト。精度重視なら `gemini-2.0-pro` 検討
+
+---
+
+**最終更新**: 2025-12-12

V1.7.1/docs/GEMINI_STRUCTURED_OUTPUT.txt

@@ -0,0 +1,540 @@
+<br />
+
+You can configure Gemini models to generate responses that adhere to a provided JSON Schema. This capability guarantees predictable and parsable results, ensures format and type-safety, enables the programmatic detection of refusals, and simplifies prompting.
+
+Using structured outputs is ideal for a wide range of applications:
+
+- **Data extraction:**Pull specific information from unstructured text, like extracting names, dates, and amounts from an invoice.
+- **Structured classification:**Classify text into predefined categories and assign structured labels, such as categorizing customer feedback by sentiment and topic.
+- **Agentic workflows:**Generate structured data that can be used to call other tools or APIs, like creating a character sheet for a game or filling out a form.
+
+In addition to supporting JSON Schema in the REST API, the Google GenAI SDKs for Python and JavaScript also make it easy to define object schemas using[Pydantic](https://docs.pydantic.dev/latest/)and[Zod](https://zod.dev/), respectively. The example below demonstrates how to extract information from unstructured text that conforms to a schema defined in code.
+
+Recipe ExtractorContent ModerationRecursive Structures
+
+This example demonstrates how to extract structured data from text using basic JSON Schema types like`object`,`array`,`string`, and`integer`.  
+
+### Python
+
+    from google import genai
+    from pydantic import BaseModel, Field
+    from typing import List, Optional
+
+    class Ingredient(BaseModel):
+        name: str = Field(description="Name of the ingredient.")
+        quantity: str = Field(description="Quantity of the ingredient, including units.")
+
+    class Recipe(BaseModel):
+        recipe_name: str = Field(description="The name of the recipe.")
+        prep_time_minutes: Optional[int] = Field(description="Optional time in minutes to prepare the recipe.")
+        ingredients: List[Ingredient]
+        instructions: List[str]
+
+    client = genai.Client()
+
+    prompt = """
+    Please extract the recipe from the following text.
+    The user wants to make delicious chocolate chip cookies.
+    They need 2 and 1/4 cups of all-purpose flour, 1 teaspoon of baking soda,
+    1 teaspoon of salt, 1 cup of unsalted butter (softened), 3/4 cup of granulated sugar,
+    3/4 cup of packed brown sugar, 1 teaspoon of vanilla extract, and 2 large eggs.
+    For the best part, they'll need 2 cups of semisweet chocolate chips.
+    First, preheat the oven to 375°F (190°C). Then, in a small bowl, whisk together the flour,
+    baking soda, and salt. In a large bowl, cream together the butter, granulated sugar, and brown sugar
+    until light and fluffy. Beat in the vanilla and eggs, one at a time. Gradually beat in the dry
+    ingredients until just combined. Finally, stir in the chocolate chips. Drop by rounded tablespoons
+    onto ungreased baking sheets and bake for 9 to 11 minutes.
+    """
+
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=prompt,
+        config={
+            "response_mime_type": "application/json",
+            "response_json_schema": Recipe.model_json_schema(),
+        },
+    )
+
+    recipe = Recipe.model_validate_json(response.text)
+    print(recipe)
+
+### JavaScript
+
+    import { GoogleGenAI } from "@google/genai";
+    import { z } from "zod";
+    import { zodToJsonSchema } from "zod-to-json-schema";
+
+    const ingredientSchema = z.object({
+      name: z.string().describe("Name of the ingredient."),
+      quantity: z.string().describe("Quantity of the ingredient, including units."),
+    });
+
+    const recipeSchema = z.object({
+      recipe_name: z.string().describe("The name of the recipe."),
+      prep_time_minutes: z.number().optional().describe("Optional time in minutes to prepare the recipe."),
+      ingredients: z.array(ingredientSchema),
+      instructions: z.array(z.string()),
+    });
+
+    const ai = new GoogleGenAI({});
+
+    const prompt = `
+    Please extract the recipe from the following text.
+    The user wants to make delicious chocolate chip cookies.
+    They need 2 and 1/4 cups of all-purpose flour, 1 teaspoon of baking soda,
+    1 teaspoon of salt, 1 cup of unsalted butter (softened), 3/4 cup of granulated sugar,
+    3/4 cup of packed brown sugar, 1 teaspoon of vanilla extract, and 2 large eggs.
+    For the best part, they'll need 2 cups of semisweet chocolate chips.
+    First, preheat the oven to 375°F (190°C). Then, in a small bowl, whisk together the flour,
+    baking soda, and salt. In a large bowl, cream together the butter, granulated sugar, and brown sugar
+    until light and fluffy. Beat in the vanilla and eggs, one at a time. Gradually beat in the dry
+    ingredients until just combined. Finally, stir in the chocolate chips. Drop by rounded tablespoons
+    onto ungreased baking sheets and bake for 9 to 11 minutes.
+    `;
+
+    const response = await ai.models.generateContent({
+      model: "gemini-2.5-flash",
+      contents: prompt,
+      config: {
+        responseMimeType: "application/json",
+        responseJsonSchema: zodToJsonSchema(recipeSchema),
+      },
+    });
+
+    const recipe = recipeSchema.parse(JSON.parse(response.text));
+    console.log(recipe);
+
+### Go
+
+    package main
+
+    import (
+        "context"
+        "fmt"
+        "log"
+
+        "google.golang.org/genai"
+    )
+
+    func main() {
+        ctx := context.Background()
+        client, err := genai.NewClient(ctx, nil)
+        if err != nil {
+            log.Fatal(err)
+        }
+
+        prompt := `
+      Please extract the recipe from the following text.
+      The user wants to make delicious chocolate chip cookies.
+      They need 2 and 1/4 cups of all-purpose flour, 1 teaspoon of baking soda,
+      1 teaspoon of salt, 1 cup of unsalted butter (softened), 3/4 cup of granulated sugar,
+      3/4 cup of packed brown sugar, 1 teaspoon of vanilla extract, and 2 large eggs.
+      For the best part, they'll need 2 cups of semisweet chocolate chips.
+      First, preheat the oven to 375°F (190°C). Then, in a small bowl, whisk together the flour,
+      baking soda, and salt. In a large bowl, cream together the butter, granulated sugar, and brown sugar
+      until light and fluffy. Beat in the vanilla and eggs, one at a time. Gradually beat in the dry
+      ingredients until just combined. Finally, stir in the chocolate chips. Drop by rounded tablespoons
+      onto ungreased baking sheets and bake for 9 to 11 minutes.
+      `
+        config := &genai.GenerateContentConfig{
+            ResponseMIMEType: "application/json",
+            ResponseJsonSchema: map[string]any{
+                "type": "object",
+                "properties": map[string]any{
+                    "recipe_name": map[string]any{
+                        "type":        "string",
+                        "description": "The name of the recipe.",
+                    },
+                    "prep_time_minutes": map[string]any{
+                        "type":        "integer",
+                        "description": "Optional time in minutes to prepare the recipe.",
+                    },
+                    "ingredients": map[string]any{
+                        "type": "array",
+                        "items": map[string]any{
+                            "type": "object",
+                            "properties": map[string]any{
+                                "name": map[string]any{
+                                    "type":        "string",
+                                    "description": "Name of the ingredient.",
+                                },
+                                "quantity": map[string]any{
+                                    "type":        "string",
+                                    "description": "Quantity of the ingredient, including units.",
+                                },
+                            },
+                            "required": []string{"name", "quantity"},
+                        },
+                    },
+                    "instructions": map[string]any{
+                        "type":  "array",
+                        "items": map[string]any{"type": "string"},
+                    },
+                },
+                "required": []string{"recipe_name", "ingredients", "instructions"},
+            },
+        }
+
+        result, err := client.Models.GenerateContent(
+            ctx,
+            "gemini-2.5-flash",
+            genai.Text(prompt),
+            config,
+        )
+        if err != nil {
+            log.Fatal(err)
+        }
+        fmt.Println(result.Text())
+    }
+
+### REST
+
+    curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent" \
+        -H "x-goog-api-key: $GEMINI_API_KEY" \
+        -H 'Content-Type: application/json' \
+        -X POST \
+        -d '{
+          "contents": [{
+            "parts":[
+              { "text": "Please extract the recipe from the following text.\nThe user wants to make delicious chocolate chip cookies.\nThey need 2 and 1/4 cups of all-purpose flour, 1 teaspoon of baking soda,\n1 teaspoon of salt, 1 cup of unsalted butter (softened), 3/4 cup of granulated sugar,\n3/4 cup of packed brown sugar, 1 teaspoon of vanilla extract, and 2 large eggs.\nFor the best part, they will need 2 cups of semisweet chocolate chips.\nFirst, preheat the oven to 375°F (190°C). Then, in a small bowl, whisk together the flour,\nbaking soda, and salt. In a large bowl, cream together the butter, granulated sugar, and brown sugar\nuntil light and fluffy. Beat in the vanilla and eggs, one at a time. Gradually beat in the dry\ningredients until just combined. Finally, stir in the chocolate chips. Drop by rounded tablespoons\nonto ungreased baking sheets and bake for 9 to 11 minutes." }
+            ]
+          }],
+          "generationConfig": {
+            "responseMimeType": "application/json",
+            "responseJsonSchema": {
+              "type": "object",
+              "properties": {
+                "recipe_name": {
+                  "type": "string",
+                  "description": "The name of the recipe."
+                },
+                "prep_time_minutes": {
+                    "type": "integer",
+                    "description": "Optional time in minutes to prepare the recipe."
+                },
+                "ingredients": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "name": { "type": "string", "description": "Name of the ingredient."},
+                      "quantity": { "type": "string", "description": "Quantity of the ingredient, including units."}
+                    },
+                    "required": ["name", "quantity"]
+                  }
+                },
+                "instructions": {
+                  "type": "array",
+                  "items": { "type": "string" }
+                }
+              },
+              "required": ["recipe_name", "ingredients", "instructions"]
+            }
+          }
+        }'
+
+**Example Response:**  
+
+    {
+      "recipe_name": "Delicious Chocolate Chip Cookies",
+      "ingredients": [
+        {
+          "name": "all-purpose flour",
+          "quantity": "2 and 1/4 cups"
+        },
+        {
+          "name": "baking soda",
+          "quantity": "1 teaspoon"
+        },
+        {
+          "name": "salt",
+          "quantity": "1 teaspoon"
+        },
+        {
+          "name": "unsalted butter (softened)",
+          "quantity": "1 cup"
+        },
+        {
+          "name": "granulated sugar",
+          "quantity": "3/4 cup"
+        },
+        {
+          "name": "packed brown sugar",
+          "quantity": "3/4 cup"
+        },
+        {
+          "name": "vanilla extract",
+          "quantity": "1 teaspoon"
+        },
+        {
+          "name": "large eggs",
+          "quantity": "2"
+        },
+        {
+          "name": "semisweet chocolate chips",
+          "quantity": "2 cups"
+        }
+      ],
+      "instructions": [
+        "Preheat the oven to 375°F (190°C).",
+        "In a small bowl, whisk together the flour, baking soda, and salt.",
+        "In a large bowl, cream together the butter, granulated sugar, and brown sugar until light and fluffy.",
+        "Beat in the vanilla and eggs, one at a time.",
+        "Gradually beat in the dry ingredients until just combined.",
+        "Stir in the chocolate chips.",
+        "Drop by rounded tablespoons onto ungreased baking sheets and bake for 9 to 11 minutes."
+      ]
+    }
+
+## Streaming
+
+You can stream structured outputs, which allows you to start processing the response as it's being generated, without having to wait for the entire output to be complete. This can improve the perceived performance of your application.
+
+The streamed chunks will be valid partial JSON strings, which can be concatenated to form the final, complete JSON object.  
+
+### Python
+
+    from google import genai
+    from pydantic import BaseModel, Field
+    from typing import Literal
+
+    class Feedback(BaseModel):
+        sentiment: Literal["positive", "neutral", "negative"]
+        summary: str
+
+    client = genai.Client()
+    prompt = "The new UI is incredibly intuitive and visually appealing. Great job. Add a very long summary to test streaming!"
+
+    response_stream = client.models.generate_content_stream(
+        model="gemini-2.5-flash",
+        contents=prompt,
+        config={
+            "response_mime_type": "application/json",
+            "response_json_schema": Feedback.model_json_schema(),
+        },
+    )
+
+    for chunk in response_stream:
+        print(chunk.candidates[0].content.parts[0].text)
+
+### JavaScript
+
+    import { GoogleGenAI } from "@google/genai";
+    import { z } from "zod";
+    import { zodToJsonSchema } from "zod-to-json-schema";
+
+    const ai = new GoogleGenAI({});
+    const prompt = "The new UI is incredibly intuitive and visually appealing. Great job! Add a very long summary to test streaming!";
+
+    const feedbackSchema = z.object({
+      sentiment: z.enum(["positive", "neutral", "negative"]),
+      summary: z.string(),
+    });
+
+    const stream = await ai.models.generateContentStream({
+      model: "gemini-2.5-flash",
+      contents: prompt,
+      config: {
+        responseMimeType: "application/json",
+        responseJsonSchema: zodToJsonSchema(feedbackSchema),
+      },
+    });
+
+    for await (const chunk of stream) {
+      console.log(chunk.candidates[0].content.parts[0].text)
+    }
+
+## Structured outputs with tools
+
+| **Preview:** This is a feature available only for the Gemini 3 series models,`gemini-3-pro-preview`and`gemini-3-flash-preview`.
+
+Gemini 3 lets you combine Structured Outputs with built-in tools, including[Grounding with Google Search](https://ai.google.dev/gemini-api/docs/google-search),[URL Context](https://ai.google.dev/gemini-api/docs/url-context), and[Code Execution](https://ai.google.dev/gemini-api/docs/code-execution).  
+
+### Python
+
+    from google import genai
+    from pydantic import BaseModel, Field
+    from typing import List
+
+    class MatchResult(BaseModel):
+        winner: str = Field(description="The name of the winner.")
+        final_match_score: str = Field(description="The final match score.")
+        scorers: List[str] = Field(description="The name of the scorer.")
+
+    client = genai.Client()
+
+    response = client.models.generate_content(
+        model="gemini-3-pro-preview",
+        contents="Search for all details for the latest Euro.",
+        config={
+            "tools": [
+                {"google_search": {}},
+                {"url_context": {}}
+            ],
+            "response_mime_type": "application/json",
+            "response_json_schema": MatchResult.model_json_schema(),
+        },  
+    )
+
+    result = MatchResult.model_validate_json(response.text)
+    print(result)
+
+### JavaScript
+
+    import { GoogleGenAI } from "@google/genai";
+    import { z } from "zod";
+    import { zodToJsonSchema } from "zod-to-json-schema";
+
+    const ai = new GoogleGenAI({});
+
+    const matchSchema = z.object({
+      winner: z.string().describe("The name of the winner."),
+      final_match_score: z.string().describe("The final score."),
+      scorers: z.array(z.string()).describe("The name of the scorer.")
+    });
+
+    async function run() {
+      const response = await ai.models.generateContent({
+        model: "gemini-3-pro-preview",
+        contents: "Search for all details for the latest Euro.",
+        config: {
+          tools: [
+            { googleSearch: {} },
+            { urlContext: {} }
+          ],
+          responseMimeType: "application/json",
+          responseJsonSchema: zodToJsonSchema(matchSchema),
+        },
+      });
+
+      const match = matchSchema.parse(JSON.parse(response.text));
+      console.log(match);
+    }
+
+    run();
+
+### REST
+
+    curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro-preview:generateContent" \
+      -H "x-goog-api-key: $GEMINI_API_KEY" \
+      -H 'Content-Type: application/json' \
+      -X POST \
+      -d '{
+        "contents": [{
+          "parts": [{"text": "Search for all details for the latest Euro."}]
+        }],
+        "tools": [
+          {"googleSearch": {}},
+          {"urlContext": {}}
+        ],
+        "generationConfig": {
+            "responseMimeType": "application/json",
+            "responseJsonSchema": {
+                "type": "object",
+                "properties": {
+                    "winner": {"type": "string", "description": "The name of the winner."},
+                    "final_match_score": {"type": "string", "description": "The final score."},
+                    "scorers": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "The name of the scorer."
+                    }
+                },
+                "required": ["winner", "final_match_score", "scorers"]
+            }
+        }
+      }'
+
+## JSON schema support
+
+To generate a JSON object, set the`response_mime_type`in the generation configuration to`application/json`and provide a`response_json_schema`. The schema must be a valid[JSON Schema](https://json-schema.org/)that describes the desired output format.
+
+The model will then generate a response that is a syntactically valid JSON string matching the provided schema. When using structured outputs, the model will produce outputs in the same order as the keys in the schema.
+
+Gemini's structured output mode supports a subset of the[JSON Schema](https://json-schema.org)specification.
+
+The following values of`type`are supported:
+
+- **`string`**: For text.
+- **`number`**: For floating-point numbers.
+- **`integer`**: For whole numbers.
+- **`boolean`**: For true/false values.
+- **`object`**: For structured data with key-value pairs.
+- **`array`**: For lists of items.
+- **`null`** : To allow a property to be null, include`"null"`in the type array (e.g.,`{"type": ["string", "null"]}`).
+
+These descriptive properties help guide the model:
+
+- **`title`**: A short description of a property.
+- **`description`**: A longer and more detailed description of a property.
+
+### Type-specific properties
+
+**For`object`values:**
+
+- **`properties`**: An object where each key is a property name and each value is a schema for that property.
+- **`required`**: An array of strings, listing which properties are mandatory.
+- **`additionalProperties`** : Controls whether properties not listed in`properties`are allowed. Can be a boolean or a schema.
+
+**For`string`values:**
+
+- **`enum`**: Lists a specific set of possible strings for classification tasks.
+- **`format`** : Specifies a syntax for the string, such as`date-time`,`date`,`time`.
+
+**For`number`and`integer`values:**
+
+- **`enum`**: Lists a specific set of possible numeric values.
+- **`minimum`**: The minimum inclusive value.
+- **`maximum`**: The maximum inclusive value.
+
+**For`array`values:**
+
+- **`items`**: Defines the schema for all items in the array.
+- **`prefixItems`**: Defines a list of schemas for the first N items, allowing for tuple-like structures.
+- **`minItems`**: The minimum number of items in the array.
+- **`maxItems`**: The maximum number of items in the array.
+
+## Model support
+
+The following models support structured output:
+
+|         Model          | Structured Outputs |
+|------------------------|--------------------|
+| Gemini 3 Pro Preview   | ✔️                 |
+| Gemini 3 Flash Preview | ✔️                 |
+| Gemini 2.5 Pro         | ✔️                 |
+| Gemini 2.5 Flash       | ✔️                 |
+| Gemini 2.5 Flash-Lite  | ✔️                 |
+| Gemini 2.0 Flash       | ✔️\*               |
+| Gemini 2.0 Flash-Lite  | ✔️\*               |
+
+*\* Note that Gemini 2.0 requires an explicit`propertyOrdering`list within the JSON input to define the preferred structure. You can find an example in this[cookbook](https://github.com/google-gemini/cookbook/blob/main/examples/Pdf_structured_outputs_on_invoices_and_forms.ipynb).*
+
+## Structured outputs vs. function calling
+
+Both structured outputs and function calling use JSON schemas, but they serve different purposes:
+
+|        Feature         |                                                                                  Primary Use Case                                                                                  |
+|------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Structured Outputs** | **Formatting the final response to the user.** Use this when you want the model's*answer*to be in a specific format (e.g., extracting data from a document to save to a database). |
+| **Function Calling**   | **Taking action during the conversation.** Use this when the model needs to*ask you*to perform a task (e.g., "get current weather") before it can provide a final answer.          |
+
+## Best practices
+
+- **Clear descriptions:** Use the`description`field in your schema to provide clear instructions to the model about what each property represents. This is crucial for guiding the model's output.
+- **Strong typing:** Use specific types (`integer`,`string`,`enum`) whenever possible. If a parameter has a limited set of valid values, use an`enum`.
+- **Prompt engineering:**Clearly state in your prompt what you want the model to do. For example, "Extract the following information from the text..." or "Classify this feedback according to the provided schema...".
+- **Validation:**While structured output guarantees syntactically correct JSON, it does not guarantee the values are semantically correct. Always validate the final output in your application code before using it.
+- **Error handling:**Implement robust error handling in your application to gracefully manage cases where the model's output, while schema-compliant, may not meet your business logic requirements.
+
+## Limitations
+
+- **Schema subset:**Not all features of the JSON Schema specification are supported. The model ignores unsupported properties.
+- **Schema complexity:**The API may reject very large or deeply nested schemas. If you encounter errors, try simplifying your schema by shortening property names, reducing nesting, or limiting the number of constraints.
+
+
+
+
+
+
+

V1.7.1/docs/GenreMaster.js

@@ -0,0 +1,431 @@
+/**
+ * ジャンルマスターデータ
+ *
+ * 中学受験4教科のジャンル分類を定義
+ *
+ * @version 1.0.0
+ * @date 2025-12-07
+ */
+
+// ============================================================================
+// ジャンルマスターデータ
+// ============================================================================
+
+/**
+ * 中学受験4教科のジャンル分類マスターデータ
+ * @constant {Object}
+ */
+var GENRE_MASTER = {
+  // 国語（8ジャンル）
+  jp: {
+    subject_id: 'jp',
+    subject_name: '国語',
+    genres: [
+      {
+        id: 'JP01',
+        name: '漢字・語彙',
+        description: '読み書き、四字熟語、慣用句、ことわざ'
+      },
+      {
+        id: 'JP02',
+        name: '文法・言葉のきまり',
+        description: '品詞、敬語、文の成分、修飾関係'
+      },
+      {
+        id: 'JP03',
+        name: '物語文読解',
+        description: '心情理解、場面把握、人物関係'
+      },
+      {
+        id: 'JP04',
+        name: '説明文・論説文読解',
+        description: '要旨、段落構成、筆者の主張'
+      },
+      {
+        id: 'JP05',
+        name: '随筆文読解',
+        description: '筆者の体験・感想の読み取り'
+      },
+      {
+        id: 'JP06',
+        name: '詩・韻文',
+        description: '詩、短歌、俳句、表現技法'
+      },
+      {
+        id: 'JP07',
+        name: '記述問題',
+        description: '理由説明、要約、意見記述'
+      },
+      {
+        id: 'JP08',
+        name: '知識・文学史',
+        description: '作家、作品名、文学的常識'
+      }
+    ]
+  },
+
+  // 算数（10ジャンル）
+  math: {
+    subject_id: 'math',
+    subject_name: '算数',
+    genres: [
+      {
+        id: 'MA01',
+        name: '計算',
+        description: '四則演算、分数・小数、逆算'
+      },
+      {
+        id: 'MA02',
+        name: '数の性質',
+        description: '約数・倍数、素因数分解、規則性'
+      },
+      {
+        id: 'MA03',
+        name: '割合・比',
+        description: '割合、比、百分率、歩合'
+      },
+      {
+        id: 'MA04',
+        name: '速さ',
+        description: '旅人算、通過算、流水算、時計算'
+      },
+      {
+        id: 'MA05',
+        name: '文章題（その他）',
+        description: '濃度、仕事算、ニュートン算、差集め算'
+      },
+      {
+        id: 'MA06',
+        name: '平面図形',
+        description: '面積、角度、相似、合同'
+      },
+      {
+        id: 'MA07',
+        name: '立体図形',
+        description: '体積、表面積、展開図、切断'
+      },
+      {
+        id: 'MA08',
+        name: '場合の数・確率',
+        description: '順列、組み合わせ、確率'
+      },
+      {
+        id: 'MA09',
+        name: 'グラフ・表',
+        description: '統計、変化のグラフ、ダイヤグラム'
+      },
+      {
+        id: 'MA10',
+        name: '特殊算',
+        description: 'つるかめ算、消去算、過不足算'
+      }
+    ]
+  },
+
+  // 理科（12ジャンル）
+  sci: {
+    subject_id: 'sci',
+    subject_name: '理科',
+    genres: [
+      {
+        id: 'SC01',
+        name: '力・運動',
+        description: 'てこ、滑車、ばね、浮力、振り子'
+      },
+      {
+        id: 'SC02',
+        name: '電気',
+        description: '回路、抵抗、電磁石、発熱'
+      },
+      {
+        id: 'SC03',
+        name: '光・音・熱',
+        description: '反射、屈折、レンズ、音の性質'
+      },
+      {
+        id: 'SC04',
+        name: '物質の性質',
+        description: '金属、気体、密度、状態変化'
+      },
+      {
+        id: 'SC05',
+        name: '水溶液',
+        description: '酸・アルカリ、中和、溶解度'
+      },
+      {
+        id: 'SC06',
+        name: '燃焼・化学変化',
+        description: '燃焼、酸化還元、化合'
+      },
+      {
+        id: 'SC07',
+        name: '植物',
+        description: 'つくり、光合成、蒸散、分類'
+      },
+      {
+        id: 'SC08',
+        name: '動物',
+        description: 'からだのつくり、行動、分類'
+      },
+      {
+        id: 'SC09',
+        name: '人体',
+        description: '消化、呼吸、血液循環、感覚器官'
+      },
+      {
+        id: 'SC10',
+        name: '天体',
+        description: '太陽、月、星座、地球の運動'
+      },
+      {
+        id: 'SC11',
+        name: '気象',
+        description: '天気、気温、湿度、雲、季節風'
+      },
+      {
+        id: 'SC12',
+        name: '地学',
+        description: '地層、岩石、火山、地震'
+      }
+    ]
+  },
+
+  // 社会（10ジャンル）
+  soc: {
+    subject_id: 'soc',
+    subject_name: '社会',
+    genres: [
+      {
+        id: 'SO01',
+        name: '日本地理（国土・自然）',
+        description: '地形、気候、都道府県'
+      },
+      {
+        id: 'SO02',
+        name: '日本地理（産業）',
+        description: '農業、工業、水産業、商業'
+      },
+      {
+        id: 'SO03',
+        name: '世界地理',
+        description: '大陸、国、貿易、環境問題'
+      },
+      {
+        id: 'SO04',
+        name: '歴史（古代〜平安）',
+        description: '旧石器〜平安時代'
+      },
+      {
+        id: 'SO05',
+        name: '歴史（鎌倉〜室町）',
+        description: '武士の台頭、文化'
+      },
+      {
+        id: 'SO06',
+        name: '歴史（安土桃山〜江戸）',
+        description: '統一、鎖国、元禄・化政文化'
+      },
+      {
+        id: 'SO07',
+        name: '歴史（明治〜現代）',
+        description: '近代化、戦争、戦後'
+      },
+      {
+        id: 'SO08',
+        name: '公民（政治・憲法）',
+        description: '三権分立、選挙、人権'
+      },
+      {
+        id: 'SO09',
+        name: '公民（経済・国際）',
+        description: '経済の仕組み、国際機関、SDGs'
+      },
+      {
+        id: 'SO10',
+        name: '時事問題',
+        description: '直近1〜2年のニュース'
+      }
+    ]
+  }
+};
+
+// ============================================================================
+// ヘルパー関数
+// ============================================================================
+
+/**
+ * ジャンルIDからジャンル情報を取得
+ *
+ * @param {string} genreId - ジャンルID（例: 'JP01', 'MA05'）
+ * @returns {Object|null} - ジャンル情報 { id, name, description, subject_id, subject_name } または null
+ *
+ * @example
+ * var genre = getGenreById('JP01');
+ * // => { id: 'JP01', name: '漢字・語彙', description: '...', subject_id: 'jp', subject_name: '国語' }
+ */
+function getGenreById(genreId) {
+  if (!genreId || typeof genreId !== 'string') {
+    return null;
+  }
+
+  var upperGenreId = genreId.toUpperCase();
+
+  // 全教科を検索
+  var subjects = ['jp', 'math', 'sci', 'soc'];
+  for (var i = 0; i < subjects.length; i++) {
+    var subjectId = subjects[i];
+    var subjectData = GENRE_MASTER[subjectId];
+    var genres = subjectData.genres;
+
+    for (var j = 0; j < genres.length; j++) {
+      var genre = genres[j];
+      if (genre.id === upperGenreId) {
+        // ジャンル情報に教科情報を追加して返却
+        return {
+          id: genre.id,
+          name: genre.name,
+          description: genre.description,
+          subject_id: subjectData.subject_id,
+          subject_name: subjectData.subject_name
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 教科のジャンル一覧を取得
+ *
+ * @param {string} subjectId - 教科ID（jp, math, sci, soc）
+ * @returns {Array} - ジャンル配列（見つからない場合は空配列）
+ *
+ * @example
+ * var genres = getGenresBySubject('jp');
+ * // => [{ id: 'JP01', name: '漢字・語彙', ... }, ...]
+ */
+function getGenresBySubject(subjectId) {
+  if (!subjectId || typeof subjectId !== 'string') {
+    return [];
+  }
+
+  var subjectData = GENRE_MASTER[subjectId.toLowerCase()];
+  if (!subjectData) {
+    return [];
+  }
+
+  return subjectData.genres;
+}
+
+/**
+ * 全ジャンル数を取得
+ *
+ * @returns {number} - 総ジャンル数（40）
+ *
+ * @example
+ * var total = getTotalGenreCount();
+ * // => 40
+ */
+function getTotalGenreCount() {
+  var count = 0;
+  var subjects = ['jp', 'math', 'sci', 'soc'];
+
+  for (var i = 0; i < subjects.length; i++) {
+    var subjectId = subjects[i];
+    count += GENRE_MASTER[subjectId].genres.length;
+  }
+
+  return count;
+}
+
+/**
+ * ジャンルIDの検証
+ *
+ * @param {string} genreId - ジャンルID
+ * @returns {boolean} - 有効なジャンルIDかどうか
+ *
+ * @example
+ * isValidGenreId('JP01'); // => true
+ * isValidGenreId('XX99'); // => false
+ */
+function isValidGenreId(genreId) {
+  return getGenreById(genreId) !== null;
+}
+
+/**
+ * Dify用のジャンルリストを生成（問題生成プロンプト用）
+ *
+ * @param {string} subjectId - 教科ID（jp, math, sci, soc）
+ * @returns {string} - ジャンルリストの文字列（改行区切り）
+ *
+ * @example
+ * var list = getGenreListForDify('jp');
+ * // => "JP01: 漢字・語彙（読み書き、四字熟語、慣用句、ことわざ）\n..."
+ */
+function getGenreListForDify(subjectId) {
+  var genres = getGenresBySubject(subjectId);
+
+  if (genres.length === 0) {
+    return '';
+  }
+
+  var lines = [];
+  for (var i = 0; i < genres.length; i++) {
+    var genre = genres[i];
+    var line = genre.id + ': ' + genre.name + '（' + genre.description + '）';
+    lines.push(line);
+  }
+
+  return lines.join('\n');
+}
+
+// ============================================================================
+// テスト関数（GASエディタで実行可能）
+// ============================================================================
+
+/**
+ * GenreMaster.jsのテスト関数
+ * GASエディタで実行して動作確認
+ */
+function testGenreMaster() {
+  Logger.log('=== GenreMaster.js テスト開始 ===');
+
+  // テスト1: ジャンル総数
+  var totalCount = getTotalGenreCount();
+  Logger.log('テスト1: 総ジャンル数 = ' + totalCount + ' (期待値: 40)');
+
+  // テスト2: ジャンルID検索
+  var genre1 = getGenreById('JP01');
+  Logger.log('テスト2: getGenreById("JP01") = ' + JSON.stringify(genre1));
+
+  var genre2 = getGenreById('MA05');
+  Logger.log('テスト2: getGenreById("MA05") = ' + JSON.stringify(genre2));
+
+  // テスト3: 教科別ジャンル取得
+  var jpGenres = getGenresBySubject('jp');
+  Logger.log('テスト3: 国語ジャンル数 = ' + jpGenres.length + ' (期待値: 8)');
+
+  var mathGenres = getGenresBySubject('math');
+  Logger.log('テスト3: 算数ジャンル数 = ' + mathGenres.length + ' (期待値: 10)');
+
+  var sciGenres = getGenresBySubject('sci');
+  Logger.log('テスト3: 理科ジャンル数 = ' + sciGenres.length + ' (期待値: 12)');
+
+  var socGenres = getGenresBySubject('soc');
+  Logger.log('テスト3: 社会ジャンル数 = ' + socGenres.length + ' (期待値: 10)');
+
+  // テスト4: ジャンルID検証
+  var valid1 = isValidGenreId('JP01');
+  Logger.log('テスト4: isValidGenreId("JP01") = ' + valid1 + ' (期待値: true)');
+
+  var valid2 = isValidGenreId('XX99');
+  Logger.log('テスト4: isValidGenreId("XX99") = ' + valid2 + ' (期待値: false)');
+
+  // テスト5: Dify用ジャンルリスト生成
+  var jpList = getGenreListForDify('jp');
+  Logger.log('テスト5: 国語ジャンルリスト（最初の100文字）:');
+  Logger.log(jpList.substring(0, 100) + '...');
+
+  Logger.log('=== GenreMaster.js テスト完了 ===');
+}

V1.7.1/docs/PLAN_v1.4.md

@@ -0,0 +1,315 @@
+# PLAN: v1.4.0 出題バランス改善（LLM要約 + ジャンル優先方式）
+
+## 目的
+テストを繰り返しても、Knowledge Base内を網羅的に出題し、ジャンル・題材の偏りを解消する
+
+## 問題点
+
+### 1. ジャンルの偏り
+- 国語8ジャンル中4ジャンルしか出題されない
+- 未出題: JP05（随筆文）、JP06（詩・韻文）、JP07（記述問題）、JP08（文学史）
+
+### 2. 問題内容の重複
+- 「いたわる」など同じ題材が繰り返し出題
+- Knowledge Baseの特定部分しか使われない
+
+---
+
+## 解決策: LLM要約 + ジャンル優先方式
+
+### アーキテクチャ
+```
+[問題生成完了]
+    ↓
+[GAS] 問題保存 + Gemini要約リクエスト（非同期）
+    ↓  ※解答中に並行処理
+[GAS] 要約結果をQuestionSummariesシートに記録
+    ↓
+[評価生成時] HFから要約完了チェック → UI表示
+    ↓
+[詳細分析] 「今回のクイズ内容」として要約表示
+    ↓
+[次回問題生成] 要約を除外リスト + ジャンルカウントで優先度計算
+```
+
+### メリット
+1. **プロンプト削減**: 問題文全文ではなく要約キーワードのみ
+2. **非同期処理**: 解答中に要約完了、ユーザー待機時間なし
+3. **UI向上**: 詳細分析に「今回のクイズ内容」を表示
+4. **信頼性**: 要約完了ステータスを評価画面で確認可能
+
+---
+
+## 既存GAS構造
+
+### 現在のシート
+- `Users`: ユーザー情報
+- `Sessions`: セッション管理
+- `Questions`: 問題データ
+- `Answers`: 解答履歴
+- `Statistics`: カテゴリ別統計
+- `Evaluations`: 評価データ
+
+### 追加するシート
+- `QuestionSummaries`: 問題要約データ（新規）
+
+---
+
+## SUBAGENT タスク定義
+
+### T1: GAS - 要約生成・保存機能（SUBAGENT-A）
+**対象ファイル**: `gas/Code.gs`
+
+**実装内容**:
+```javascript
+// 新規シート
+const SHEETS = {
+  ...existing,
+  QUESTION_SUMMARIES: 'QuestionSummaries'
+};
+
+// 問題保存後に要約リクエスト発火
+function saveQuestions(sessionId, subject, questions) {
+  // ...既存の保存処理...
+
+  // 非同期で要約生成をトリガー
+  triggerSummaryGeneration(sessionId, subject, questions);
+
+  return { questions: savedQuestions, count: savedQuestions.length };
+}
+
+// 要約生成（Gemini API呼び出し）
+function triggerSummaryGeneration(sessionId, subject, questions) {
+  const GEMINI_API_KEY = PropertiesService.getScriptProperties().getProperty('GEMINI_API_KEY');
+  const prompt = buildSummaryPrompt(questions);
+
+  // Gemini API呼び出し
+  const response = callGeminiAPI(prompt, GEMINI_API_KEY);
+
+  // 結果をシートに保存
+  saveSummary(sessionId, subject, response);
+}
+
+// 要約プロンプト構築
+function buildSummaryPrompt(questions) {
+  return `以下の問題群から、重複防止用のキーワードリストを抽出してください。
+
+問題:
+${questions.map(q => q.question).join('\n')}
+
+出力形式（JSON）:
+{
+  "keywords": ["キーワード1", "キーワード2", ...],
+  "topics": ["トピック1", "トピック2", ...],
+  "summary": "問題群の概要（50文字以内）"
+}`;
+}
+
+// 要約保存
+function saveSummary(sessionId, subject, summaryData) {
+  const headers = ['summary_id', 'session_id', 'subject', 'keywords', 'topics', 'summary', 'created_at'];
+  const sheet = getOrCreateSheet(SHEETS.QUESTION_SUMMARIES, headers);
+  // ...保存処理...
+}
+
+// 要約取得（HFから呼び出し）
+function getQuestionSummaries(userId, limit = 5) {
+  // 直近N セッションの要約を取得
+  // ジャンル別カウントも併せて返却
+}
+
+// 要約ステータスチェック（HFから呼び出し）
+function checkSummaryStatus(sessionId) {
+  // 要約完了状態を返却
+}
+```
+
+---
+
+### T2: GAS - ジャンル別カウント取得（SUBAGENT-B）
+**対象ファイル**: `gas/Code.gs`
+
+**実装内容**:
+```javascript
+// 統計取得を拡張（ジャンル別出題カウント追加）
+function getStatistics(userId, subjects) {
+  // ...既存処理...
+
+  // ジャンル別出題カウントを追加
+  result.genre_counts = getGenreCounts(userId, subjects);
+
+  return result;
+}
+
+// ジャンル別出題カウント
+function getGenreCounts(userId, subjects) {
+  const answersSheet = getOrCreateSheet(SHEETS.ANSWERS, []);
+  const sessionsSheet = getOrCreateSheet(SHEETS.SESSIONS, []);
+
+  // ユーザーのセッション一覧を取得
+  // 各セッションの解答からカテゴリ別にカウント
+
+  return {
+    jp: { JP01: 15, JP02: 5, JP03: 6, JP04: 4, JP05: 0, JP06: 0, JP07: 0, JP08: 0 },
+    math: { MA01: 10, ... },
+    ...
+  };
+}
+```
+
+---
+
+### T3: HF - 要約取得・除外リスト生成（SUBAGENT-C）
+**対象ファイル**: `src/services/gas_client.py`
+
+**実装内容**:
+```python
+async def get_question_summaries(
+    self,
+    user_id: str,
+    limit: int = 5
+) -> Dict[str, Any]:
+    """直近セッションの問題要約を取得"""
+    return await self._post({
+        "action": "get_question_summaries",
+        "user_id": user_id,
+        "limit": limit
+    })
+
+async def check_summary_status(
+    self,
+    session_id: str
+) -> Dict[str, Any]:
+    """要約完了ステータスを確認"""
+    return await self._post({
+        "action": "check_summary_status",
+        "session_id": session_id
+    })
+```
+
+---
+
+### T4: HF - プロンプト改修（SUBAGENT-D）
+**対象ファイル**: `src/prompts/question_prompts.py`
+
+**実装内容**:
+```python
+def get_batch_question_prompt(
+    subjects: List[str],
+    knowledge_bases: Dict[str, str],
+    priority_genres: Dict[str, List[str]] = None,  # 追加
+    exclude_keywords: List[str] = None              # 追加
+) -> str:
+    # ... 既存のプロンプト構築 ...
+
+    # 優先ジャンル指定を追加
+    if priority_genres:
+        prompt += "\n## 出題優先ジャンル\n"
+        prompt += "以下のジャンルからの出題を優先してください（出題が少ない分野）:\n"
+        for subject in subjects:
+            if subject in priority_genres and priority_genres[subject]:
+                subject_name = SUBJECT_NAMES.get(subject, subject)
+                genres = priority_genres[subject][:5]  # 上位5ジャンル
+                prompt += f"- {subject_name}: {', '.join(genres)}\n"
+
+    # 除外キーワード指定を追加
+    if exclude_keywords and len(exclude_keywords) > 0:
+        prompt += f"\n## 除外キーワード\n"
+        prompt += "以下のキーワード・トピックに関する問題は避けてください（直近で出題済み）:\n"
+        prompt += f"{', '.join(exclude_keywords[:30])}\n"
+
+    return prompt
+```
+
+---
+
+### T5: HF - app.py統合（SUBAGENT-E）
+**対象ファイル**: `app.py`
+
+**実装内容**:
+```python
+@app.post("/api/generate_questions")
+async def generate_questions(request: GenerateQuestionsRequest):
+    # Phase 0: 統計・要約取得（新規追加）
+    stats = await gas_client.get_statistics(request.user_id, request.subjects)
+    summaries = await gas_client.get_question_summaries(request.user_id, limit=5)
+
+    # Phase 0.5: 優先ジャンル・除外キーワード計算（新規追加）
+    priority_genres = calculate_priority_genres(stats.get("genre_counts", {}), request.subjects)
+    exclude_keywords = extract_exclude_keywords(summaries)
+
+    # Phase 1-4: 既存フロー（引数追加）
+    questions_by_subject = await gemini_service.generate_questions_batch(
+        subjects=request.subjects,
+        knowledge_bases=knowledge_bases,
+        priority_genres=priority_genres,
+        exclude_keywords=exclude_keywords
+    )
+    ...
+```
+
+---
+
+### T6: HF - 評価画面に要約ステータス表示（SUBAGENT-F）
+**対象ファイル**: `app.py`, `static/index.html`
+
+**実装内容**:
+```python
+@app.post("/api/get_evaluation")
+async def get_evaluation(request):
+    # ...既存処理...
+
+    # 要約ステータスチェック追加
+    summary_status = await gas_client.check_summary_status(request.session_id)
+
+    return {
+        "success": True,
+        "data": {
+            ...existing,
+            "summary_status": summary_status,
+            "quiz_summary": summary_status.get("summary", "")  # 今回のクイズ内容
+        }
+    }
+```
+
+---
+
+## ファイル担当マップ
+
+| ファイル | Task | 変更内容 |
+|---------|------|---------|
+| `gas/Code.gs` | T1, T2 | 要約生成・保存、ジャンルカウント |
+| `src/services/gas_client.py` | T3 | 要約取得API追加 |
+| `src/prompts/question_prompts.py` | T4 | プロンプト拡張 |
+| `src/services/gemini_service.py` | T4 | 引数追加 |
+| `app.py` | T5, T6 | フロー統合、ステータス表示 |
+| `static/index.html` | T6 | UI更新 |
+
+---
+
+## 競合回避
+- T1, T2: GAS側（同一ファイルだが関数単位で分離）
+- T3, T4: HF側（異なるファイル、並列可）
+- T5, T6: T1-T4完了後に実行
+
+## 実行順序
+
+```
+[並列実行可能]
+T1 (GAS要約生成) ─────────────────┐
+T2 (GASジャンルカウント) ─────────┼→ T5 (app.py統合) → T6 (UI) → E2E
+T3 (HF要約取得) ──────────────────┤
+T4 (HFプロンプト改修) ────────────┘
+```
+
+---
+
+## 期待効果
+
+| 指標 | v1.3.0 | v1.4.0 |
+|-----|--------|--------|
+| ジャンル網羅率 | 50%（4/8） | 100%（8/8） |
+| 題材重複率 | 高い | 低い |
+| LLM呼び出し（問題生成） | 2回 | 2回（変更なし）|
+| LLM呼び出し（要約）| 0��� | 1回/教科（GAS側、非同期）|
+| ユーザー待機時間 | - | 増加なし（解答中に処理）|

V1.7.1/docs/dify-prompts.md

@@ -0,0 +1,299 @@
+# Dify 問題生成LLMプロンプト集
+
+**目的**: 4教科の問題生成LLMノードに設定するプロンプト
+**使用方法**: 各教科のプロンプトをコピーして、対応するLLMノードにペースト
+
+---
+
+## 国語問題生成
+
+```
+あなたは中学受験対策の国語問題作成の専門家です。
+
+## タスク
+以下の条件に基づき、国語の4択問題を20問生成してください。
+
+## ジャンル一覧（必ず以下のジャンルIDを使用）
+- JP01: 漢字・語彙（読み書き、四字熟語、慣用句、ことわざ）
+- JP02: 文法・言葉のきまり（品詞、敬語、文の成分、修飾関係）
+- JP03: 物語文読解（心情理解、場面把握、人物関係）
+- JP04: 説明文・論説文読解（要旨、段落構成、筆者の主張）
+- JP05: 随筆文読解（筆者の体験・感想の読み取り）
+- JP06: 詩・韻文（詩、短歌、俳句、表現技法）
+- JP07: 記述問題（理由説明、要約、意見記述）
+- JP08: 知識・文学史（作家、作品名、文学的常識）
+
+## 入力データ
+- **分野別正答率**: {{#1751785054001.statistics#}}
+- **直近20問の履歴**: {{#1751785054001.recent_questions#}}
+
+## 条件
+1. **分野構成**: 上記8ジャンルから均等に出題（各2〜3問）
+2. **難易度調整**: 正答率60%未満のジャンルは「基本」レベル、60%以上は「標準」「応用」をミックス
+3. **重複回避**: 直近20問と類似した問題は避ける
+4. **問題形式**: 問題文、4つの選択肢、正解番号（0〜3）、解説を含む
+5. **ジャンルID使用**: categoryフィールドには必ずジャンルID（JP01〜JP08）を使用すること
+
+## 出力形式
+**重要**: categoryフィールドには必ずジャンルID（JP01, JP02, JP03, JP04, JP05, JP06, JP07, JP08）を使用してください。
+日本語のジャンル名（「漢字・語彙」等）は使用しないでください。
+
+JSON形式で以下の構造で返してください：
+[
+  {
+    "question_id": "koku_001",
+    "category": "JP01",
+    "difficulty": "標準",
+    "question": "問題文",
+    "choices": ["選択肢1", "選択肢2", "選択肢3", "選択肢4"],
+    "correct_answer": 2,
+    "explanation": "解説文"
+  },
+  {
+    "question_id": "koku_002",
+    "category": "JP02",
+    "difficulty": "基本",
+    "question": "問題文",
+    "choices": ["選択肢1", "選択肢2", "選択肢3", "選択肢4"],
+    "correct_answer": 0,
+    "explanation": "解説文"
+  }
+  ... （合計20問）
+]
+```
+
+---
+
+## 算数問題生成
+
+```
+あなたは中学受験対策の算数問題作成の専門家です。
+
+## タスク
+以下の条件に基づき、算数の4択問題を20問生成してください。
+
+## ジャンル一覧（必ず以下のジャンルIDを使用）
+- MA01: 計算（四則演算、分数・小数、逆算）
+- MA02: 数の性質（約数・倍数、素因数分解、規則性）
+- MA03: 割合・比（割合、比、百分率、歩合）
+- MA04: 速さ（旅人算、通過算、流水算、時計算）
+- MA05: 文章題（その他）（濃度、仕事算、ニュートン算、差集め算）
+- MA06: 平面図形（面積、角度、相似、合同）
+- MA07: 立体図形（体積、表面積、展開図、切断）
+- MA08: 場合の数・確率（順列、組み合わせ、確率）
+- MA09: グラフ・表（統計、変化のグラフ、ダイヤグラム）
+- MA10: 特殊算（つるかめ算、消去算、過不足算）
+
+## 入力データ
+- **分野別正答率**: {{#1751785054001.statistics#}}
+- **直近20問の履歴**: {{#1751785054001.recent_questions#}}
+
+## 条件
+1. **分野構成**: 上記10ジャンルから幅広く出題（各1〜3問）
+2. **難易度調整**: 正答率60%未満のジャンルは「基本」レベル、60%以上は「標準」「応用」をミックス
+3. **重複回避**: 直近20問と類似した問題は避ける
+4. **問題形式**: 問題文、4つの選択肢、正解番号（0〜3）、解説を含む
+5. **ジャンルID使用**: categoryフィールドには必ずジャンルID（MA01〜MA10）を使用すること
+
+## 出力形式
+**重要**: categoryフィールドには必ずジャンルID（MA01, MA02, MA03, MA04, MA05, MA06, MA07, MA08, MA09, MA10）を使用してください。
+日本語のジャンル名（「平面図形」等）は使用しないでください。
+
+JSON形式で以下の構造で返してください：
+[
+  {
+    "question_id": "san_001",
+    "category": "MA01",
+    "difficulty": "標準",
+    "question": "問題文",
+    "choices": ["選択肢1", "選択肢2", "選択肢3", "選択肢4"],
+    "correct_answer": 0,
+    "explanation": "解説文"
+  },
+  {
+    "question_id": "san_002",
+    "category": "MA06",
+    "difficulty": "応用",
+    "question": "問題文",
+    "choices": ["選択肢1", "選択肢2", "選択肢3", "選択肢4"],
+    "correct_answer": 2,
+    "explanation": "解説文"
+  }
+  ... （合計20問）
+]
+```
+
+---
+
+## 理科問題生成
+
+```
+あなたは中学受験対策の理科問題作成の専門家です。
+
+## タスク
+以下の条件に基づき、理科の4択問題を20問生成してください。
+
+## ジャンル一覧（必ず以下のジャンルIDを使用）
+- SC01: 力・運動（てこ、滑車、ばね、浮力、振り子）
+- SC02: 電気（回路、抵抗、電磁石、発熱）
+- SC03: 光・音・熱（反射、屈折、レンズ、音の性質）
+- SC04: 物質の性質（金属、気体、密度、状態変化）
+- SC05: 水溶液（酸・アルカリ、中和、溶解度）
+- SC06: 燃焼・化学変化（燃焼、酸化還元、化合）
+- SC07: 植物（つくり、光合成、蒸散、分類）
+- SC08: 動物（からだのつくり、行動、分類）
+- SC09: 人体（消化、呼吸、血液循環、感覚器官）
+- SC10: 天体（太陽、月、星座、地球の運動）
+- SC11: 気象（天気、気温、湿度、雲、季節風）
+- SC12: 地学（地層、岩石、火山、地震）
+
+## 入力データ
+- **分野別正答率**: {{#1751785054001.statistics#}}
+- **直近20問の履歴**: {{#1751785054001.recent_questions#}}
+
+## 条件
+1. **分野構成**: 上記12ジャンルから幅広く出題（各1〜2問）
+2. **難易度調整**: 正答率60%未満のジャンルは「基本」レベル、60%以上は「標準」「応用」をミックス
+3. **重複回避**: 直近20問と類似した問題は避ける
+4. **問題形式**: 問題文、4つの選択肢、正解番号（0〜3）、解説を含む
+5. **ジャンルID使用**: categoryフィールドには必ずジャンルID（SC01〜SC12）を使用すること
+
+## 出力形式
+**重要**: categoryフィールドには必ずジャンルID（SC01, SC02, SC03, SC04, SC05, SC06, SC07, SC08, SC09, SC10, SC11, SC12）を使用してください。
+日本語のジャンル名（「力・運動」等）は使用しないでください。
+
+JSON形式で以下の構造で返してください：
+[
+  {
+    "question_id": "rika_001",
+    "category": "SC01",
+    "difficulty": "標準",
+    "question": "問題文",
+    "choices": ["選択肢1", "選択肢2", "選択肢3", "選択肢4"],
+    "correct_answer": 1,
+    "explanation": "解説文"
+  },
+  {
+    "question_id": "rika_002",
+    "category": "SC07",
+    "difficulty": "基本",
+    "question": "問題文",
+    "choices": ["選択肢1", "選択肢2", "選択肢3", "選択肢4"],
+    "correct_answer": 3,
+    "explanation": "解説文"
+  }
+  ... （合計20問）
+]
+```
+
+---
+
+## 社会問題生成
+
+```
+あなたは中学受験対策の社会問題作成の専門家です。
+
+## タスク
+以下の条件に基づき、社会の4択問題を20問生成してください。
+
+## ジャンル一覧（必ず以下のジャンルIDを使用）
+- SO01: 日本地理（国土・自然）（地形、気候、都道府県）
+- SO02: 日本地理（産業）（農業、工業、水産業、商業）
+- SO03: 世界地理（大陸、国、貿易、環境問題）
+- SO04: 歴史（古代〜平安）（旧石器〜平安時代）
+- SO05: 歴史（鎌倉〜室町）（武士の台頭、文化）
+- SO06: 歴史（安土桃山〜江戸）（統一、鎖国、元禄・化政文化）
+- SO07: 歴史（明治〜現代）（近代化、戦争、戦後）
+- SO08: 公民（政治・憲法）（三権分立、選挙、人権）
+- SO09: 公民（経済・国際）（経済の仕組み、国際機関、SDGs）
+- SO10: 時事問題（直近1〜2年のニュース）
+
+## 入力データ
+- **分野別正答率**: {{#1751785054001.statistics#}}
+- **直近20問の履歴**: {{#1751785054001.recent_questions#}}
+
+## 条件
+1. **分野構成**: 上記10ジャンルから幅広く出題（各1〜3問）
+2. **難易度調整**: 正答率60%未満のジャンルは「基本」レベル、60%以上は「標準」「応用」をミックス
+3. **重複回避**: 直近20問と類似した問題は避ける
+4. **問題形式**: 問題文、4つの選択肢、正解番号（0〜3）、解説を含む
+5. **ジャンルID使用**: categoryフィールドには必ずジャンルID（SO01〜SO10）を使用すること
+
+## 出力形式
+**重要**: categoryフィールドには必ずジャンルID（SO01, SO02, SO03, SO04, SO05, SO06, SO07, SO08, SO09, SO10）を使用してください。
+日本語のジャンル名（「日本地理（国土・自然）」等）は使用しないでください。
+
+JSON形式で以下の構造で返してください：
+[
+  {
+    "question_id": "soci_001",
+    "category": "SO01",
+    "difficulty": "標準",
+    "question": "問題文",
+    "choices": ["選択肢1", "選択肢2", "選択肢3", "選択肢4"],
+    "correct_answer": 2,
+    "explanation": "解説文"
+  },
+  {
+    "question_id": "soci_002",
+    "category": "SO08",
+    "difficulty": "応用",
+    "question": "問題文",
+    "choices": ["選択肢1", "選択肢2", "選択肢3", "選���肢4"],
+    "correct_answer": 1,
+    "explanation": "解説文"
+  }
+  ... （合計20問）
+]
+```
+
+---
+
+## ジャンルID一覧（参照用）
+
+| 教科 | ジャンルID | ジャンル名 |
+|------|-----------|-----------|
+| **国語** | JP01 | 漢字・語彙 |
+| | JP02 | 文法・言葉のきまり |
+| | JP03 | 物語文読解 |
+| | JP04 | 説明文・論説文読解 |
+| | JP05 | 随筆文読解 |
+| | JP06 | 詩・韻文 |
+| | JP07 | 記述問題 |
+| | JP08 | 知識・文学史 |
+| **算数** | MA01 | 計算 |
+| | MA02 | 数の性質 |
+| | MA03 | 割合・比 |
+| | MA04 | 速さ |
+| | MA05 | 文章題（その他） |
+| | MA06 | 平面図形 |
+| | MA07 | 立体図形 |
+| | MA08 | 場合の数・確率 |
+| | MA09 | グラフ・表 |
+| | MA10 | 特殊算 |
+| **理科** | SC01 | 力・運動 |
+| | SC02 | 電気 |
+| | SC03 | 光・音・熱 |
+| | SC04 | 物質の性質 |
+| | SC05 | 水溶液 |
+| | SC06 | 燃焼・化学変化 |
+| | SC07 | 植物 |
+| | SC08 | 動物 |
+| | SC09 | 人体 |
+| | SC10 | 天体 |
+| | SC11 | 気象 |
+| | SC12 | 地学 |
+| **社会** | SO01 | 日本地理（国土・自然） |
+| | SO02 | 日本地理（産業） |
+| | SO03 | 世界地理 |
+| | SO04 | 歴史（古代〜平安） |
+| | SO05 | 歴史（鎌倉〜室町） |
+| | SO06 | 歴史（安土桃山〜江戸） |
+| | SO07 | 歴史（明治〜現代） |
+| | SO08 | 公民（政治・憲法） |
+| | SO09 | 公民（経済・国際） |
+| | SO10 | 時事問題 |
+
+---
+
+**注意**: `{{#1751785054001.statistics#}}` と `{{#1751785054001.recent_questions#}}` は、Difyワークフロー内の変数参照です。実際のノードIDに合わせて調整してください。

V1.7.1/gas/.clasp.json

@@ -0,0 +1,4 @@
+{
+  "scriptId": "1rBj6xUhat3KZ1Iy9WXLdMiRh4CTKqCJHK3G149plkLJsPeuGFa5DuyGX",
+  "rootDir": "."
+}

V1.7.1/gas/Code.js

@@ -0,0 +1,2246 @@
+/**
+ * 超天才クイズAPI - Google Apps Script メインファイル
+ *
+ * @version 1.6.12
+ * @date 2025-12-20
+ *
+ * 変更履歴:
+ * - v1.6.12: デバッグロギング追加
+ * - v1.6.11: handleSubmitAnswers レスポンスキー修正 (correct_count→correct, total_questions→total, score→accuracy)
+ * - v1.6.10: getSessionResults カラムインデックス修正 (row[5],row[7],row[8])
+ * - v1.6.9: correct_answer 0-indexed統一, temperature=1.0
+ * - v1.6.8: shuffle_choices→convert_correct_answer_index, MAX_OUTPUT_TOKENS=65536
+ * - v1.6.6: Answersシートに subject,category,correct_answer カラム追加
+ */
+
+// ============================================================================
+// 定数定義
+// ============================================================================
+
+// 超天才クイズv3 本番スプレッドシート
+// URL: https://docs.google.com/spreadsheets/d/10JLP5ds2CNDOEYTxEzDyY82dErbD-InkTeuyzS_w_3U/
+const SPREADSHEET_ID = '10JLP5ds2CNDOEYTxEzDyY82dErbD-InkTeuyzS_w_3U';
+const SHEET_NAMES = {
+  USERS: 'Users',
+  SESSIONS: 'Sessions',
+  QUESTIONS: 'Questions',
+  ANSWERS: 'Answers',
+  STATISTICS: 'Statistics',
+  EVALUATIONS: 'Evaluations',
+  KNOWLEDGE_BASE: 'Knowledge_Base',
+  GENERATED_QUESTIONS: 'GeneratedQuestions',
+  SUMMARIES: 'Summaries'
+};
+
+// 教科マッピング（DifyService.jsと共有）
+const SUBJECT_MAP = {
+  jp: { id: 'jp', name: '国語' },
+  math: { id: 'math', name: '算数' },
+  sci: { id: 'sci', name: '理科' },
+  soc: { id: 'soc', name: '社会' }
+};
+
+// ============================================================================
+// エントリーポイント（HTTPリクエストハンドラ）
+// ============================================================================
+
+/**
+ * GETリクエストハンドラ（ヘルスチェック用）
+ *
+ * @param {Object} e - イベントオブジェクト
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function doGet(e) {
+  try {
+    return createJsonResponse({
+      success: true,
+      message: "超天才クイズAPI is running",
+      version: "1.0.0",
+      timestamp: new Date().toISOString()
+    });
+  } catch (error) {
+    return createErrorResponse('Internal Server Error', error.toString());
+  }
+}
+
+/**
+ * POSTリクエストハンドラ（APIエンドポイントルーター）
+ *
+ * @param {Object} e - イベントオブジェクト
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function doPost(e) {
+  try {
+    // リクエストボディのパース
+    const requestBody = JSON.parse(e.postData.contents);
+
+    // 新形式（action）と旧形式（endpoint）の両方をサポート
+    const action = requestBody.action || requestBody.endpoint || '';
+
+    // 新形式: パラメータはフラット、旧形式: params内にネスト
+    const params = requestBody.params || requestBody;
+
+    Logger.log('Received request - Action: ' + action);
+    Logger.log('Request params: ' + JSON.stringify(params));
+
+    // ==================== QuestionDatabase関連のアクション (v1.6.3) ====================
+    const questionDbActions = [
+      'get_random_answers',
+      'get_random_questions',     // Python互換: get_questions_by_configにマッピング
+      'get_questions_by_config',  // v1.6.3: ジャンル構成固定化
+      'update_usage_count',
+      'bulk_insert_answers',
+      'get_stats',
+      'reset_usage',
+      'delete_by_subject',
+      'add_header'
+    ];
+
+    if (questionDbActions.includes(action)) {
+      const result = handleQuestionDatabaseAction(action, params);
+      return ContentService.createTextOutput(JSON.stringify(result))
+        .setMimeType(ContentService.MimeType.JSON);
+    }
+
+    // アクションによる振り分け（snake_case と camelCase の両方をサポート）
+    switch (action) {
+      case 'login':
+        return handleLogin(params);
+
+      case 'register_user':
+      case 'registerUser':
+        return handleRegisterUser(params);
+
+      case 'start_session':
+      case 'startSession':
+        return handleStartSession(params);
+
+      case 'generate_question':
+      case 'generateQuestion':
+        return handleGenerateQuestion(params);
+
+      case 'generate_questions':
+      case 'generateQuestions':
+        return handleGenerateQuestions(params);
+
+      case 'submit_answers':
+      case 'submitAnswers':
+        return handleSubmitAnswers(params);
+
+      case 'get_statistics':
+      case 'getStatistics':
+        return handleGetStatistics(params);
+
+      case 'get_evaluation':
+      case 'getEvaluation':
+        return handleGetEvaluation(params);
+
+      case 'save_questions':
+        return handleSaveQuestions(params);
+
+      case 'save_summary':
+        return handleSaveSummary(params);
+
+      case 'get_session_results':
+        return handleGetSessionResults(params);
+
+      case 'check_summary_status':
+        return handleCheckSummaryStatus(params);
+
+      case 'save_evaluations':
+        return handleSaveEvaluations(params);
+
+      default:
+        return createErrorResponse('Invalid Action', 'Unknown action: ' + action);
+    }
+  } catch (error) {
+    Logger.log('Error in doPost: ' + error.toString());
+    return createErrorResponse('Bad Request', error.toString());
+  }
+}
+
+/**
+ * OPTIONSリクエストハンドラ（CORS preflight対応）
+ *
+ * @returns {TextOutput} - 空のレスポンス
+ */
+function doOptions() {
+  return ContentService
+    .createTextOutput('')
+    .setMimeType(ContentService.MimeType.TEXT)
+    .setHeader('Access-Control-Allow-Origin', '*')
+    .setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+    .setHeader('Access-Control-Allow-Headers', 'Content-Type');
+}
+
+// ============================================================================
+// エンドポイント実装（Phase 1: ダミーレスポンス）
+// ============================================================================
+
+/**
+ * ユーザー登録エンドポイント（本実装）
+ * Usersシートに新規ユーザーを追加
+ *
+ * @param {Object} params - リクエストパラメータ { username: string }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function handleRegisterUser(params) {
+  try {
+    // 1. バリデーション
+    const username = params.username;
+
+    if (!username) {
+      return createJsonResponse({
+        status: "error",
+        message: "Username is required"
+      });
+    }
+
+    if (username.length > 20) {
+      return createJsonResponse({
+        status: "error",
+        message: "Username must be 20 characters or less"
+      });
+    }
+
+    // 2. Usersシート取得
+    const sheet = getSheet(SHEET_NAMES.USERS);
+
+    // 3. 既存ユーザーチェック（存在すればログインとして扱う）
+    const data = sheet.getDataRange().getValues();
+    // ヘッダー行をスキップ（data[0]）
+    for (let i = 1; i < data.length; i++) {
+      if (data[i][1] === username) { // 列1 = username
+        // 既存ユーザーが見つかった場合、ログインとして成功を返す
+        const existingUserId = data[i][0];   // 列0 = user_id
+        const existingCreatedAt = data[i][3]; // 列3 = created_at（列2はpassword_hash）
+
+        // last_loginを更新（列4）
+        const loginTime = getTimestamp();
+        sheet.getRange(i + 1, 5).setValue(loginTime); // 行番号は1始まり、列5 = last_login
+
+        Logger.log('Existing user logged in: ' + username + ' (user_id: ' + existingUserId + ')');
+
+        return createJsonResponse({
+          status: "success",
+          message: "User logged in successfully",
+          data: {
+            user_id: existingUserId,
+            username: username,
+            created_at: existingCreatedAt,
+            last_login: loginTime,
+            is_new_user: false
+          }
+        });
+      }
+    }
+
+    // 4. 新規ユーザーデータ作成
+    const userId = generateUUID();
+    const createdAt = getTimestamp();
+    const passwordHash = params.password_hash || "";  // パスワードハッシュ（オプション）
+    const newRow = [
+      userId,           // user_id (列0)
+      username,         // username (列1)
+      passwordHash,     // password_hash (列2) ← 追加
+      createdAt,        // created_at (列3)
+      "",               // last_login (列4, 初回は空)
+      0,                // total_sessions (列5)
+      0,                // total_questions (列6)
+      "{}"              // settings (列7)
+    ];
+
+    // 5. Sheetsに書き込み
+    sheet.appendRow(newRow);
+
+    // 6. 成功レスポンス
+    Logger.log('New user registered: ' + username + ' (user_id: ' + userId + ')');
+
+    return createJsonResponse({
+      status: "success",
+      message: "User registered successfully",
+      data: {
+        user_id: userId,
+        username: username,
+        created_at: createdAt,
+        is_new_user: true
+      }
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleRegisterUser: ' + error.toString());
+    return createErrorResponse('Registration Failed', error.toString());
+  }
+}
+
+/**
+ * ログインエンドポイント（パスワードハッシュ取得）
+ * ユーザー名でUsersシートを検索し、password_hashを返す
+ *
+ * @param {Object} params - リクエストパラメータ { username: string }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function handleLogin(params) {
+  try {
+    const username = params.username;
+
+    if (!username) {
+      return createJsonResponse({
+        success: false,
+        error: "Username is required"
+      });
+    }
+
+    // Usersシート取得
+    const sheet = getSheet(SHEET_NAMES.USERS);
+    const data = sheet.getDataRange().getValues();
+
+    // ヘッダー行をスキップして検索
+    // 列構造: 0=user_id, 1=username, 2=password_hash, 3=created_at, 4=last_login, ...
+    for (let i = 1; i < data.length; i++) {
+      if (data[i][1] === username) { // 列1 = username
+        const userId = data[i][0];        // 列0 = user_id
+        const passwordHash = data[i][2];  // 列2 = password_hash
+
+        // last_loginを更新（列4）
+        const loginTime = getTimestamp();
+        sheet.getRange(i + 1, 5).setValue(loginTime); // 行番号は1始まり、列5(index 4) = last_login
+
+        Logger.log('User found for login: ' + username + ', password_hash exists: ' + (!!passwordHash));
+
+        return createJsonResponse({
+          success: true,
+          found: true,
+          data: {
+            user_id: userId,
+            username: username,
+            password_hash: passwordHash
+          }
+        });
+      }
+    }
+
+    // ユーザーが見つからない場合
+    Logger.log('User not found for login: ' + username);
+    return createJsonResponse({
+      success: true,
+      found: false,
+      message: "User not found"
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleLogin: ' + error.toString());
+    return createErrorResponse('Login Failed', error.toString());
+  }
+}
+
+/**
+ * セッション開始エンドポイント（本実装）
+ *
+ * @param {Object} params - リクエストパラメータ { user_id: string, subjects: string[] }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function handleStartSession(params) {
+  try {
+    Logger.log('handleStartSession called with params: ' + JSON.stringify(params));
+
+    const userId = params.user_id;
+    const subjects = params.subjects || [];
+
+    if (!userId) {
+      return createJsonResponse({
+        success: false,
+        error: 'user_id is required'
+      });
+    }
+
+    // セッションデータ作成
+    const sessionId = generateUUID();
+    const startTime = getTimestamp();
+
+    const sessionsSheet = getSheet(SHEET_NAMES.SESSIONS);
+    const row = [
+      sessionId,              // session_id
+      userId,                 // user_id
+      startTime,              // start_time
+      '',                     // end_time (セッション終了時に更新)
+      JSON.stringify(subjects), // subjects
+      0,                      // total_score (セッション終了時に計算)
+      false                   // completed
+    ];
+    sessionsSheet.appendRow(row);
+
+    return createJsonResponse({
+      success: true,
+      data: {
+        session_id: sessionId,
+        user_id: userId,
+        subjects: subjects,
+        start_time: startTime
+      }
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleStartSession: ' + error.toString());
+    return createErrorResponse('Session Start Failed', error.toString());
+  }
+}
+
+/**
+ * 問題生成エンドポイント（旧版、互換性のため残す）
+ * Phase 1: ダミー問題返却（Gemini API統合はPhase 2）
+ *
+ * @param {Object} params - リクエストパラメータ { session_id: string, subjects: string[] }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function handleGenerateQuestion(params) {
+  try {
+    Logger.log('handleGenerateQuestion called with params: ' + JSON.stringify(params));
+
+    // Phase 1: ダミー問題データ
+    const dummyQuestion = {
+      question_id: 'dummy-question-001',
+      session_id: params.session_id || 'dummy-session-001',
+      subject: '国語',
+      topic: '漢字の読み',
+      difficulty: 3,
+      question_text: '次の漢字の読みを選びなさい：「薔薇」',
+      choices: ['ばら', 'しょうび', 'そうび', 'ばいか'],
+      correct_answer: 0,
+      created_at: new Date().toISOString()
+    };
+
+    const dummyResponse = {
+      success: true,
+      message: 'Question generated (dummy)',
+      data: {
+        question: dummyQuestion
+      }
+    };
+
+    return createJsonResponse(dummyResponse);
+  } catch (error) {
+    Logger.log('Error in handleGenerateQuestion: ' + error.toString());
+    return createErrorResponse('Question Generation Failed', error.toString());
+  }
+}
+
+/**
+ * 問題生成エンドポイント（Dify統合版・並列処理対応）
+ *
+ * @param {Object} params - { session_id: string, subjects: string[] }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function handleGenerateQuestions(params) {
+  try {
+    Logger.log('handleGenerateQuestions called with params: ' + JSON.stringify(params));
+
+    const sessionId = params.session_id;
+    const subjects = params.subjects || [];
+
+    if (!sessionId) {
+      return createJsonResponse({
+        success: false,
+        error: 'session_id is required'
+      });
+    }
+
+    if (subjects.length === 0) {
+      return createJsonResponse({
+        success: false,
+        error: 'subjects array is required'
+      });
+    }
+
+    const allQuestions = [];
+    const questionsSheet = getSheet(SHEET_NAMES.QUESTIONS);
+
+    // === 並列処理: 全教科のDify APIリクエストを同時実行 ===
+    Logger.log('Generating questions for ' + subjects.length + ' subjects in PARALLEL');
+    const startTime = new Date().getTime();
+
+    // 全教科のリクエスト設定を準備
+    const requestConfigs = subjects.map(function(subject) {
+      return {
+        action: 'generate_questions',
+        subject: subject,
+        additionalInputs: {
+          statistics: JSON.stringify({}),
+          recent_questions: JSON.stringify([])
+        }
+      };
+    });
+
+    // 並列でDify APIを呼び出し
+    const difyResponses = callDifyWorkflowBatch(requestConfigs);
+
+    const endTime = new Date().getTime();
+    Logger.log('Parallel API calls completed in ' + ((endTime - startTime) / 1000) + ' seconds');
+
+    // === レスポンス処理: 各教科の問題を保存 ===
+    for (var i = 0; i < subjects.length; i++) {
+      var subject = subjects[i];
+      var response = difyResponses[i];
+
+      try {
+        // エラーチェック
+        if (response.error) {
+          Logger.log('Error in response for ' + subject + ': ' + response.message);
+          continue;
+        }
+
+        // Difyレスポンスから問題データを抽出
+        var questions = parseQuestionsFromDifyResponse(subject, response);
+
+        // 各問題をシートに保存し、レスポンス用配列に追加
+        for (var j = 0; j < questions.length; j++) {
+          var q = questions[j];
+          var questionId = generateUUID();
+          var createdAt = getTimestamp();
+
+          // Questionsシートに保存（10列: data-model.md v2.0準拠）
+          // Difyは correct_answer を返すが、互換性のため correct もチェック
+          var correctAnswer = q.correct_answer !== undefined ? q.correct_answer : q.correct;
+
+          var row = [
+            questionId,                // question_id
+            sessionId,                 // session_id
+            subject,                   // subject
+            q.category || '',          // category
+            q.difficulty || '標準',    // difficulty (基本/標準/応用)
+            q.question,                // question_text
+            JSON.stringify(q.choices), // choices (JSON)
+            correctAnswer,             // correct_answer
+            q.explanation || '',       // explanation
+            createdAt                  // created_at
+          ];
+          questionsSheet.appendRow(row);
+
+          // レスポンス用に問題データを追加
+          allQuestions.push({
+            question_id: questionId,
+            subject: subject,
+            subject_name: SUBJECT_MAP[subject] ? SUBJECT_MAP[subject].name : subject,
+            category: q.category || '',
+            question: q.question,
+            choices: q.choices,
+            correct: correctAnswer,
+            difficulty: q.difficulty || 3
+          });
+        }
+
+        Logger.log('Generated ' + questions.length + ' questions for ' + subject);
+
+      } catch (subjectError) {
+        Logger.log('Error processing questions for ' + subject + ': ' + subjectError.toString());
+        // 個別教科のエラーは続行（他の教科は処理する）
+      }
+    }
+
+    if (allQuestions.length === 0) {
+      return createJsonResponse({
+        success: false,
+        error: 'Failed to generate questions for any subject'
+      });
+    }
+
+    var totalTime = (new Date().getTime() - startTime) / 1000;
+    Logger.log('Total question generation time: ' + totalTime + ' seconds for ' + allQuestions.length + ' questions');
+
+    return createJsonResponse({
+      success: true,
+      data: {
+        session_id: sessionId,
+        questions: allQuestions,
+        total_count: allQuestions.length
+      }
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleGenerateQuestions: ' + error.toString());
+    return createErrorResponse('Question Generation Failed', error.toString());
+  }
+}
+
+/**
+ * Difyレスポンスから問題データをパース（並列処理用ヘルパー）
+ *
+ * @param {string} subject - 教科ID
+ * @param {Object} response - Dify APIレスポンス
+ * @returns {Array} - 問題配列
+ */
+function parseQuestionsFromDifyResponse(subject, response) {
+  if (response.data && response.data.outputs) {
+    var outputs = response.data.outputs;
+
+    // エラーチェック
+    if (outputs.action_error) {
+      throw new Error('Dify action error: ' + outputs.action_error);
+    }
+    if (outputs.subject_error_questions) {
+      throw new Error('Dify subject error: ' + outputs.subject_error_questions);
+    }
+
+    // 教科別の出力変数名を取得（DifyService.jsで定義）
+    var outputKeyMap = {
+      'jp': 'kokugo_questions',
+      'math': 'sansu_questions',
+      'sci': 'rika_questions',
+      'soc': 'shakai_questions'
+    };
+
+    var outputKey = outputKeyMap[subject];
+    if (!outputKey || !outputs[outputKey]) {
+      throw new Error('Output key not found: ' + outputKey + ', available: ' + Object.keys(outputs).join(', '));
+    }
+
+    var questionsData = outputs[outputKey];
+
+    // JSON文字列の場合はパース
+    if (typeof questionsData === 'string') {
+      var parsed = JSON.parse(questionsData);
+      return parsed.questions || parsed;
+    }
+
+    // 既にオブジェクト/配列の場合
+    return questionsData.questions || questionsData;
+  }
+
+  throw new Error('Invalid response format from Dify');
+}
+
+/**
+ * 解答送信エンドポイント（本実装）
+ *
+ * v1.6.5以降: フロントエンドから送られるcorrect_answerを使用してスコアリング
+ *
+ * @param {Object} params - {
+ *   session_id: string,
+ *   answers: [{
+ *     question_id,
+ *     selected_answer,
+ *     user_answer,
+ *     correct_answer,
+ *     subject,
+ *     category,
+ *     time_taken_seconds
+ *   }]
+ * }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function handleSubmitAnswers(params) {
+  try {
+    Logger.log('handleSubmitAnswers called with params: ' + JSON.stringify(params));
+
+    const sessionId = params.session_id;
+    const answers = params.answers || [];
+
+    if (!sessionId) {
+      return createJsonResponse({
+        success: false,
+        error: 'session_id is required'
+      });
+    }
+
+    if (!Array.isArray(answers) || answers.length === 0) {
+      return createJsonResponse({
+        success: false,
+        error: 'answers array is required and must not be empty'
+      });
+    }
+
+    const answersSheet = getSheet(SHEET_NAMES.ANSWERS);
+
+    // 統計用のデータ構造（教科・分野別に集計）
+    const statsBySubjectCategory = {};
+    let correctCount = 0;
+    let totalCount = answers.length;
+
+    // 各回答を処理
+    for (let i = 0; i < answers.length; i++) {
+      const answer = answers[i];
+      const questionId = answer.question_id;
+      const userAnswer = answer.user_answer || answer.selected_answer; // user_answerを優先、なければselected_answer
+      const correctAnswer = answer.correct_answer; // フロントエンドから送られる正答
+      const subject = answer.subject;
+      const category = answer.category;
+      const timeTaken = answer.time_taken_seconds || 0;
+
+      // フロントエンドからcorrect_answerが送られていない場合はエラー
+      if (correctAnswer === undefined || correctAnswer === null) {
+        Logger.log('Warning: correct_answer missing for question_id: ' + questionId);
+        continue;
+      }
+
+      // 正誤判定（フロントエンドから送られるcorrect_answerを使用）
+      const isCorrect = (userAnswer === correctAnswer);
+      if (isCorrect) {
+        correctCount++;
+      }
+
+      // Answersシートに書き込み
+      const answerId = generateUUID();
+      const answeredAt = getTimestamp();
+      const answerRow = [
+        answerId,         // answer_id
+        sessionId,        // session_id
+        questionId,       // question_id
+        subject || '',    // subject
+        category || '',   // category
+        userAnswer,       // user_answer
+        correctAnswer,    // correct_answer
+        isCorrect,        // is_correct
+        timeTaken,        // time_spent
+        answeredAt        // submitted_at
+      ];
+      answersSheet.appendRow(answerRow);
+
+      // 統計用データ集計（subject/categoryがある場合のみ）
+      if (subject && category) {
+        const key = subject + '|' + category;
+        if (!statsBySubjectCategory[key]) {
+          statsBySubjectCategory[key] = {
+            subject: subject,
+            category: category,
+            attempted: 0,
+            correct: 0
+          };
+        }
+        statsBySubjectCategory[key].attempted++;
+        if (isCorrect) {
+          statsBySubjectCategory[key].correct++;
+        }
+      }
+    }
+
+    // スコア計算（0-100）
+    const score = Math.round((correctCount / totalCount) * 100);
+
+    // Sessionsシート更新（total_score, end_time, completed）
+    const sessionsSheet = getSheet(SHEET_NAMES.SESSIONS);
+    const sessionsData = sessionsSheet.getDataRange().getValues();
+    for (let i = 1; i < sessionsData.length; i++) {
+      if (sessionsData[i][0] === sessionId) {
+        const endTime = getTimestamp();
+        sessionsSheet.getRange(i + 1, 4).setValue(endTime);      // end_time
+        sessionsSheet.getRange(i + 1, 6).setValue(score);        // total_score
+        sessionsSheet.getRange(i + 1, 7).setValue(true);         // completed
+        break;
+      }
+    }
+
+    // Statisticsシート更新
+    const userId = getUserIdFromSession(sessionId);
+    if (userId) {
+      updateStatistics(userId, statsBySubjectCategory);
+
+      // Usersシートのtotal_sessionsとtotal_questionsを更新
+      updateUserStats(userId, 1, totalCount);
+    }
+
+    // デバッグログ (v1.6.12)
+    console.log('[handleSubmitAnswers] Response data:', JSON.stringify({
+      session_id: sessionId,
+      total: totalCount,
+      correct: correctCount,
+      accuracy: score,
+      answers_saved: answers.length
+    }));
+
+    return createJsonResponse({
+      success: true,
+      data: {
+        session_id: sessionId,
+        total: totalCount,
+        correct: correctCount,
+        accuracy: score,
+        answers_saved: answers.length
+      }
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleSubmitAnswers: ' + error.toString());
+    return createErrorResponse('Submit Answers Failed', error.toString());
+  }
+}
+
+/**
+ * 統計取得エンドポイント（ジャンル別累積集計対応版）
+ *
+ * @param {Object} params - { user_id: string, subjects?: string[] }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ *
+ * レスポンス形式:
+ * {
+ *   success: true,
+ *   data: {
+ *     user_id: string,
+ *     subjects: [
+ *       {
+ *         subject: string,
+ *         subject_name: string,
+ *         total_attempted: number,
+ *         total_correct: number,
+ *         overall_accuracy: number,
+ *         genres: [
+ *           { genre_id: string, genre_name: string, attempted: number, correct: number, accuracy: number },
+ *           ...
+ *         ]
+ *       },
+ *       ...
+ *     ],
+ *     cumulative: {
+ *       total_sessions: number,
+ *       total_questions: number,
+ *       total_correct: number,
+ *       overall_accuracy: number
+ *     }
+ *   }
+ * }
+ */
+function handleGetStatistics(params) {
+  try {
+    Logger.log('handleGetStatistics called with params: ' + JSON.stringify(params));
+
+    const userId = params.user_id;
+    const subjects = params.subjects || null;
+
+    if (!userId) {
+      return createJsonResponse({
+        success: false,
+        error: 'user_id is required'
+      });
+    }
+
+    const statisticsSheet = getSheet(SHEET_NAMES.STATISTICS);
+    const data = statisticsSheet.getDataRange().getValues();
+
+    // ヘッダー行をスキップして該当ユーザーの統計を取得
+    const userStats = [];
+    for (let i = 1; i < data.length; i++) {
+      const row = data[i];
+      const rowUserId = row[1];      // user_id
+      const rowSubject = row[2];     // subject
+
+      // user_idが一致し、subjects指定がある場合はそれも確認
+      if (rowUserId === userId) {
+        if (!subjects || subjects.includes(rowSubject)) {
+          userStats.push({
+            stat_id: row[0],           // stat_id
+            user_id: row[1],           // user_id
+            subject: row[2],           // subject
+            category: row[3],          // category（ジャンルID）
+            total_attempted: row[4],   // total_attempted
+            correct_count: row[5],     // correct_count
+            accuracy_rate: row[6],     // accuracy_rate
+            last_updated: row[7]       // last_updated
+          });
+        }
+      }
+    }
+
+    // 教科別・ジャンル別にグループ化
+    const bySubject = {};
+    let cumulativeTotalAttempted = 0;
+    let cumulativeTotalCorrect = 0;
+
+    for (let i = 0; i < userStats.length; i++) {
+      const stat = userStats[i];
+      const subject = stat.subject;
+      const genreId = stat.category; // categoryフィールドをジャンルIDとして扱う
+
+      if (!bySubject[subject]) {
+        bySubject[subject] = {
+          subject: subject,
+          subject_name: SUBJECT_MAP[subject] ? SUBJECT_MAP[subject].name : subject,
+          genres: [],
+          total_attempted: 0,
+          total_correct: 0,
+          overall_accuracy: 0
+        };
+      }
+
+      // GenreMaster.jsからジャンル情報を取得
+      const genreInfo = getGenreById(genreId);
+      const genreName = genreInfo ? genreInfo.name : '不明';
+
+      bySubject[subject].genres.push({
+        genre_id: genreId,
+        genre_name: genreName,
+        attempted: stat.total_attempted,
+        correct: stat.correct_count,
+        accuracy: stat.accuracy_rate
+      });
+
+      bySubject[subject].total_attempted += stat.total_attempted;
+      bySubject[subject].total_correct += stat.correct_count;
+
+      // 累積統計用
+      cumulativeTotalAttempted += stat.total_attempted;
+      cumulativeTotalCorrect += stat.correct_count;
+    }
+
+    // 教科別の正答率を計算
+    const subjectsArray = [];
+    for (const subjectId in bySubject) {
+      const subjectData = bySubject[subjectId];
+      if (subjectData.total_attempted > 0) {
+        subjectData.overall_accuracy = subjectData.total_correct / subjectData.total_attempted;
+      }
+
+      // ジャンルを正答率の低い順にソート（苦手なジャンル順）
+      subjectData.genres = sortByWeakness(subjectData.genres);
+
+      subjectsArray.push(subjectData);
+    }
+
+    // レーダーチャート用データ（教科別正答率）
+    const radarChartData = {
+      labels: [],
+      values: []
+    };
+    for (let i = 0; i < subjectsArray.length; i++) {
+      radarChartData.labels.push(subjectsArray[i].subject_name);
+      radarChartData.values.push(Math.round(subjectsArray[i].overall_accuracy * 100));
+    }
+
+    // セッション数を取得
+    const totalSessions = getUserSessionCount(userId);
+
+    // 累積統計
+    const cumulativeStats = {
+      total_sessions: totalSessions,
+      total_questions: cumulativeTotalAttempted,
+      total_correct: cumulativeTotalCorrect,
+      overall_accuracy: cumulativeTotalAttempted > 0 ? cumulativeTotalCorrect / cumulativeTotalAttempted : 0
+    };
+
+    return createJsonResponse({
+      success: true,
+      data: {
+        user_id: userId,
+        subjects: subjectsArray,
+        radar_chart: radarChartData,
+        cumulative: cumulativeStats
+      }
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleGetStatistics: ' + error.toString());
+    return createErrorResponse('Get Statistics Failed', error.toString());
+  }
+}
+
+/**
+ * 評価取得エンドポイント（本実装）
+ *
+ * @param {Object} params - { session_id: string, subjects?: string[] }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ *
+ * 処理フロー:
+ * 1. Statisticsシートから統計データを取得
+ * 2. Answers/Questionsシートから解答結果を取得
+ * 3. 各教科に対してDify評価生成を呼び出し
+ * 4. 全体評価も生成（すべての教科の結果を統合）
+ * 5. Evaluationsシートへ書き込み
+ */
+function handleGetEvaluation(params) {
+  try {
+    Logger.log('handleGetEvaluation called with params: ' + JSON.stringify(params));
+
+    const sessionId = params.session_id;
+    const requestedSubjects = params.subjects || null;
+
+    if (!sessionId) {
+      return createJsonResponse({
+        success: false,
+        error: 'session_id is required'
+      });
+    }
+
+    // セッション情報取得
+    const userId = getUserIdFromSession(sessionId);
+    if (!userId) {
+      return createJsonResponse({
+        success: false,
+        error: 'Session not found'
+      });
+    }
+
+    // 統計データ取得
+    const statisticsSheet = getSheet(SHEET_NAMES.STATISTICS);
+    const statsData = statisticsSheet.getDataRange().getValues();
+    const userStatistics = {};
+
+    for (let i = 1; i < statsData.length; i++) {
+      const row = statsData[i];
+      const statUserId = row[1];
+      const statSubject = row[2];
+
+      if (statUserId === userId) {
+        if (!userStatistics[statSubject]) {
+          userStatistics[statSubject] = {
+            subject: statSubject,
+            categories: []
+          };
+        }
+        userStatistics[statSubject].categories.push({
+          category: row[3],
+          total_attempted: row[4],
+          correct_count: row[5],
+          accuracy_rate: row[6]
+        });
+      }
+    }
+
+    // セッションの解答結果を取得
+    const sessionResults = getSessionResults(sessionId);
+
+    if (sessionResults.length === 0) {
+      return createJsonResponse({
+        success: false,
+        error: 'No answers found for this session'
+      });
+    }
+
+    // 教科別にグループ化
+    const resultsBySubject = {};
+    for (let i = 0; i < sessionResults.length; i++) {
+      const result = sessionResults[i];
+      const subject = result.subject;
+
+      if (!resultsBySubject[subject]) {
+        resultsBySubject[subject] = [];
+      }
+      resultsBySubject[subject].push(result);
+    }
+
+    const evaluations = [];
+    const evaluationsSheet = getSheet(SHEET_NAMES.EVALUATIONS);
+
+    // 教科別評価を収集するオブジェクト（全体評価用）
+    const subjectEvaluations = {};
+
+    // 各教科の評価を生成
+    const subjects = requestedSubjects || Object.keys(resultsBySubject);
+    for (let i = 0; i < subjects.length; i++) {
+      const subject = subjects[i];
+      const results = resultsBySubject[subject] || [];
+
+      if (results.length === 0) {
+        Logger.log('No results found for subject: ' + subject);
+        continue;
+      }
+
+      try {
+        // Dify APIで評価生成
+        const statistics = userStatistics[subject] || { subject: subject, categories: [] };
+        const evaluation = generateEvaluationFromDify(subject, statistics, results);
+
+        // 教科別評価を収集（全体評価生成時に使用）
+        subjectEvaluations[subject] = {
+          subject: subject,
+          subject_name: SUBJECT_MAP[subject] ? SUBJECT_MAP[subject].name : subject,
+          advice: evaluation.advice || '',
+          strengths: evaluation.strengths || [],
+          weaknesses: evaluation.weaknesses || [],
+          recommended_topics: evaluation.recommended_topics || []
+        };
+
+        // Evaluationsシートに書き込み
+        const evaluationId = generateUUID();
+        const createdAt = getTimestamp();
+
+        // 教科別評価: evaluation_id, session_id, subject, advice, strengths, weaknesses, recommended_topics, created_at
+        const strengthsJson = JSON.stringify(evaluation.strengths || []);
+        const weaknessesJson = JSON.stringify(evaluation.weaknesses || []);
+        const recommendedTopicsJson = JSON.stringify(evaluation.recommended_topics || []);
+
+        const row = [
+          evaluationId,
+          sessionId,
+          subject,
+          evaluation.advice || '',
+          strengthsJson,
+          weaknessesJson,
+          recommendedTopicsJson,
+          createdAt
+        ];
+        evaluationsSheet.appendRow(row);
+
+        evaluations.push({
+          evaluation_id: evaluationId,
+          subject: subject,
+          subject_name: SUBJECT_MAP[subject] ? SUBJECT_MAP[subject].name : subject,
+          advice: evaluation.advice || '',
+          strengths: evaluation.strengths || [],
+          weaknesses: evaluation.weaknesses || [],
+          recommended_topics: evaluation.recommended_topics || [],
+          created_at: createdAt
+        });
+
+        Logger.log('Evaluation generated for ' + subject);
+
+      } catch (subjectError) {
+        Logger.log('Error generating evaluation for ' + subject + ': ' + subjectError.toString());
+        // 個別教科のエラーは続行
+      }
+    }
+
+    // 全体評価を生成（複数教科の場合）
+    if (subjects.length > 1) {
+      try {
+        // 全統計・全結果を統合
+        const overallStatistics = {
+          subjects: userStatistics
+        };
+        const overallResults = sessionResults;
+
+        // 教科別評価も渡す（第4引数）
+        const overallEvaluation = generateEvaluationFromDify('overall', overallStatistics, overallResults, subjectEvaluations);
+
+        // Evaluationsシートに書き込み（subject = 'overall'）
+        const evaluationId = generateUUID();
+        const createdAt = getTimestamp();
+
+        const strengthsJson = JSON.stringify(overallEvaluation.strengths || []);
+        const weaknessesJson = JSON.stringify(overallEvaluation.weaknesses || []);
+        const nextStepsJson = JSON.stringify(overallEvaluation.next_steps || []);
+
+        const row = [
+          evaluationId,
+          sessionId,
+          'overall',
+          overallEvaluation.overall_advice || '',
+          strengthsJson,
+          weaknessesJson,
+          nextStepsJson,
+          createdAt
+        ];
+        evaluationsSheet.appendRow(row);
+
+        evaluations.push({
+          evaluation_id: evaluationId,
+          subject: 'overall',
+          subject_name: '全体評価',
+          advice: overallEvaluation.overall_advice || '',
+          strengths: overallEvaluation.strengths || [],
+          weaknesses: overallEvaluation.weaknesses || [],
+          next_steps: overallEvaluation.next_steps || [],
+          created_at: createdAt
+        });
+
+        Logger.log('Overall evaluation generated');
+
+      } catch (overallError) {
+        Logger.log('Error generating overall evaluation: ' + overallError.toString());
+        // 全体評価のエラーは無視（教科別評価は返す）
+      }
+    }
+
+    return createJsonResponse({
+      success: true,
+      data: {
+        session_id: sessionId,
+        evaluations: evaluations,
+        total_count: evaluations.length
+      }
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleGetEvaluation: ' + error.toString());
+    return createErrorResponse('Get Evaluation Failed', error.toString());
+  }
+}
+
+/**
+ * 問題保存エンドポイント（v1.6.5新規）
+ * 生成された問題をGeneratedQuestionsシートに保存
+ *
+ * @param {Object} params - { session_id: string, subject: string, questions: Array }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function handleSaveQuestions(params) {
+  try {
+    Logger.log('handleSaveQuestions called with params: ' + JSON.stringify(params));
+
+    const sessionId = params.session_id;
+    const subject = params.subject;
+    const questions = params.questions || [];
+
+    if (!sessionId) {
+      return createJsonResponse({
+        success: false,
+        error: 'session_id is required'
+      });
+    }
+
+    if (!subject) {
+      return createJsonResponse({
+        success: false,
+        error: 'subject is required'
+      });
+    }
+
+    if (!Array.isArray(questions) || questions.length === 0) {
+      return createJsonResponse({
+        success: false,
+        error: 'questions array is required and must not be empty'
+      });
+    }
+
+    // GeneratedQuestionsシート取得（なければ作成）
+    const sheet = getOrCreateSheet(SHEET_NAMES.GENERATED_QUESTIONS, [
+      'question_id',
+      'session_id',
+      'subject',
+      'genre_id',
+      'answer',
+      'question_text',
+      'choices',
+      'correct_answer',
+      'difficulty',
+      'created_at'
+    ]);
+
+    const timestamp = getTimestamp();
+    const savedQuestions = [];
+
+    // 各問題を保存
+    for (let i = 0; i < questions.length; i++) {
+      const q = questions[i];
+      const questionId = q.question_id || generateUUID();
+
+      // 行データ作成
+      const row = [
+        questionId,                           // question_id
+        sessionId,                            // session_id
+        subject,                              // subject
+        q.genre_id || q.category || '',       // genre_id
+        q.answer || '',                       // answer
+        q.question || q.question_text || '',  // question_text
+        JSON.stringify(q.choices || []),      // choices (JSON)
+        q.correct_answer !== undefined ? q.correct_answer : q.correct, // correct_answer
+        q.difficulty || '標準',              // difficulty
+        timestamp                             // created_at
+      ];
+
+      sheet.appendRow(row);
+
+      // レスポンス用データ
+      savedQuestions.push({
+        question_id: questionId,
+        subject: subject,
+        genre_id: q.genre_id || q.category || '',
+        question: q.question || q.question_text || ''
+      });
+
+      Logger.log('Saved question: ' + questionId + ' for subject: ' + subject);
+    }
+
+    return createJsonResponse({
+      success: true,
+      data: {
+        questions: savedQuestions,
+        saved_count: savedQuestions.length
+      }
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleSaveQuestions: ' + error.toString());
+    return createErrorResponse('Save Questions Failed', error.toString());
+  }
+}
+
+/**
+ * サマリー保存エンドポイント（v1.6.5新規）
+ * 問題要約をSummariesシートに保存
+ *
+ * @param {Object} params - { session_id: string, subject: string, summary_data: Object }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function handleSaveSummary(params) {
+  try {
+    Logger.log('handleSaveSummary called with params: ' + JSON.stringify(params));
+
+    const sessionId = params.session_id;
+    const subject = params.subject;
+    const summaryData = params.summary_data || {};
+
+    if (!sessionId) {
+      return createJsonResponse({
+        success: false,
+        error: 'session_id is required'
+      });
+    }
+
+    if (!subject) {
+      return createJsonResponse({
+        success: false,
+        error: 'subject is required'
+      });
+    }
+
+    // Summariesシート取得（なければ作成）
+    const sheet = getOrCreateSheet(SHEET_NAMES.SUMMARIES, [
+      'summary_id',
+      'session_id',
+      'subject',
+      'keywords',
+      'topics',
+      'summary',
+      'created_at'
+    ]);
+
+    const summaryId = generateUUID();
+    const timestamp = getTimestamp();
+
+    // 行データ作成
+    const row = [
+      summaryId,                                          // summary_id
+      sessionId,                                          // session_id
+      subject,                                            // subject
+      JSON.stringify(summaryData.keywords || []),         // keywords (JSON)
+      JSON.stringify(summaryData.topics || []),           // topics (JSON)
+      summaryData.summary || '',                          // summary
+      timestamp                                           // created_at
+    ];
+
+    sheet.appendRow(row);
+
+    Logger.log('Saved summary: ' + summaryId + ' for session: ' + sessionId + ', subject: ' + subject);
+
+    return createJsonResponse({
+      success: true,
+      data: {
+        summary_id: summaryId,
+        session_id: sessionId,
+        subject: subject
+      }
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleSaveSummary: ' + error.toString());
+    return createErrorResponse('Save Summary Failed', error.toString());
+  }
+}
+
+// ============================================================================
+// ユーティリティ関数
+// ============================================================================
+
+/**
+ * UsersシートのユーザーStatistics(total_sessions, total_questions)を更新
+ *
+ * @param {string} userId - ユーザーID
+ * @param {number} sessionsIncrement - セッション数の増分（通常1）
+ * @param {number} questionsIncrement - 問題数の増分
+ */
+function updateUserStats(userId, sessionsIncrement, questionsIncrement) {
+  try {
+    const usersSheet = getSheet(SHEET_NAMES.USERS);
+    const data = usersSheet.getDataRange().getValues();
+
+    // ユーザーを検索して更新
+    for (let i = 1; i < data.length; i++) {
+      if (data[i][0] === userId) { // user_id (列0)
+        const currentSessions = data[i][4] || 0;    // total_sessions (列4 = E列)
+        const currentQuestions = data[i][5] || 0;   // total_questions (列5 = F列)
+
+        const newSessions = currentSessions + sessionsIncrement;
+        const newQuestions = currentQuestions + questionsIncrement;
+
+        // E列(total_sessions)とF列(total_questions)を更新
+        usersSheet.getRange(i + 1, 5).setValue(newSessions);   // 列5 = E列
+        usersSheet.getRange(i + 1, 6).setValue(newQuestions);  // 列6 = F列
+
+        Logger.log('Updated user stats for ' + userId + ': sessions=' + newSessions + ', questions=' + newQuestions);
+        return;
+      }
+    }
+
+    Logger.log('User not found for stats update: ' + userId);
+
+  } catch (error) {
+    Logger.log('Error in updateUserStats: ' + error.toString());
+  }
+}
+
+/**
+ * セッションIDからユーザーIDを取得
+ *
+ * @param {string} sessionId - セッションID
+ * @returns {string|null} - ユーザーID（見つからない場合null）
+ */
+function getUserIdFromSession(sessionId) {
+  try {
+    const sessionsSheet = getSheet(SHEET_NAMES.SESSIONS);
+    const data = sessionsSheet.getDataRange().getValues();
+
+    for (let i = 1; i < data.length; i++) {
+      if (data[i][0] === sessionId) { // session_id
+        return data[i][1]; // user_id
+      }
+    }
+    return null;
+  } catch (error) {
+    Logger.log('Error in getUserIdFromSession: ' + error.toString());
+    return null;
+  }
+}
+
+/**
+ * ユーザーのセッション総数を取得
+ *
+ * @param {string} userId - ユーザーID
+ * @returns {number} - セッション総数
+ */
+function getUserSessionCount(userId) {
+  try {
+    const sessionsSheet = getSheet(SHEET_NAMES.SESSIONS);
+    const data = sessionsSheet.getDataRange().getValues();
+
+    let count = 0;
+    for (let i = 1; i < data.length; i++) {
+      if (data[i][1] === userId) { // user_id
+        count++;
+      }
+    }
+    return count;
+  } catch (error) {
+    Logger.log('Error in getUserSessionCount: ' + error.toString());
+    return 0;
+  }
+}
+
+/**
+ * ジャンル統計を苦手順（正答率昇順）にソート
+ *
+ * @param {Array} genreStats - ジャンル統計配列 [{ genre_id, genre_name, attempted, correct, accuracy }]
+ * @returns {Array} - 正答率昇順でソートされた配列
+ */
+function sortByWeakness(genreStats) {
+  if (!Array.isArray(genreStats)) {
+    return [];
+  }
+
+  return genreStats.sort(function(a, b) {
+    return a.accuracy - b.accuracy; // 正答率昇順（苦手なジャンルが上位）
+  });
+}
+
+/**
+ * セッションの解答結果を取得
+ *
+ * @param {string} sessionId - セッションID
+ * @returns {Array} - 解答結果配列
+ *
+ * 結果配列の各要素:
+ * {
+ *   question_id: string,
+ *   subject: string,
+ *   category: string,
+ *   question_text: string,
+ *   user_answer: number,
+ *   correct_answer: number,
+ *   is_correct: boolean,
+ *   time_taken: number
+ * }
+ */
+function getSessionResults(sessionId) {
+  try {
+    const answersSheet = getSheet(SHEET_NAMES.ANSWERS);
+    const questionsSheet = getSheet(SHEET_NAMES.GENERATED_QUESTIONS);
+    const answersData = answersSheet.getDataRange().getValues();
+    const questionsData = questionsSheet.getDataRange().getValues();
+
+    // Questionsデータをマップ化（高速検索用）
+    const questionsMap = {};
+    for (let i = 1; i < questionsData.length; i++) {
+      const questionId = questionsData[i][0];
+      questionsMap[questionId] = {
+        session_id: questionsData[i][1],
+        subject: questionsData[i][2],
+        category: questionsData[i][3],
+        difficulty: questionsData[i][8],
+        question_text: questionsData[i][5],
+        choices: questionsData[i][6],
+        correct_answer: questionsData[i][7],
+        explanation: '',
+        created_at: questionsData[i][9]
+      };
+    }
+
+    const results = [];
+
+    // Answersシートから該当セッションの解答を取得
+    for (let i = 1; i < answersData.length; i++) {
+      const row = answersData[i];
+      const answerSessionId = row[1]; // session_id
+
+      if (answerSessionId === sessionId) {
+        const questionId = row[2];    // question_id
+        const userAnswer = row[5];    // user_answer (F列)
+        const isCorrect = row[7];     // is_correct (H列)
+        const timeTaken = row[8];     // time_spent (I列)
+
+        // 対応する問題データを取得
+        const question = questionsMap[questionId];
+        if (question) {
+          results.push({
+            question_id: questionId,
+            subject: question.subject,
+            category: question.category,
+            difficulty: question.difficulty,
+            question_text: question.question_text,
+            user_answer: userAnswer,
+            correct_answer: question.correct_answer,
+            is_correct: isCorrect,
+            time_taken: timeTaken
+          });
+        }
+      }
+    }
+
+    Logger.log('getSessionResults: Found ' + results.length + ' results for session ' + sessionId);
+    return results;
+
+  } catch (error) {
+    Logger.log('Error in getSessionResults: ' + error.toString());
+    return [];
+  }
+}
+
+/**
+ * セッション結果取得エンドポイント（評価生成用）
+ *
+ * @param {Object} params - { session_id: string }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ *
+ * レスポンス形式:
+ * {
+ *   success: true,
+ *   data: {
+ *     session_id: string,
+ *     results: [
+ *       {
+ *         question_id: string,
+ *         subject: string,
+ *         category: string,
+ *         difficulty: string,
+ *         question_text: string,
+ *         user_answer: number,
+ *         correct_answer: number,
+ *         is_correct: boolean,
+ *         time_taken: number
+ *       },
+ *       ...
+ *     ],
+ *     summary: {
+ *       total_score: number,
+ *       completed: boolean,
+ *       start_time: string,
+ *       end_time: string
+ *     }
+ *   }
+ * }
+ */
+function handleGetSessionResults(params) {
+  try {
+    Logger.log('handleGetSessionResults called with params: ' + JSON.stringify(params));
+
+    const sessionId = params.session_id;
+
+    if (!sessionId) {
+      return createJsonResponse({
+        success: false,
+        error: 'session_id is required'
+      });
+    }
+
+    // Sessionsシートからセッション情報を取得
+    const sessionsSheet = getSheet(SHEET_NAMES.SESSIONS);
+    const sessionsData = sessionsSheet.getDataRange().getValues();
+
+    let sessionInfo = null;
+    for (let i = 1; i < sessionsData.length; i++) {
+      if (sessionsData[i][0] === sessionId) {
+        sessionInfo = {
+          session_id: sessionsData[i][0],
+          user_id: sessionsData[i][1],
+          start_time: sessionsData[i][2],
+          end_time: sessionsData[i][3],
+          subjects: sessionsData[i][4],
+          total_score: sessionsData[i][5],
+          completed: sessionsData[i][6]
+        };
+        break;
+      }
+    }
+
+    if (!sessionInfo) {
+      return createJsonResponse({
+        success: false,
+        error: 'Session not found'
+      });
+    }
+
+    // 解答結果を取得（既存のgetSessionResults関数を使用）
+    const results = getSessionResults(sessionId);
+
+    Logger.log('handleGetSessionResults: Found ' + results.length + ' results');
+
+    return createJsonResponse({
+      success: true,
+      data: {
+        session_id: sessionId,
+        results: results,
+        summary: {
+          total_score: sessionInfo.total_score,
+          completed: sessionInfo.completed,
+          start_time: sessionInfo.start_time,
+          end_time: sessionInfo.end_time
+        }
+      }
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleGetSessionResults: ' + error.toString());
+    return createErrorResponse('Get Session Results Failed', error.toString());
+  }
+}
+
+/**
+ * check_summary_statusエンドポイント
+ * session_idに紐づくサマリー完了状態を確認
+ *
+ * @param {Object} params - { session_id: string }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function handleCheckSummaryStatus(params) {
+  try {
+    Logger.log('handleCheckSummaryStatus called with params: ' + JSON.stringify(params));
+
+    const sessionId = params.session_id;
+
+    if (!sessionId) {
+      return createJsonResponse({
+        success: false,
+        error: 'session_id is required'
+      });
+    }
+
+    // Summariesシートからsession_idに一致するレコードを取得
+    const sheet = getSheet(SHEET_NAMES.SUMMARIES);
+    const data = sheet.getDataRange().getValues();
+
+    // ヘッダー行を確認（デバッグ用）
+    const headers = data[0];
+    Logger.log('Summaries sheet headers: ' + JSON.stringify(headers));
+
+    const summaries = [];
+
+    // ヘッダー行をスキップして検索
+    for (let i = 1; i < data.length; i++) {
+      const row = data[i];
+      const rowSessionId = row[1]; // session_id列（0-indexed）
+
+      if (rowSessionId === sessionId) {
+        const subject = row[2];       // subject
+        const keywordsJson = row[3];  // keywords (JSON文字列)
+        const summary = row[5];       // summary
+
+        // JSONをパース（空の場合は空配列）
+        let keywords = [];
+        try {
+          keywords = keywordsJson ? JSON.parse(keywordsJson) : [];
+        } catch (parseError) {
+          Logger.log('Failed to parse keywords: ' + parseError.toString());
+          keywords = [];
+        }
+
+        summaries.push({
+          subject: subject,
+          summary: summary || '',
+          keywords: keywords
+        });
+      }
+    }
+
+    const completed = summaries.length > 0;
+    const count = summaries.length;
+
+    Logger.log('handleCheckSummaryStatus: Found ' + count + ' summaries for session: ' + sessionId);
+
+    return createJsonResponse({
+      success: true,
+      data: {
+        session_id: sessionId,
+        completed: completed,
+        count: count,
+        summaries: summaries
+      }
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleCheckSummaryStatus: ' + error.toString());
+    return createErrorResponse('Check Summary Status Failed', error.toString());
+  }
+}
+
+/**
+ * 評価保存エンドポイント
+ * Python側のget_evaluationから呼び出される
+ *
+ * @param {Object} params - { session_id: string, evaluations: Array }
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function handleSaveEvaluations(params) {
+  try {
+    Logger.log('handleSaveEvaluations called with params: ' + JSON.stringify(params));
+
+    const sessionId = params.session_id;
+    const evaluations = params.evaluations || [];
+
+    if (!sessionId) {
+      return createJsonResponse({
+        success: false,
+        error: 'session_id is required'
+      });
+    }
+
+    if (!Array.isArray(evaluations) || evaluations.length === 0) {
+      return createJsonResponse({
+        success: false,
+        error: 'evaluations array is required and must not be empty'
+      });
+    }
+
+    // Evaluationsシート取得（なければ作成）
+    const sheet = getOrCreateSheet(SHEET_NAMES.EVALUATIONS, [
+      'evaluation_id',
+      'session_id',
+      'subject',
+      'advice',
+      'strengths',
+      'weaknesses',
+      'recommended_topics',
+      'created_at'
+    ]);
+
+    const timestamp = getTimestamp();
+    const savedEvaluations = [];
+
+    // 各評価を保存
+    for (let i = 0; i < evaluations.length; i++) {
+      const evaluation = evaluations[i];
+      const evaluationId = generateUUID();
+
+      const row = [
+        evaluationId,
+        sessionId,
+        evaluation.subject || 'overall',
+        evaluation.advice || '',
+        JSON.stringify(evaluation.strengths || []),
+        JSON.stringify(evaluation.weaknesses || []),
+        JSON.stringify(evaluation.recommended_topics || evaluation.next_steps || []),
+        timestamp
+      ];
+
+      sheet.appendRow(row);
+
+      savedEvaluations.push({
+        evaluation_id: evaluationId,
+        subject: evaluation.subject || 'overall'
+      });
+
+      Logger.log('Saved evaluation: ' + evaluationId + ' for subject: ' + (evaluation.subject || 'overall'));
+    }
+
+    return createJsonResponse({
+      success: true,
+      data: {
+        session_id: sessionId,
+        saved_count: savedEvaluations.length,
+        evaluations: savedEvaluations
+      }
+    });
+
+  } catch (error) {
+    Logger.log('Error in handleSaveEvaluations: ' + error.toString());
+    return createErrorResponse('Save Evaluations Failed', error.toString());
+  }
+}
+
+/**
+ * Statisticsシートを更新
+ *
+ * @param {string} userId - ユーザーID
+ * @param {Object} statsBySubjectCategory - 教科・分野別の統計データ
+ */
+function updateStatistics(userId, statsBySubjectCategory) {
+  try {
+    const statisticsSheet = getSheet(SHEET_NAMES.STATISTICS);
+    const data = statisticsSheet.getDataRange().getValues();
+    const timestamp = getTimestamp();
+
+    // 各教科・分野について統計を更新
+    for (const key in statsBySubjectCategory) {
+      const stat = statsBySubjectCategory[key];
+      const subject = stat.subject;
+      const category = stat.category;
+      const attempted = stat.attempted;
+      const correct = stat.correct;
+
+      // 既存の統計レコードを検索
+      let existingRowIndex = -1;
+      for (let i = 1; i < data.length; i++) {
+        if (data[i][1] === userId && data[i][2] === subject && data[i][3] === category) {
+          existingRowIndex = i;
+          break;
+        }
+      }
+
+      if (existingRowIndex !== -1) {
+        // 既存レコードを更新
+        const oldAttempted = data[existingRowIndex][4] || 0;
+        const oldCorrect = data[existingRowIndex][5] || 0;
+        const newAttempted = oldAttempted + attempted;
+        const newCorrect = oldCorrect + correct;
+        const newAccuracyRate = newAttempted > 0 ? newCorrect / newAttempted : 0;
+
+        statisticsSheet.getRange(existingRowIndex + 1, 5).setValue(newAttempted);      // total_attempted
+        statisticsSheet.getRange(existingRowIndex + 1, 6).setValue(newCorrect);        // correct_count
+        statisticsSheet.getRange(existingRowIndex + 1, 7).setValue(newAccuracyRate);   // accuracy_rate
+        statisticsSheet.getRange(existingRowIndex + 1, 8).setValue(timestamp);         // last_updated
+
+        Logger.log('Updated statistics: ' + subject + '/' + category + ' - ' + newCorrect + '/' + newAttempted);
+      } else {
+        // 新規レコードを作成
+        const statId = generateUUID();
+        const accuracyRate = attempted > 0 ? correct / attempted : 0;
+        const newRow = [
+          statId,         // stat_id
+          userId,         // user_id
+          subject,        // subject
+          category,       // category
+          attempted,      // total_attempted
+          correct,        // correct_count
+          accuracyRate,   // accuracy_rate
+          timestamp       // last_updated
+        ];
+        statisticsSheet.appendRow(newRow);
+
+        Logger.log('Created new statistics: ' + subject + '/' + category + ' - ' + correct + '/' + attempted);
+      }
+    }
+
+  } catch (error) {
+    Logger.log('Error in updateStatistics: ' + error.toString());
+  }
+}
+
+/**
+ * JSON形式のレスポンスを作成
+ *
+ * @param {Object} data - レスポンスデータ
+ * @returns {TextOutput} - JSON形式のレスポンス
+ */
+function createJsonResponse(data) {
+  return ContentService
+    .createTextOutput(JSON.stringify(data))
+    .setMimeType(ContentService.MimeType.JSON);
+}
+
+/**
+ * エラーレスポンスを作成
+ *
+ * @param {string} message - エラーメッセージ
+ * @param {string} details - エラー詳細
+ * @returns {TextOutput} - JSON形式のエラーレスポンス
+ */
+function createErrorResponse(message, details) {
+  const errorData = {
+    success: false,
+    error: message,
+    details: details,
+    timestamp: new Date().toISOString()
+  };
+
+  return ContentService
+    .createTextOutput(JSON.stringify(errorData))
+    .setMimeType(ContentService.MimeType.JSON);
+}
+
+/**
+ * スプレッドシートオ��ジェクトを取得
+ *
+ * @returns {Spreadsheet} - スプレッドシートオブジェクト
+ */
+function getSpreadsheet() {
+  return SpreadsheetApp.openById(SPREADSHEET_ID);
+}
+
+/**
+ * シートオブジェクトを取得
+ *
+ * @param {string} sheetName - シート名
+ * @returns {Sheet} - シートオブジェクト
+ */
+function getSheet(sheetName) {
+  const spreadsheet = getSpreadsheet();
+  const sheet = spreadsheet.getSheetByName(sheetName);
+
+  if (!sheet) {
+    throw new Error('Sheet not found: ' + sheetName);
+  }
+
+  return sheet;
+}
+
+/**
+ * シートオブジェクトを取得（存在しない場合は作成）
+ *
+ * @param {string} sheetName - シート名
+ * @param {Array} headers - ヘッダー行の配列（新規作成時のみ使用）
+ * @returns {Sheet} - シートオブジェクト
+ */
+function getOrCreateSheet(sheetName, headers) {
+  const spreadsheet = getSpreadsheet();
+  let sheet = spreadsheet.getSheetByName(sheetName);
+
+  if (!sheet) {
+    Logger.log('Creating new sheet: ' + sheetName);
+    sheet = spreadsheet.insertSheet(sheetName);
+
+    // ヘッダー行を設定
+    if (headers && headers.length > 0) {
+      sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+      Logger.log('Set headers for ' + sheetName + ': ' + headers.join(', '));
+    }
+  }
+
+  return sheet;
+}
+
+/**
+ * UUIDを生成（簡易版）
+ *
+ * @returns {string} - UUID文字列
+ */
+function generateUUID() {
+  return Utilities.getUuid();
+}
+
+/**
+ * 現在のタイムスタンプ（ISO 8601形式）を取得
+ *
+ * @returns {string} - ISO 8601形式の日時文字列
+ */
+function getTimestamp() {
+  return new Date().toISOString();
+}
+
+// ============================================================================
+// デバッグ用関数（開発時のみ使用）
+// ============================================================================
+
+/**
+ * デバッグ用：ユーザー登録APIテスト
+ * Apps Scriptエディタから実行可能
+ * ランダムなusernameを生成して重複を回避
+ */
+function testRegisterUser() {
+  // ランダムなusernameを生成（重複回避）
+  const randomSuffix = Math.floor(Math.random() * 10000);
+  const e = {
+    postData: {
+      contents: JSON.stringify({
+        endpoint: 'registerUser',
+        params: {
+          username: 'テストユーザー' + randomSuffix
+        }
+      })
+    }
+  };
+
+  const response = doPost(e);
+  Logger.log('Test Response: ' + response.getContent());
+}
+
+function testStartSession() {
+  const e = {
+    postData: {
+      contents: JSON.stringify({
+        endpoint: 'startSession',
+        params: {
+          user_id: 'dummy-user-001',
+          subjects: ['国語', '算数', '理科']
+        }
+      })
+    }
+  };
+
+  const response = doPost(e);
+  Logger.log('Test Response: ' + response.getContent());
+}
+
+function testGenerateQuestion() {
+  const e = {
+    postData: {
+      contents: JSON.stringify({
+        endpoint: 'generateQuestion',
+        params: {
+          session_id: 'dummy-session-001',
+          subjects: ['国語']
+        }
+      })
+    }
+  };
+
+  const response = doPost(e);
+  Logger.log('Test Response: ' + response.getContent());
+}
+
+/**
+ * デバッグ用：重複usernameでのユーザー登録テスト
+ * 既存のusernameを使用してエラーレスポンスを確認
+ */
+function testDuplicateUsername() {
+  const e = {
+    postData: {
+      contents: JSON.stringify({
+        endpoint: 'registerUser',
+        params: {
+          username: 'テストユーザー9526'  // 既存のusername
+        }
+      })
+    }
+  };
+
+  const response = doPost(e);
+  Logger.log('Test Response: ' + response.getContent());
+}
+
+/**
+ * 問題生成APIテスト（Dify統合）
+ */
+function testGenerateQuestions() {
+  const e = {
+    postData: {
+      contents: JSON.stringify({
+        endpoint: 'generateQuestions',
+        params: {
+          session_id: 'test-session-' + Date.now(),
+          subjects: ['jp'] // まず国語だけでテスト
+        }
+      })
+    }
+  };
+
+  const response = doPost(e);
+  Logger.log('Test Response: ' + response.getContent());
+}
+
+/**
+ * 解答送信APIテスト
+ * 注: 事前にtestStartSession、testGenerateQuestionsを実行し、
+ * 実際のsession_idとquestion_idを取得してから実行すること
+ */
+function testSubmitAnswers() {
+  // テスト用: 実際のsession_idとquestion_idに置き換える必要あり
+  const e = {
+    postData: {
+      contents: JSON.stringify({
+        endpoint: 'submitAnswers',
+        params: {
+          session_id: 'test-session-001',  // 実際のsession_idに置き換え
+          answers: [
+            {
+              question_id: 'test-question-001',  // 実際のquestion_idに置き換え
+              selected_answer: 0,
+              time_taken_seconds: 12
+            },
+            {
+              question_id: 'test-question-002',  // 実際のquestion_idに置き換え
+              selected_answer: 2,
+              time_taken_seconds: 18
+            }
+          ]
+        }
+      })
+    }
+  };
+
+  const response = doPost(e);
+  Logger.log('Test Response: ' + response.getContent());
+}
+
+/**
+ * 統計取得APIテスト（ジャンル別累積集計対応版）
+ * 注: 事前にtestRegisterUserを実行し、実際のuser_idを取得してから実行すること
+ *
+ * テスト項目:
+ * 1. ジャンル別統計が取得できること
+ * 2. GenreMaster.jsからジャンル名が正しく取得できること
+ * 3. 苦手順（正答率昇順）にソートされていること
+ * 4. 累積統計（total_sessions, total_questions, total_correct, overall_accuracy）が返却されること
+ */
+function testGetStatistics() {
+  const e = {
+    postData: {
+      contents: JSON.stringify({
+        endpoint: 'getStatistics',
+        params: {
+          user_id: 'test-user-001',  // 実際のuser_idに置き換え
+          subjects: ['jp', 'math']    // オプション: 指定教科のみ取得
+        }
+      })
+    }
+  };
+
+  const response = doPost(e);
+  const responseText = response.getContent();
+  Logger.log('=== testGetStatistics 結果 ===');
+  Logger.log(responseText);
+
+  // レスポンスをパースして検証
+  try {
+    const data = JSON.parse(responseText);
+    if (data.success && data.data) {
+      Logger.log('✅ success: true');
+      Logger.log('user_id: ' + data.data.user_id);
+
+      if (data.data.subjects && data.data.subjects.length > 0) {
+        Logger.log('✅ subjects配列が存在（' + data.data.subjects.length + '教科）');
+
+        // 最初の教科の詳細を確認
+        const firstSubject = data.data.subjects[0];
+        Logger.log('教科例: ' + firstSubject.subject_name);
+        Logger.log('  - 総問題数: ' + firstSubject.total_attempted);
+        Logger.log('  - 正解数: ' + firstSubject.total_correct);
+        Logger.log('  - 正答率: ' + (firstSubject.overall_accuracy * 100).toFixed(1) + '%');
+
+        if (firstSubject.genres && firstSubject.genres.length > 0) {
+          Logger.log('✅ ジャンル配列が存在（' + firstSubject.genres.length + 'ジャンル）');
+          Logger.log('ジャンル例（苦手順）:');
+          for (let i = 0; i < Math.min(3, firstSubject.genres.length); i++) {
+            const genre = firstSubject.genres[i];
+            Logger.log('  ' + (i + 1) + '. ' + genre.genre_name + '（' + genre.genre_id + '）: ' +
+                       genre.correct + '/' + genre.attempted + ' = ' +
+                       (genre.accuracy * 100).toFixed(1) + '%');
+          }
+        } else {
+          Logger.log('⚠️ ジャンル配列が空です');
+        }
+      }
+
+      if (data.data.cumulative) {
+        Logger.log('✅ 累積統計が存在');
+        Logger.log('  - 総セッション数: ' + data.data.cumulative.total_sessions);
+        Logger.log('  - 総問題数: ' + data.data.cumulative.total_questions);
+        Logger.log('  - 総正解数: ' + data.data.cumulative.total_correct);
+        Logger.log('  - 全体正答率: ' + (data.data.cumulative.overall_accuracy * 100).toFixed(1) + '%');
+      } else {
+        Logger.log('⚠️ 累積統計が存在しません');
+      }
+    } else {
+      Logger.log('❌ エラー: ' + (data.error || 'unknown'));
+    }
+  } catch (parseError) {
+    Logger.log('❌ JSON解析エラー: ' + parseError.toString());
+  }
+
+  Logger.log('=== テスト完了 ===');
+}
+
+/**
+ * 評価取得APIテスト
+ * 注: 事前にtestStartSession、testGenerateQuestions、testSubmitAnswersを実行し、
+ * 実際のsession_idを取得してから実行すること
+ *
+ * 使用方法:
+ * 1. testStartSession() → session_idを取得
+ * 2. testGenerateQuestions() → question_idを取得
+ * 3. testSubmitAnswers() → 解答を送信
+ * 4. testGetEvaluation() → 評価を取得
+ */
+function testGetEvaluation() {
+  const e = {
+    postData: {
+      contents: JSON.stringify({
+        endpoint: 'getEvaluation',
+        params: {
+          session_id: 'test-session-001',  // 実際のsession_idに置き換え
+          subjects: ['jp', 'math']          // オプション: 指定教科のみ評価
+        }
+      })
+    }
+  };
+
+  const response = doPost(e);
+  Logger.log('Test Response: ' + response.getContent());
+}
+
+/**
+ * save_questions APIテスト
+ * GeneratedQuestionsシートへの保存をテスト
+ */
+function testSaveQuestions() {
+  const e = {
+    postData: {
+      contents: JSON.stringify({
+        action: 'save_questions',
+        session_id: 'test-session-' + Date.now(),
+        subject: 'jp',
+        questions: [
+          {
+            question_id: 'test-q-001',
+            genre_id: 'JP01',
+            answer: '憂鬱',
+            question: '次の漢字の読みを選びなさい：「憂鬱」',
+            choices: ['ゆううつ', 'ゆうげき', 'ゆうめい', 'ゆうべつ'],
+            correct_answer: 0,
+            difficulty: '標準'
+          },
+          {
+            question_id: 'test-q-002',
+            genre_id: 'JP01',
+            answer: '慈悲',
+            question: '次の熟語の読みを選びなさい：「慈悲」',
+            choices: ['じひ', 'じしん', 'じゅひ', 'しひ'],
+            correct_answer: 0,
+            difficulty: '基本'
+          }
+        ]
+      })
+    }
+  };
+
+  const response = doPost(e);
+  Logger.log('Test Response: ' + response.getContent());
+}
+
+/**
+ * save_summary APIテスト
+ * Summariesシートへの保存をテスト
+ */
+function testSaveSummary() {
+  const e = {
+    postData: {
+      contents: JSON.stringify({
+        action: 'save_summary',
+        session_id: 'test-session-' + Date.now(),
+        subject: 'jp',
+        summary_data: {
+          keywords: ['漢字', '語彙', '読み'],
+          topics: ['漢字の読み', '熟語'],
+          summary: '今回は漢字と熟語の読みに関する問題でした。難読漢字が2問出題されました。'
+        }
+      })
+    }
+  };
+
+  const response = doPost(e);
+  Logger.log('Test Response: ' + response.getContent());
+}

V1.7.1/gas/DifyService.js

@@ -0,0 +1,458 @@
+/**
+ * Dify APIサービス
+ *
+ * Dify Cloudのワークフロー実行APIを呼び出すラッパー
+ *
+ * @version 1.0.0
+ * @date 2025-12-04
+ */
+
+// ============================================================================
+// 定数定義
+// ============================================================================
+
+const DIFY_CONFIG = {
+  TIMEOUT: 150000, // 150秒（RAG Knowledge Base利用による処理時間増加対応）
+  RESPONSE_MODE: 'blocking',
+  USER: 'gas-orchestrator'
+};
+
+// 教科マッピング: GAS内部コード → Dify期待値（日本語）
+const SUBJECT_TO_JAPANESE = {
+  'jp': '国語',
+  'math': '算数',
+  'sci': '理科',
+  'soc': '社会'
+};
+
+// 教科コード → Dify出力変数名のマッピング
+const SUBJECT_TO_OUTPUT_KEY = {
+  'jp': 'kokugo_questions',
+  'math': 'sansu_questions',
+  'sci': 'rika_questions',
+  'soc': 'shakai_questions'
+};
+
+// 教科コード → Dify評価出力変数名のマッピング
+const SUBJECT_TO_EVALUATION_KEY = {
+  'jp': 'kokugo_evaluation',
+  'math': 'sansu_evaluation',
+  'sci': 'rika_evaluation',
+  'soc': 'shakai_evaluation'
+};
+
+/**
+ * Difyの評価出力形式をGAS期待形式に正規化
+ *
+ * Dify出力形式: {"評価": ["コメント1", "コメント2", ...]}
+ * GAS期待形式: {advice, strengths[], weaknesses[], recommended_topics[]}
+ *
+ * @param {Object} difyEvaluation - Difyから返された評価データ
+ * @param {string} subject - 教科ID
+ * @returns {Object} - 正規化された評価データ
+ */
+function normalizeEvaluationFormat(difyEvaluation, subject) {
+  // 既にGAS期待形式の場合はそのまま返す
+  if (difyEvaluation.advice !== undefined) {
+    Logger.log('[DifyService] Evaluation already in expected format');
+    return difyEvaluation;
+  }
+
+  // Dify形式 {"評価": [...]} の場合
+  if (difyEvaluation['評価'] && Array.isArray(difyEvaluation['評価'])) {
+    const comments = difyEvaluation['評価'];
+    Logger.log('[DifyService] Converting Dify format to GAS format: ' + comments.length + ' comments');
+
+    // コメントを構造化
+    // 最初のコメントを総合アドバイス、残りを分類
+    const advice = comments[0] || '';
+    const strengths = [];
+    const weaknesses = [];
+    const recommended_topics = [];
+
+    // 2番目以降のコメントを内容で分類
+    for (var i = 1; i < comments.length; i++) {
+      var comment = comments[i];
+      // 改善・弱点を示すキーワードがあればweaknesses
+      if (comment.includes('課題') || comment.includes('弱') || comment.includes('不足') ||
+          comment.includes('低い') || comment.includes('0%') || comment.includes('改善')) {
+        weaknesses.push(comment);
+      }
+      // 強み・良い点を示すキーワードがあればstrengths
+      else if (comment.includes('強') || comment.includes('得意') || comment.includes('高い') ||
+               comment.includes('安定') || comment.includes('良')) {
+        strengths.push(comment);
+      }
+      // それ以外はrecommended_topics
+      else {
+        recommended_topics.push(comment);
+      }
+    }
+
+    return {
+      advice: advice,
+      strengths: strengths,
+      weaknesses: weaknesses,
+      recommended_topics: recommended_topics
+    };
+  }
+
+  // 不明な形式の場合はそのまま返す（ログ出力）
+  Logger.log('[DifyService] Unknown evaluation format: ' + JSON.stringify(Object.keys(difyEvaluation)));
+  return {
+    advice: JSON.stringify(difyEvaluation),
+    strengths: [],
+    weaknesses: [],
+    recommended_topics: []
+  };
+}
+
+// ============================================================================
+// Dify API呼び出し関数
+// ============================================================================
+
+/**
+ * Dify APIの環境変数を取得
+ */
+function getDifyCredentials() {
+  const properties = PropertiesService.getScriptProperties();
+  const apiUrl = properties.getProperty('DIFY_API_URL');
+  const apiKey = properties.getProperty('DIFY_API_KEY');
+
+  if (!apiUrl || !apiKey) {
+    throw new Error('Dify API credentials not configured. Run setDifyProperties() first.');
+  }
+
+  return { apiUrl, apiKey };
+}
+
+/**
+ * 複数のDify APIリクエストを並列実行
+ *
+ * @param {Array} requestConfigs - リクエスト設定の配列
+ *   各要素: { action: string, subject: string, additionalInputs: Object }
+ * @returns {Array} - Dify APIレスポンスの配列（リクエスト順序を保持）
+ */
+function callDifyWorkflowBatch(requestConfigs) {
+  try {
+    const { apiUrl, apiKey } = getDifyCredentials();
+
+    Logger.log('[DifyService] callDifyWorkflowBatch: Preparing ' + requestConfigs.length + ' parallel requests');
+
+    // 各リクエストの設定を作成
+    const requests = requestConfigs.map((config, index) => {
+      const japaneseSubject = SUBJECT_TO_JAPANESE[config.subject] || config.subject;
+
+      Logger.log('[DifyService] Request ' + index + ': action=' + config.action + ', subject=' + config.subject + ' (' + japaneseSubject + ')');
+
+      return {
+        url: apiUrl,
+        method: 'post',
+        contentType: 'application/json',
+        headers: {
+          'Authorization': 'Bearer ' + apiKey
+        },
+        payload: JSON.stringify({
+          inputs: {
+            action: config.action,
+            subject: japaneseSubject,
+            ...config.additionalInputs
+          },
+          response_mode: DIFY_CONFIG.RESPONSE_MODE,
+          user: DIFY_CONFIG.USER
+        }),
+        muteHttpExceptions: true
+      };
+    });
+
+    Logger.log('[DifyService] Sending ' + requests.length + ' parallel requests to Dify API...');
+    const startTime = new Date().getTime();
+
+    // 並列実行
+    const responses = UrlFetchApp.fetchAll(requests);
+
+    const endTime = new Date().getTime();
+    Logger.log('[DifyService] All requests completed in ' + ((endTime - startTime) / 1000) + ' seconds');
+
+    // 結果をパースして返却
+    return responses.map((response, index) => {
+      const responseCode = response.getResponseCode();
+      const responseText = response.getContentText();
+
+      Logger.log('[DifyService] Response ' + index + ': code=' + responseCode);
+
+      if (responseCode !== 200) {
+        Logger.log('[DifyService] Batch request ' + index + ' failed: ' + responseText.substring(0, 200));
+        return {
+          error: true,
+          code: responseCode,
+          message: responseText,
+          subject: requestConfigs[index].subject
+        };
+      }
+
+      try {
+        const parsed = JSON.parse(responseText);
+        parsed._subject = requestConfigs[index].subject; // 後で識別するため
+        return parsed;
+      } catch (parseError) {
+        Logger.log('[DifyService] JSON parse error for request ' + index + ': ' + parseError.toString());
+        return {
+          error: true,
+          code: responseCode,
+          message: 'JSON parse error: ' + parseError.toString(),
+          subject: requestConfigs[index].subject
+        };
+      }
+    });
+
+  } catch (error) {
+    Logger.log('[DifyService] callDifyWorkflowBatch error: ' + error.toString());
+    throw error;
+  }
+}
+
+/**
+ * Dify Workflowを実行
+ *
+ * @param {string} action - アクション（generate_questions, generate_evaluation）
+ * @param {string} subject - 教科ID（jp, math, sci, soc）
+ * @param {Object} additionalInputs - 追加の入力パラメータ（統計情報など）
+ * @returns {Object} - Dify APIレスポンス
+ */
+function callDifyWorkflow(action, subject, additionalInputs = {}) {
+  try {
+    const { apiUrl, apiKey } = getDifyCredentials();
+
+    // GASの教科コード（jp, math, sci, soc）を日本語に変換
+    const japaneseSubject = SUBJECT_TO_JAPANESE[subject] || subject;
+
+    Logger.log('[DifyService] callDifyWorkflow: action=' + action + ', subject=' + subject + ' (' + japaneseSubject + ')');
+
+    // リクエストペイロード（subjectは日本語に変換して送信）
+    const payload = {
+      inputs: {
+        action: action,
+        subject: japaneseSubject,
+        ...additionalInputs
+      },
+      response_mode: DIFY_CONFIG.RESPONSE_MODE,
+      user: DIFY_CONFIG.USER
+    };
+
+    // HTTPリクエストオプション
+    const options = {
+      method: 'post',
+      contentType: 'application/json',
+      headers: {
+        'Authorization': 'Bearer ' + apiKey
+      },
+      payload: JSON.stringify(payload),
+      muteHttpExceptions: true
+    };
+
+    Logger.log('[DifyService] Sending request to Dify API...');
+    const response = UrlFetchApp.fetch(apiUrl, options);
+    const responseCode = response.getResponseCode();
+    const responseText = response.getContentText();
+
+    Logger.log('[DifyService] Response code: ' + responseCode);
+
+    if (responseCode !== 200) {
+      Logger.log('[DifyService] Error response: ' + responseText);
+      throw new Error('Dify API error: ' + responseCode + ' - ' + responseText);
+    }
+
+    const responseData = JSON.parse(responseText);
+    Logger.log('[DifyService] Success: workflow_run_id=' + (responseData.workflow_run_id || 'N/A'));
+
+    return responseData;
+
+  } catch (error) {
+    Logger.log('[DifyService] Error: ' + error.toString());
+    throw error;
+  }
+}
+
+/**
+ * 問題生成APIを呼び出し
+ *
+ * @param {string} subject - 教科ID
+ * @param {Object} statistics - ユーザー統計（オプション）
+ * @param {Array} recentQuestions - 直近の問題リスト（オプション）
+ * @returns {Array} - 生成された問題配列
+ */
+function generateQuestionsFromDify(subject, statistics = {}, recentQuestions = []) {
+  try {
+    Logger.log('[DifyService] generateQuestionsFromDify: subject=' + subject);
+
+    const response = callDifyWorkflow('generate_questions', subject, {
+      statistics: JSON.stringify(statistics),
+      recent_questions: JSON.stringify(recentQuestions)
+    });
+
+    // Difyレスポンスから問題データを抽出
+    // response.data.outputs から教科別の出力変数を取得
+    if (response.data && response.data.outputs) {
+      const outputs = response.data.outputs;
+
+      // エラーレスポンスチェック
+      if (outputs.action_error) {
+        throw new Error('Dify action error: ' + outputs.action_error);
+      }
+      if (outputs.subject_error_questions) {
+        throw new Error('Dify subject error: ' + outputs.subject_error_questions);
+      }
+
+      // 教科別の出力変数名を取得（例: kokugo_questions, sansu_questions）
+      const outputKey = SUBJECT_TO_OUTPUT_KEY[subject];
+      if (!outputKey) {
+        throw new Error('Invalid subject code: ' + subject);
+      }
+
+      Logger.log('[DifyService] Looking for output key: ' + outputKey);
+
+      // 教科別の出力変数から問題データを取得
+      if (outputs[outputKey]) {
+        const questionsData = outputs[outputKey];
+
+        // JSON文字列の場合はパース
+        if (typeof questionsData === 'string') {
+          Logger.log('[DifyService] Parsing JSON string from ' + outputKey);
+          const parsed = JSON.parse(questionsData);
+
+          // { questions: [...] } 形式の場合
+          if (parsed.questions && Array.isArray(parsed.questions)) {
+            Logger.log('[DifyService] Successfully parsed ' + parsed.questions.length + ' questions');
+            return parsed.questions;
+          }
+
+          // 直接配列の場合
+          if (Array.isArray(parsed)) {
+            Logger.log('[DifyService] Successfully parsed ' + parsed.length + ' questions (array format)');
+            return parsed;
+          }
+        }
+
+        // 既にオブジェクト/配列の場合
+        if (Array.isArray(questionsData)) {
+          Logger.log('[DifyService] Got ' + questionsData.length + ' questions (array format)');
+          return questionsData;
+        }
+
+        if (questionsData.questions && Array.isArray(questionsData.questions)) {
+          Logger.log('[DifyService] Got ' + questionsData.questions.length + ' questions (object format)');
+          return questionsData.questions;
+        }
+      }
+
+      Logger.log('[DifyService] Output key "' + outputKey + '" not found in outputs: ' + JSON.stringify(Object.keys(outputs)));
+    }
+
+    throw new Error('Invalid response format from Dify: questions data not found');
+
+  } catch (error) {
+    Logger.log('[DifyService] generateQuestionsFromDify error: ' + error.toString());
+    throw error;
+  }
+}
+
+/**
+ * 評価生成APIを呼び出し
+ *
+ * @param {string} subject - 教科ID（jp, math, sci, soc, または 'overall'）
+ * @param {Object} statistics - ユーザー統計（教科別正答率など）
+ * @param {Array} results - 解答結果配列（各問題の正誤結果）
+ * @param {Object} subjectEvaluations - 教科別評価（overallの場合のみ使用、オプション）
+ * @returns {Object} - 生成された評価
+ *
+ * レスポンスフォーマット:
+ * 教科別評価: { subject, advice, strengths[], weaknesses[], recommended_topics[] }
+ * 全体評価: { overall_advice, strengths[], weaknesses[], next_steps[] }
+ */
+function generateEvaluationFromDify(subject, statistics, results, subjectEvaluations = null) {
+  try {
+    Logger.log('[DifyService] generateEvaluationFromDify: subject=' + subject);
+
+    // 追加の入力パラメータ
+    const additionalInputs = {
+      statistics: JSON.stringify(statistics),
+      results: JSON.stringify(results)
+    };
+
+    // 全体評価の場合、教科別評価も渡す
+    if (subject === 'overall' && subjectEvaluations) {
+      Logger.log('[DifyService] Adding subject_evaluations to overall evaluation');
+      additionalInputs.subject_evaluations = JSON.stringify(subjectEvaluations);
+    }
+
+    const response = callDifyWorkflow('generate_evaluation', subject, additionalInputs);
+
+    // Difyレスポンスから評価データを抽出
+    if (response.data && response.data.outputs) {
+      const outputs = response.data.outputs;
+
+      // エラーレスポンスチェック
+      if (outputs.action_error) {
+        throw new Error('Dify action error: ' + outputs.action_error);
+      }
+      if (outputs.subject_error_evaluation) {
+        throw new Error('Dify subject error: ' + outputs.subject_error_evaluation);
+      }
+
+      // 全体評価の場合
+      if (subject === 'overall') {
+        if (outputs.overall_evaluation) {
+          const evaluationData = outputs.overall_evaluation;
+
+          // JSON文字列の場合はパース
+          if (typeof evaluationData === 'string') {
+            Logger.log('[DifyService] Parsing overall_evaluation JSON string');
+            const parsed = JSON.parse(evaluationData);
+            Logger.log('[DifyService] Overall evaluation generated successfully');
+            return parsed;
+          }
+
+          // 既にオブジェクトの場合
+          Logger.log('[DifyService] Overall evaluation generated successfully (object format)');
+          return evaluationData;
+        }
+      } else {
+        // 教科別評価の場合
+        const evaluationKey = SUBJECT_TO_EVALUATION_KEY[subject];
+        if (!evaluationKey) {
+          throw new Error('Invalid subject code for evaluation: ' + subject);
+        }
+
+        Logger.log('[DifyService] Looking for evaluation key: ' + evaluationKey);
+
+        if (outputs[evaluationKey]) {
+          const evaluationData = outputs[evaluationKey];
+          let parsed;
+
+          // JSON文字列の場合はパース
+          if (typeof evaluationData === 'string') {
+            Logger.log('[DifyService] Parsing JSON string from ' + evaluationKey);
+            parsed = JSON.parse(evaluationData);
+          } else {
+            // 既にオブジェクトの場合
+            parsed = evaluationData;
+          }
+
+          // Difyの出力形式 {"評価": [...]} をGAS期待形式に変換
+          const normalized = normalizeEvaluationFormat(parsed, subject);
+          Logger.log('[DifyService] Evaluation generated successfully for ' + subject);
+          return normalized;
+        }
+
+        Logger.log('[DifyService] Evaluation key "' + evaluationKey + '" not found in outputs: ' + JSON.stringify(Object.keys(outputs)));
+      }
+    }
+
+    throw new Error('Invalid response format from Dify: evaluation data not found');
+
+  } catch (error) {
+    Logger.log('[DifyService] generateEvaluationFromDify error: ' + error.toString());
+    throw error;
+  }
+}

V1.7.1/gas/GenreMaster.js

@@ -0,0 +1,431 @@
+/**
+ * ジャンルマスターデータ
+ *
+ * 中学受験4教科のジャンル分類を定義
+ *
+ * @version 1.0.0
+ * @date 2025-12-07
+ */
+
+// ============================================================================
+// ジャンルマスターデータ
+// ============================================================================
+
+/**
+ * 中学受験4教科のジャンル分類マスターデータ
+ * @constant {Object}
+ */
+var GENRE_MASTER = {
+  // 国語（8ジャンル）
+  jp: {
+    subject_id: 'jp',
+    subject_name: '国語',
+    genres: [
+      {
+        id: 'JP01',
+        name: '漢字・語彙',
+        description: '読み書き、四字熟語、慣用句、ことわざ'
+      },
+      {
+        id: 'JP02',
+        name: '文法・言葉のきまり',
+        description: '品詞、敬語、文の成分、修飾関係'
+      },
+      {
+        id: 'JP03',
+        name: '物語文読解',
+        description: '心情理解、場面把握、人物関係'
+      },
+      {
+        id: 'JP04',
+        name: '説明文・論説文読解',
+        description: '要旨、段落構成、筆者の主張'
+      },
+      {
+        id: 'JP05',
+        name: '随筆文読解',
+        description: '筆者の体験・感想の読み取り'
+      },
+      {
+        id: 'JP06',
+        name: '詩・韻文',
+        description: '詩、短歌、俳句、表現技法'
+      },
+      {
+        id: 'JP07',
+        name: '記述問題',
+        description: '理由説明、要約、意見記述'
+      },
+      {
+        id: 'JP08',
+        name: '知識・文学史',
+        description: '作家、作品名、文学的常識'
+      }
+    ]
+  },
+
+  // 算数（10ジャンル）
+  math: {
+    subject_id: 'math',
+    subject_name: '算数',
+    genres: [
+      {
+        id: 'MA01',
+        name: '計算',
+        description: '四則演算、分数・小数、逆算'
+      },
+      {
+        id: 'MA02',
+        name: '数の性質',
+        description: '約数・倍数、素因数分解、規則性'
+      },
+      {
+        id: 'MA03',
+        name: '割合・比',
+        description: '割合、比、百分率、歩合'
+      },
+      {
+        id: 'MA04',
+        name: '速さ',
+        description: '旅人算、通過算、流水算、時計算'
+      },
+      {
+        id: 'MA05',
+        name: '文章題（その他）',
+        description: '濃度、仕事算、ニュートン算、差集め算'
+      },
+      {
+        id: 'MA06',
+        name: '平面図形',
+        description: '面積、角度、相似、合同'
+      },
+      {
+        id: 'MA07',
+        name: '立体図形',
+        description: '体積、表面積、展開図、切断'
+      },
+      {
+        id: 'MA08',
+        name: '場合の数・確率',
+        description: '順列、組み合わせ、確率'
+      },
+      {
+        id: 'MA09',
+        name: 'グラフ・表',
+        description: '統計、変化のグラフ、ダイヤグラム'
+      },
+      {
+        id: 'MA10',
+        name: '特殊算',
+        description: 'つるかめ算、消去算、過不足算'
+      }
+    ]
+  },
+
+  // 理科（12ジャンル）
+  sci: {
+    subject_id: 'sci',
+    subject_name: '理科',
+    genres: [
+      {
+        id: 'SC01',
+        name: '力・運動',
+        description: 'てこ、滑車、ばね、浮力、振り子'
+      },
+      {
+        id: 'SC02',
+        name: '電気',
+        description: '回路、抵抗、電磁石、発熱'
+      },
+      {
+        id: 'SC03',
+        name: '光・音・熱',
+        description: '反射、屈折、レンズ、音の性質'
+      },
+      {
+        id: 'SC04',
+        name: '物質の性質',
+        description: '金属、気体、密度、状態変化'
+      },
+      {
+        id: 'SC05',
+        name: '水溶液',
+        description: '酸・アルカリ、中和、溶解度'
+      },
+      {
+        id: 'SC06',
+        name: '燃焼・化学変化',
+        description: '燃焼、酸化還元、化合'
+      },
+      {
+        id: 'SC07',
+        name: '植物',
+        description: 'つくり、光合成、蒸散、分類'
+      },
+      {
+        id: 'SC08',
+        name: '動物',
+        description: 'からだのつくり、行動、分類'
+      },
+      {
+        id: 'SC09',
+        name: '人体',
+        description: '消化、呼吸、血液循環、感覚器官'
+      },
+      {
+        id: 'SC10',
+        name: '天体',
+        description: '太陽、月、星座、地球の運動'
+      },
+      {
+        id: 'SC11',
+        name: '気象',
+        description: '天気、気温、湿度、雲、季節風'
+      },
+      {
+        id: 'SC12',
+        name: '地学',
+        description: '地層、岩石、火山、地震'
+      }
+    ]
+  },
+
+  // 社会（10ジャンル）
+  soc: {
+    subject_id: 'soc',
+    subject_name: '社会',
+    genres: [
+      {
+        id: 'SO01',
+        name: '日本地理（国土・自然）',
+        description: '地形、気候、都道府県'
+      },
+      {
+        id: 'SO02',
+        name: '日本地理（産業）',
+        description: '農業、工業、水産業、商業'
+      },
+      {
+        id: 'SO03',
+        name: '世界地理',
+        description: '大陸、国、貿易、環境問題'
+      },
+      {
+        id: 'SO04',
+        name: '歴史（古代〜平安）',
+        description: '旧石器〜平安時代'
+      },
+      {
+        id: 'SO05',
+        name: '歴史（鎌倉〜室町）',
+        description: '武士の台頭、文化'
+      },
+      {
+        id: 'SO06',
+        name: '歴史（安土桃山〜江戸）',
+        description: '統一、鎖国、元禄・化政文化'
+      },
+      {
+        id: 'SO07',
+        name: '歴史（明治〜現代）',
+        description: '近代化、戦争、戦後'
+      },
+      {
+        id: 'SO08',
+        name: '公民（政治・憲法）',
+        description: '三権分立、選挙、人権'
+      },
+      {
+        id: 'SO09',
+        name: '公民（経済・国際）',
+        description: '経済の仕組み、国際機関、SDGs'
+      },
+      {
+        id: 'SO10',
+        name: '時事問題',
+        description: '直近1〜2年のニュース'
+      }
+    ]
+  }
+};
+
+// ============================================================================
+// ヘルパー関数
+// ============================================================================
+
+/**
+ * ジャンルIDからジャンル情報を取得
+ *
+ * @param {string} genreId - ジャンルID（例: 'JP01', 'MA05'）
+ * @returns {Object|null} - ジャンル情報 { id, name, description, subject_id, subject_name } または null
+ *
+ * @example
+ * var genre = getGenreById('JP01');
+ * // => { id: 'JP01', name: '漢字・語彙', description: '...', subject_id: 'jp', subject_name: '国語' }
+ */
+function getGenreById(genreId) {
+  if (!genreId || typeof genreId !== 'string') {
+    return null;
+  }
+
+  var upperGenreId = genreId.toUpperCase();
+
+  // 全教科を検索
+  var subjects = ['jp', 'math', 'sci', 'soc'];
+  for (var i = 0; i < subjects.length; i++) {
+    var subjectId = subjects[i];
+    var subjectData = GENRE_MASTER[subjectId];
+    var genres = subjectData.genres;
+
+    for (var j = 0; j < genres.length; j++) {
+      var genre = genres[j];
+      if (genre.id === upperGenreId) {
+        // ジャンル情報に教科情報を追加して返却
+        return {
+          id: genre.id,
+          name: genre.name,
+          description: genre.description,
+          subject_id: subjectData.subject_id,
+          subject_name: subjectData.subject_name
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 教科のジャンル一覧を取得
+ *
+ * @param {string} subjectId - 教科ID（jp, math, sci, soc）
+ * @returns {Array} - ジャンル配列（見つからない場合は空配列）
+ *
+ * @example
+ * var genres = getGenresBySubject('jp');
+ * // => [{ id: 'JP01', name: '漢字・語彙', ... }, ...]
+ */
+function getGenresBySubject(subjectId) {
+  if (!subjectId || typeof subjectId !== 'string') {
+    return [];
+  }
+
+  var subjectData = GENRE_MASTER[subjectId.toLowerCase()];
+  if (!subjectData) {
+    return [];
+  }
+
+  return subjectData.genres;
+}
+
+/**
+ * 全ジャンル数を取得
+ *
+ * @returns {number} - 総ジャンル数（40）
+ *
+ * @example
+ * var total = getTotalGenreCount();
+ * // => 40
+ */
+function getTotalGenreCount() {
+  var count = 0;
+  var subjects = ['jp', 'math', 'sci', 'soc'];
+
+  for (var i = 0; i < subjects.length; i++) {
+    var subjectId = subjects[i];
+    count += GENRE_MASTER[subjectId].genres.length;
+  }
+
+  return count;
+}
+
+/**
+ * ジャンルIDの検証
+ *
+ * @param {string} genreId - ジャンルID
+ * @returns {boolean} - 有効なジャンルIDかどうか
+ *
+ * @example
+ * isValidGenreId('JP01'); // => true
+ * isValidGenreId('XX99'); // => false
+ */
+function isValidGenreId(genreId) {
+  return getGenreById(genreId) !== null;
+}
+
+/**
+ * Dify用のジャンルリストを生成（問題生成プロンプト用）
+ *
+ * @param {string} subjectId - 教科ID（jp, math, sci, soc）
+ * @returns {string} - ジャンルリストの文字列（改行区切り）
+ *
+ * @example
+ * var list = getGenreListForDify('jp');
+ * // => "JP01: 漢字・語彙（読み書き、四字熟語、慣用句、ことわざ）\n..."
+ */
+function getGenreListForDify(subjectId) {
+  var genres = getGenresBySubject(subjectId);
+
+  if (genres.length === 0) {
+    return '';
+  }
+
+  var lines = [];
+  for (var i = 0; i < genres.length; i++) {
+    var genre = genres[i];
+    var line = genre.id + ': ' + genre.name + '（' + genre.description + '）';
+    lines.push(line);
+  }
+
+  return lines.join('\n');
+}
+
+// ============================================================================
+// テスト関数（GASエディタで実行可能）
+// ============================================================================
+
+/**
+ * GenreMaster.jsのテスト関数
+ * GASエディタで実行して動作確認
+ */
+function testGenreMaster() {
+  Logger.log('=== GenreMaster.js テスト開始 ===');
+
+  // テスト1: ジャンル総数
+  var totalCount = getTotalGenreCount();
+  Logger.log('テスト1: 総ジャンル数 = ' + totalCount + ' (期待値: 40)');
+
+  // テスト2: ジャンルID検索
+  var genre1 = getGenreById('JP01');
+  Logger.log('テスト2: getGenreById("JP01") = ' + JSON.stringify(genre1));
+
+  var genre2 = getGenreById('MA05');
+  Logger.log('テスト2: getGenreById("MA05") = ' + JSON.stringify(genre2));
+
+  // テスト3: 教科別ジャンル取得
+  var jpGenres = getGenresBySubject('jp');
+  Logger.log('テスト3: 国語ジャンル数 = ' + jpGenres.length + ' (期待値: 8)');
+
+  var mathGenres = getGenresBySubject('math');
+  Logger.log('テスト3: 算数ジャンル数 = ' + mathGenres.length + ' (期待値: 10)');
+
+  var sciGenres = getGenresBySubject('sci');
+  Logger.log('テスト3: 理科ジャンル数 = ' + sciGenres.length + ' (期待値: 12)');
+
+  var socGenres = getGenresBySubject('soc');
+  Logger.log('テスト3: 社会ジャンル数 = ' + socGenres.length + ' (期待値: 10)');
+
+  // テスト4: ジャンルID検証
+  var valid1 = isValidGenreId('JP01');
+  Logger.log('テスト4: isValidGenreId("JP01") = ' + valid1 + ' (期待値: true)');
+
+  var valid2 = isValidGenreId('XX99');
+  Logger.log('テスト4: isValidGenreId("XX99") = ' + valid2 + ' (期待値: false)');
+
+  // テスト5: Dify用ジャンルリスト生成
+  var jpList = getGenreListForDify('jp');
+  Logger.log('テスト5: 国語ジャンルリスト（最初の100文字）:');
+  Logger.log(jpList.substring(0, 100) + '...');
+
+  Logger.log('=== GenreMaster.js テスト完了 ===');
+}

V1.7.1/gas/appsscript.json

@@ -0,0 +1,15 @@
+{
+  "timeZone": "Asia/Tokyo",
+  "dependencies": {
+  },
+  "exceptionLogging": "STACKDRIVER",
+  "runtimeVersion": "V8",
+  "oauthScopes": [
+    "https://www.googleapis.com/auth/script.external_request",
+    "https://www.googleapis.com/auth/spreadsheets"
+  ],
+  "webapp": {
+    "executeAs": "USER_DEPLOYING",
+    "access": "ANYONE_ANONYMOUS"
+  }
+}

V1.7.1/gas/questiondb_functions.js

@@ -0,0 +1,816 @@
+/**
+ * QuestionDatabase機能
+ *
+ * 機能:
+ * - 事前生成された「回答させたい答え」をGoogle Sheetsで管理
+ * - 問題生成時に使用回数が少ないものからランダムに選択
+ *
+ * シート名: QuestionDatabase
+ *
+ * スキーマ（8カラム）:
+ * A: answer_id (string) - 一意ID (例: jp_001, math_042)
+ * B: subject (string) - 教科コード (jp, math, sci, soc)
+ * C: category (string) - ジャンルID (例: JP01, MA03, SC07)
+ * D: answer (string) - 回答させたい答え
+ * E: question_hint (string) - 設問方針
+ * F: difficulty (string) - 基本/標準/応用
+ * G: source_context (string) - 教材での使用例
+ * H: usage_count (number) - 使用回数（初期値0）
+ */
+
+// ==================== 定数定義 ====================
+
+const QUESTIONDB_SHEET_NAME = 'QuestionDatabase';
+
+const QUESTIONDB_COLUMNS = {
+  ANSWER_ID: 1,        // A列
+  SUBJECT: 2,          // B列
+  CATEGORY: 3,         // C列
+  ANSWER: 4,           // D列
+  QUESTION_HINT: 5,    // E列
+  DIFFICULTY: 6,       // F列
+  SOURCE_CONTEXT: 7,   // G列
+  USAGE_COUNT: 8       // H列
+};
+
+const QUESTIONDB_HEADER = [
+  'answer_id',
+  'subject',
+  'category',
+  'answer',
+  'question_hint',
+  'difficulty',
+  'source_context',
+  'usage_count'
+];
+
+/**
+ * ジャンル構成定義（各教科10問）
+ *
+ * 国語: JP01(4), JP02(2), JP03-06各1 = 10問
+ * 算数: MA01-MA10 各1問 = 10問
+ * 理科: SC01-SC10 各1問 = 10問
+ * 社会: SO01-SO10 各1問 = 10問
+ */
+const GENRE_CONFIG = {
+  "jp": {"JP01": 4, "JP02": 2, "JP03": 1, "JP04": 1, "JP05": 1, "JP06": 1},
+  "math": {"MA01": 1, "MA02": 1, "MA03": 1, "MA04": 1, "MA05": 1, "MA06": 1, "MA07": 1, "MA08": 1, "MA09": 1, "MA10": 1},
+  "sci": {"SC01": 1, "SC02": 1, "SC03": 1, "SC04": 1, "SC05": 1, "SC06": 1, "SC07": 1, "SC08": 1, "SC09": 1, "SC10": 1},
+  "soc": {"SO01": 1, "SO02": 1, "SO03": 1, "SO04": 1, "SO05": 1, "SO06": 1, "SO07": 1, "SO08": 1, "SO09": 1, "SO10": 1}
+};
+
+// ==================== ユーティリティ関数 ====================
+
+/**
+ * QuestionDatabaseシートを取得（なければ作成）
+ * @returns {GoogleAppsScript.Spreadsheet.Sheet}
+ */
+function getQuestionDatabaseSheet_() {
+  const ss = SpreadsheetApp.getActiveSpreadsheet();
+  let sheet = ss.getSheetByName(QUESTIONDB_SHEET_NAME);
+
+  if (!sheet) {
+    sheet = ss.insertSheet(QUESTIONDB_SHEET_NAME);
+    // ヘッダー行を設定
+    sheet.getRange(1, 1, 1, QUESTIONDB_HEADER.length).setValues([QUESTIONDB_HEADER]);
+    sheet.getRange(1, 1, 1, QUESTIONDB_HEADER.length).setFontWeight('bold');
+    sheet.setFrozenRows(1);
+
+    Logger.log('QuestionDatabaseシートを新規作成しました');
+  }
+
+  return sheet;
+}
+
+/**
+ * 行データをオブジェクトに変換
+ * @param {Array} row - スプレッドシートの行データ
+ * @returns {Object}
+ */
+function rowToQuestionObject_(row) {
+  return {
+    answer_id: row[0] || '',
+    subject: row[1] || '',
+    category: row[2] || '',
+    answer: row[3] || '',
+    question_hint: row[4] || '',
+    difficulty: row[5] || '',
+    source_context: row[6] || '',
+    usage_count: row[7] || 0
+  };
+}
+
+/**
+ * オブジェクトを行データに変換
+ * @param {Object} obj - 問題データオブジェクト
+ * @returns {Array}
+ */
+function questionObjectToRow_(obj) {
+  return [
+    obj.answer_id || '',
+    obj.subject || '',
+    obj.category || '',
+    obj.answer || '',
+    obj.question_hint || '',
+    obj.difficulty || '',
+    obj.source_context || '',
+    obj.usage_count || 0
+  ];
+}
+
+// ==================== メインAPI ====================
+
+/**
+ * 教科を指定してランダムに答えを取得
+ *
+ * アルゴリズム:
+ * 1. subject で絞り込み
+ * 2. usage_count の最小値を取得
+ * 3. 最小値のレコードに絞り込み
+ * 4. その中からランダムに count 件抽出
+ *
+ * @param {string} subject - 教科コード (jp, math, sci, soc)
+ * @param {number} count - 取得件数
+ * @returns {Array<Object>} 取得した答えデータの配列
+ *
+ * @example
+ * // 国語から3件取得
+ * const answers = get_random_answers('jp', 3);
+ * console.log(answers);
+ * // [
+ * //   { answer_id: 'jp_001', subject: 'jp', category: 'JP01', answer: '漢字', ... },
+ * //   { answer_id: 'jp_042', subject: 'jp', category: 'JP02', answer: '文法', ... },
+ * //   ...
+ * // ]
+ */
+function get_random_answers(subject, count) {
+  try {
+    const sheet = getQuestionDatabaseSheet_();
+    const lastRow = sheet.getLastRow();
+
+    if (lastRow <= 1) {
+      Logger.log('QuestionDatabaseにデータがありません');
+      return [];
+    }
+
+    // 全データを取得（ヘッダー行を除く）
+    const dataRange = sheet.getRange(2, 1, lastRow - 1, QUESTIONDB_HEADER.length);
+    const allData = dataRange.getValues();
+
+    // subjectで絞り込み
+    const filteredData = allData
+      .map((row, index) => ({ row, originalIndex: index + 2 })) // 行番号を保持（2行目から）
+      .filter(item => item.row[QUESTIONDB_COLUMNS.SUBJECT - 1] === subject);
+
+    if (filteredData.length === 0) {
+      Logger.log(`教科コード '${subject}' のデータが見つかりませんでした`);
+      return [];
+    }
+
+    // usage_countの最小値を取得
+    const usageCounts = filteredData.map(item => item.row[QUESTIONDB_COLUMNS.USAGE_COUNT - 1] || 0);
+    const minUsageCount = Math.min(...usageCounts);
+
+    Logger.log(`教科 '${subject}' の最小使用回数: ${minUsageCount}`);
+
+    // 最小値のレコードに絞り込み
+    const minUsageData = filteredData.filter(
+      item => (item.row[QUESTIONDB_COLUMNS.USAGE_COUNT - 1] || 0) === minUsageCount
+    );
+
+    Logger.log(`最小使用回数のレコード数: ${minUsageData.length}`);
+
+    // ランダムに count 件抽出
+    const selectedCount = Math.min(count, minUsageData.length);
+    const shuffled = minUsageData.sort(() => Math.random() - 0.5);
+    const selected = shuffled.slice(0, selectedCount);
+
+    // オブジェクト形式に変換
+    const results = selected.map(item => rowToQuestionObject_(item.row));
+
+    Logger.log(`${selectedCount}件の答えを取得しました`);
+    return results;
+
+  } catch (error) {
+    Logger.log(`get_random_answers エラー: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * ジャンル構成に基づいて問題を取得（v1.6.3新規）
+ *
+ * 各ジャンル内でusage_countが最小のレコードからランダムに指定数を抽出
+ * これにより全ジャンルから均等に出題され、同じ問題の繰り返しを防ぐ
+ *
+ * @param {Array<string>} subjects - 教科コードの配列 (例: ["jp", "math", "sci", "soc"])
+ * @returns {Array<Object>} 取得した問題データの配列（全教科分を結合）
+ *
+ * @example
+ * const questions = get_questions_by_genre_config(["jp", "math"]);
+ * // 国語10問 + 算数10問 = 20問が返る
+ */
+function get_questions_by_genre_config(subjects) {
+  try {
+    const sheet = getQuestionDatabaseSheet_();
+    const lastRow = sheet.getLastRow();
+
+    if (lastRow <= 1) {
+      Logger.log('QuestionDatabaseにデータがありません');
+      return [];
+    }
+
+    // 全データを取得（ヘッダー行を除く）
+    const dataRange = sheet.getRange(2, 1, lastRow - 1, QUESTIONDB_HEADER.length);
+    const allData = dataRange.getValues();
+
+    const results = [];
+
+    // 各教科を処理
+    for (const subject of subjects) {
+      const genreConfig = GENRE_CONFIG[subject];
+
+      if (!genreConfig) {
+        Logger.log(`未知の教科コード: ${subject} - スキップ`);
+        continue;
+      }
+
+      Logger.log(`教科 '${subject}' を処理中...`);
+
+      // 各ジャンルを処理
+      for (const [genre, count] of Object.entries(genreConfig)) {
+        // このジャンルのレコードを抽出
+        const genreData = allData
+          .map((row, index) => ({ row, originalIndex: index + 2 }))
+          .filter(item =>
+            item.row[QUESTIONDB_COLUMNS.SUBJECT - 1] === subject &&
+            item.row[QUESTIONDB_COLUMNS.CATEGORY - 1] === genre
+          );
+
+        if (genreData.length === 0) {
+          Logger.log(`ジャンル '${genre}' のデータがありません`);
+          continue;
+        }
+
+        // v1.6.14: usage_count最小優先で抽出、不足分は次のusage_countから補充
+        // ユニークなusage_count値をソート
+        const usageCounts = genreData.map(item => item.row[QUESTIONDB_COLUMNS.USAGE_COUNT - 1] || 0);
+        const uniqueUsageCounts = [...new Set(usageCounts)].sort((a, b) => a - b);
+
+        const selected = [];
+        let remaining = count;
+
+        // usage_countが小さい順に必要数を満たすまで抽出
+        for (const usageCount of uniqueUsageCounts) {
+          if (remaining <= 0) break;
+
+          // この usage_count のレコードを取得
+          const usageData = genreData.filter(
+            item => (item.row[QUESTIONDB_COLUMNS.USAGE_COUNT - 1] || 0) === usageCount
+          );
+
+          // ランダムにシャッフルして不足分だけ抽出
+          const shuffled = usageData.sort(() => Math.random() - 0.5);
+          const toTake = Math.min(remaining, shuffled.length);
+          
+          for (let i = 0; i < toTake; i++) {
+            selected.push(shuffled[i]);
+          }
+          
+          remaining -= toTake;
+          
+          if (toTake > 0) {
+            Logger.log(`  usage_count=${usageCount}: ${toTake}問取得`);
+          }
+        }
+
+        // v1.6.15: 抽出時にUSAGE_COUNTを+1（抽出と同時に更新）
+        for (const item of selected) {
+          const currentUsage = item.row[QUESTIONDB_COLUMNS.USAGE_COUNT - 1] || 0;
+          const newUsage = currentUsage + 1;
+          sheet.getRange(item.originalIndex, QUESTIONDB_COLUMNS.USAGE_COUNT).setValue(newUsage);
+          // メモリ上のデータも更新（後続のジャンルで正しいusage_countを参照するため）
+          item.row[QUESTIONDB_COLUMNS.USAGE_COUNT - 1] = newUsage;
+        }
+
+        // オブジェクト形式に変換して結果に追加
+        for (const item of selected) {
+          results.push(rowToQuestionObject_(item.row));
+        }
+
+        Logger.log(`ジャンル '${genre}': ${selected.length}/${count}問取得（USAGE_COUNT更新済）`);
+      }
+    }
+
+    Logger.log(`合計 ${results.length} 問を取得しました`);
+    return results;
+
+  } catch (error) {
+    Logger.log(`get_questions_by_genre_config エラー: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * 指定した答えIDの使用回数を+1する
+ *
+ * @param {Array<string>} answerIds - 答えIDの配列
+ * @returns {Object} 更新結果 { success: true, updated_count: number }
+ *
+ * @example
+ * // 2件の使用回数を更新
+ * const result = update_usage_count(['jp_001', 'jp_042']);
+ * console.log(result); // { success: true, updated_count: 2 }
+ */
+function update_usage_count(answerIds) {
+  try {
+    if (!Array.isArray(answerIds) || answerIds.length === 0) {
+      Logger.log('answer_ids が空または無効です');
+      return { success: false, updated_count: 0, error: 'Invalid answer_ids' };
+    }
+
+    const sheet = getQuestionDatabaseSheet_();
+    const lastRow = sheet.getLastRow();
+
+    if (lastRow <= 1) {
+      Logger.log('QuestionDatabaseにデータがありません');
+      return { success: false, updated_count: 0, error: 'No data' };
+    }
+
+    // 全データを取得
+    const dataRange = sheet.getRange(2, 1, lastRow - 1, QUESTIONDB_HEADER.length);
+    const allData = dataRange.getValues();
+
+    let updatedCount = 0;
+
+    // answer_id でマッチする行を探して usage_count を +1
+    allData.forEach((row, index) => {
+      const answerId = row[QUESTIONDB_COLUMNS.ANSWER_ID - 1];
+
+      if (answerIds.includes(answerId)) {
+        const currentUsage = row[QUESTIONDB_COLUMNS.USAGE_COUNT - 1] || 0;
+        const newUsage = currentUsage + 1;
+
+        // usage_count セルを更新
+        const rowNumber = index + 2; // ヘッダー行を考慮
+        sheet.getRange(rowNumber, QUESTIONDB_COLUMNS.USAGE_COUNT).setValue(newUsage);
+
+        Logger.log(`${answerId} の使用回数を ${currentUsage} → ${newUsage} に更新`);
+        updatedCount++;
+      }
+    });
+
+    Logger.log(`合計 ${updatedCount} 件の使用回数を更新しました`);
+
+    return {
+      success: true,
+      updated_count: updatedCount
+    };
+
+  } catch (error) {
+    Logger.log(`update_usage_count エラー: ${error.message}`);
+    return {
+      success: false,
+      updated_count: 0,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * 答えデータを一括挿入（初期データ投入用）
+ *
+ * @param {Array<Object>} answers - 答えデータの配列
+ * @returns {Object} 挿入結果 { success: true, inserted_count: number }
+ *
+ * @example
+ * const answers = [
+ *   {
+ *     answer_id: 'jp_001',
+ *     subject: 'jp',
+ *     category: 'JP01',
+ *     answer: '漢字',
+ *     question_hint: '部首を手がかりに意味を推測させる',
+ *     difficulty: '基本',
+ *     source_context: '小学3年生の漢字学習',
+ *     usage_count: 0
+ *   },
+ *   ...
+ * ];
+ * const result = bulk_insert_answers(answers);
+ */
+function bulk_insert_answers(answers) {
+  try {
+    if (!Array.isArray(answers) || answers.length === 0) {
+      Logger.log('answers が空または無効です');
+      return { success: false, inserted_count: 0, error: 'Invalid answers' };
+    }
+
+    const sheet = getQuestionDatabaseSheet_();
+    const lastRow = sheet.getLastRow();
+
+    // オブジェクト配列を行データに変換
+    const rows = answers.map(obj => questionObjectToRow_(obj));
+
+    // データを一括挿入
+    const startRow = lastRow + 1;
+    const range = sheet.getRange(startRow, 1, rows.length, QUESTIONDB_HEADER.length);
+    range.setValues(rows);
+
+    Logger.log(`${rows.length} 件のデータを挿入しました（行 ${startRow} ～ ${startRow + rows.length - 1}）`);
+
+    return {
+      success: true,
+      inserted_count: rows.length
+    };
+
+  } catch (error) {
+    Logger.log(`bulk_insert_answers エラー: ${error.message}`);
+    return {
+      success: false,
+      inserted_count: 0,
+      error: error.message
+    };
+  }
+}
+
+// ==================== 管理用ユーティリティ ====================
+
+/**
+ * QuestionDatabaseの統計情報を取得
+ *
+ * @returns {Object} 統計情報
+ */
+function getQuestionDatabaseStats() {
+  const sheet = getQuestionDatabaseSheet_();
+  const lastRow = sheet.getLastRow();
+
+  if (lastRow <= 1) {
+    return {
+      total_count: 0,
+      subjects: {}
+    };
+  }
+
+  const dataRange = sheet.getRange(2, 1, lastRow - 1, QUESTIONDB_HEADER.length);
+  const allData = dataRange.getValues();
+
+  const stats = {
+    total_count: allData.length,
+    subjects: {}
+  };
+
+  allData.forEach(row => {
+    const subject = row[QUESTIONDB_COLUMNS.SUBJECT - 1];
+    const category = row[QUESTIONDB_COLUMNS.CATEGORY - 1];
+    const usageCount = row[QUESTIONDB_COLUMNS.USAGE_COUNT - 1] || 0;
+
+    if (!stats.subjects[subject]) {
+      stats.subjects[subject] = {
+        count: 0,
+        categories: {},
+        total_usage: 0,
+        min_usage: Infinity,
+        max_usage: 0
+      };
+    }
+
+    stats.subjects[subject].count++;
+    stats.subjects[subject].total_usage += usageCount;
+    stats.subjects[subject].min_usage = Math.min(stats.subjects[subject].min_usage, usageCount);
+    stats.subjects[subject].max_usage = Math.max(stats.subjects[subject].max_usage, usageCount);
+
+    if (!stats.subjects[subject].categories[category]) {
+      stats.subjects[subject].categories[category] = 0;
+    }
+    stats.subjects[subject].categories[category]++;
+  });
+
+  Logger.log('QuestionDatabase統計情報:');
+  Logger.log(JSON.stringify(stats, null, 2));
+
+  return stats;
+}
+
+/**
+ * 指定した教科のデータを全削除
+ *
+ * @param {string} subject - 教科コード (jp, math, sci, soc)
+ * @returns {Object} 削除結果 { success: true, deleted_count: number }
+ */
+function deleteBySubject(subject) {
+  try {
+    if (!subject) {
+      Logger.log('subject が指定されていません');
+      return { success: false, deleted_count: 0, error: 'subject required' };
+    }
+
+    const sheet = getQuestionDatabaseSheet_();
+    const lastRow = sheet.getLastRow();
+
+    if (lastRow <= 1) {
+      Logger.log('QuestionDatabaseにデータがありません');
+      return { success: true, deleted_count: 0 };
+    }
+
+    // 全データを取得
+    const dataRange = sheet.getRange(2, 1, lastRow - 1, QUESTIONDB_HEADER.length);
+    const allData = dataRange.getValues();
+
+    // 削除対象の行番号を特定（後ろから削除するため逆順）
+    const rowsToDelete = [];
+    allData.forEach((row, index) => {
+      if (row[QUESTIONDB_COLUMNS.SUBJECT - 1] === subject) {
+        rowsToDelete.push(index + 2); // ヘッダー行を考慮
+      }
+    });
+
+    // 後ろから削除（行番号がずれないように）
+    rowsToDelete.reverse().forEach(rowNum => {
+      sheet.deleteRow(rowNum);
+    });
+
+    Logger.log(`教科 '${subject}' の ${rowsToDelete.length} 件を削除しました`);
+
+    return {
+      success: true,
+      deleted_count: rowsToDelete.length
+    };
+
+  } catch (error) {
+    Logger.log(`deleteBySubject エラー: ${error.message}`);
+    return {
+      success: false,
+      deleted_count: 0,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * QuestionDatabaseシートにヘッダ行を追加
+ *
+ * @returns {Object} 結果 { success: true, message: string }
+ */
+function addQuestionDatabaseHeader() {
+  try {
+    const ss = SpreadsheetApp.getActiveSpreadsheet();
+    let sheet = ss.getSheetByName(QUESTIONDB_SHEET_NAME);
+
+    if (!sheet) {
+      // シートがない場合は作成
+      sheet = ss.insertSheet(QUESTIONDB_SHEET_NAME);
+      Logger.log('QuestionDatabaseシートを新規作成しました');
+    }
+
+    // ヘッダー行を設定（既存データがある場合は行1に挿入）
+    const firstRow = sheet.getRange(1, 1, 1, QUESTIONDB_HEADER.length);
+    const currentFirstRow = firstRow.getValues()[0];
+
+    // 既にヘッダーがあるかチェック
+    if (currentFirstRow[0] === 'answer_id') {
+      return {
+        success: true,
+        message: 'Header already exists'
+      };
+    }
+
+    // ヘッダーがない場合、行1に挿入
+    if (currentFirstRow[0] !== '' && currentFirstRow[0] !== 'answer_id') {
+      // データがある場合は行を挿入
+      sheet.insertRowBefore(1);
+    }
+
+    // ヘッダーを設定
+    sheet.getRange(1, 1, 1, QUESTIONDB_HEADER.length).setValues([QUESTIONDB_HEADER]);
+    sheet.getRange(1, 1, 1, QUESTIONDB_HEADER.length).setFontWeight('bold');
+    sheet.setFrozenRows(1);
+
+    Logger.log('QuestionDatabaseヘッダ行を追加しました');
+
+    return {
+      success: true,
+      message: 'Header added successfully'
+    };
+
+  } catch (error) {
+    Logger.log(`addQuestionDatabaseHeader エラー: ${error.message}`);
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * 全データのusage_countをリセット（開発/テスト用）
+ *
+ * @returns {Object} リセット結果
+ */
+function resetAllUsageCount() {
+  const sheet = getQuestionDatabaseSheet_();
+  const lastRow = sheet.getLastRow();
+
+  if (lastRow <= 1) {
+    Logger.log('QuestionDatabaseにデータがありません');
+    return { success: false, message: 'No data' };
+  }
+
+  const usageCountRange = sheet.getRange(2, QUESTIONDB_COLUMNS.USAGE_COUNT, lastRow - 1, 1);
+  const zeros = Array(lastRow - 1).fill([0]);
+  usageCountRange.setValues(zeros);
+
+  Logger.log(`${lastRow - 1} 件の usage_count を 0 にリセットしました`);
+
+  return {
+    success: true,
+    reset_count: lastRow - 1
+  };
+}
+
+// ==================== Web API エンドポイント ====================
+
+/**
+ * doPost エンドポイント（既存のコードに統合用）
+ *
+ * アクション一覧:
+ * - get_random_answers: ランダムに答えを取得
+ * - update_usage_count: 使用回数を更新
+ * - bulk_insert_answers: 一括挿入
+ *
+ * 使用例:
+ *
+ * // get_random_answers
+ * POST https://script.google.com/macros/s/.../exec
+ * {
+ *   "action": "get_random_answers",
+ *   "subject": "jp",
+ *   "count": 3
+ * }
+ *
+ * // update_usage_count
+ * POST https://script.google.com/macros/s/.../exec
+ * {
+ *   "action": "update_usage_count",
+ *   "answer_ids": ["jp_001", "jp_042"]
+ * }
+ *
+ * // bulk_insert_answers
+ * POST https://script.google.com/macros/s/.../exec
+ * {
+ *   "action": "bulk_insert_answers",
+ *   "answers": [
+ *     {
+ *       "answer_id": "jp_001",
+ *       "subject": "jp",
+ *       "category": "JP01",
+ *       "answer": "漢字",
+ *       "question_hint": "部首を手がかりに",
+ *       "difficulty": "基本",
+ *       "source_context": "小学3年生",
+ *       "usage_count": 0
+ *     }
+ *   ]
+ * }
+ */
+function handleQuestionDatabaseAction(action, params) {
+  switch (action) {
+    case 'get_random_answers':
+      return get_random_answers(params.subject, params.count || 1);
+
+    case 'get_random_questions':
+      // Python互換: get_questions_by_configと同じだが、レスポンス形式を調整
+      try {
+        const questions = get_questions_by_genre_config(params.subjects || []);
+        return {
+          success: true,
+          data: {
+            questions: questions
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+
+    case 'get_questions_by_config':
+      // v1.6.3: ジャンル構成に基づく問題取得
+      return get_questions_by_genre_config(params.subjects || []);
+
+    case 'update_usage_count':
+      return update_usage_count(params.answer_ids || []);
+
+    case 'bulk_insert_answers':
+      return bulk_insert_answers(params.answers || []);
+
+    case 'get_stats':
+      return getQuestionDatabaseStats();
+
+    case 'reset_usage':
+      return resetAllUsageCount();
+
+    case 'delete_by_subject':
+      return deleteBySubject(params.subject);
+
+    case 'add_header':
+      return addQuestionDatabaseHeader();
+
+    default:
+      return {
+        success: false,
+        error: `Unknown action: ${action}`
+      };
+  }
+}
+
+// ==================== テスト用関数 ====================
+
+/**
+ * テスト用: サンプルデータを挿入
+ */
+function testInsertSampleData() {
+  const sampleData = [
+    {
+      answer_id: 'jp_001',
+      subject: 'jp',
+      category: 'JP01',
+      answer: '憂鬱',
+      question_hint: '気分が晴れない様子を表す漢字',
+      difficulty: '標準',
+      source_context: '中学国語教科書',
+      usage_count: 0
+    },
+    {
+      answer_id: 'jp_002',
+      subject: 'jp',
+      category: 'JP01',
+      answer: '慈悲',
+      question_hint: '思いやりの心を表す熟語',
+      difficulty: '基本',
+      source_context: '小学6年生',
+      usage_count: 0
+    },
+    {
+      answer_id: 'jp_003',
+      subject: 'jp',
+      category: 'JP02',
+      answer: 'である',
+      question_hint: '断定の助動詞',
+      difficulty: '基本',
+      source_context: '中学文法',
+      usage_count: 0
+    },
+    {
+      answer_id: 'math_001',
+      subject: 'math',
+      category: 'MA01',
+      answer: '平方根',
+      question_hint: '2乗してその数になる数',
+      difficulty: '標準',
+      source_context: '中学3年数学',
+      usage_count: 0
+    }
+  ];
+
+  const result = bulk_insert_answers(sampleData);
+  Logger.log('サンプルデータ挿入結果:');
+  Logger.log(JSON.stringify(result, null, 2));
+}
+
+/**
+ * テスト用: get_random_answers のテスト
+ */
+function testGetRandomAnswers() {
+  const answers = get_random_answers('jp', 2);
+  Logger.log('取得した答え:');
+  Logger.log(JSON.stringify(answers, null, 2));
+}
+
+/**
+ * テスト用: update_usage_count のテスト
+ */
+function testUpdateUsageCount() {
+  const result = update_usage_count(['jp_001', 'jp_002']);
+  Logger.log('更新結果:');
+  Logger.log(JSON.stringify(result, null, 2));
+}
+
+/**
+ * テスト用: get_questions_by_genre_config のテスト（v1.6.3）
+ */
+function testGetQuestionsByGenreConfig() {
+  const questions = get_questions_by_genre_config(['jp', 'math']);
+  Logger.log(`取得した問題数: ${questions.length}`);
+
+  // ジャンル別の内訳を表示
+  const genreCounts = {};
+  for (const q of questions) {
+    const key = `${q.subject}/${q.category}`;
+    genreCounts[key] = (genreCounts[key] || 0) + 1;
+  }
+
+  Logger.log('ジャンル別内訳:');
+  Logger.log(JSON.stringify(genreCounts, null, 2));
+}

V1.7.1/gas/setup_dify_properties.js

@@ -0,0 +1,468 @@
+/**
+ * Dify環境変数設定スクリプト
+ *
+ * Google Apps ScriptのScriptPropertiesに、Dify API統合に必要な環境変数を設定・管理します。
+ *
+ * 主要機能:
+ * - Dify API URL・API Keyの設定
+ * - 設定値の取得・確認
+ * - Dify APIへの接続テスト
+ * - 環境変数のクリア（デバッグ用）
+ *
+ * @version 1.0.0
+ * @date 2025-11-10
+ */
+
+// ============================================================================
+// 定数定義
+// ============================================================================
+
+/**
+ * 環境変数のキー名
+ */
+const PROPERTY_KEYS = {
+  DIFY_API_URL: 'DIFY_API_URL',
+  DIFY_API_KEY: 'DIFY_API_KEY',
+  SPREADSHEET_ID: 'SPREADSHEET_ID'
+};
+
+// ============================================================================
+// 環境変数設定関数
+// ============================================================================
+
+/**
+ * Dify関連の環境変数をScriptPropertiesに設定します
+ *
+ * 設定される環境変数:
+ * - DIFY_API_URL: Difyワークフロー実行エンドポイント
+ * - DIFY_API_KEY: Dify APIキー
+ * - SPREADSHEET_ID: Google SheetsのスプレッドシートID（確認用）
+ *
+ * 実行方法:
+ * 1. Apps Scriptエディタでこのファイルを開く
+ * 2. 関数 setDifyProperties を選択して実行
+ * 3. 実行ログで結果を確認
+ *
+ * 注意:
+ * - 実際の値を設定する際は、以下のダミー値を実際の値に置き換えてください
+ * - API Keyは機密情報のため、取り扱いに注意してください
+ *
+ * @returns {void}
+ *
+ * @example
+ * // 実行例（Apps Scriptエディタで実行）
+ * setDifyProperties();
+ * // ログ出力: 「✅ Dify環境変数の設定が完了しました」
+ */
+function setDifyProperties() {
+  try {
+    const properties = PropertiesService.getScriptProperties();
+
+    // ========================================================================
+    // 【重要】実際の値に置き換えてください
+    // ========================================================================
+
+    // Dify Cloud のワークフロー実行エンドポイント
+    // 例: 'https://api.dify.ai/v1/workflows/run'
+    const DIFY_API_URL = 'https://api.dify.ai/v1/workflows/run';
+
+    // Dify Cloud のAPI Key（ワークフロー作成後に取得）
+    // 例: 'app-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+    const DIFY_API_KEY = 'app-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
+
+    // Google SheetsのスプレッドシートID（既存、確認用）
+    // 既にCode.jsで定義されている値
+    const SPREADSHEET_ID = '1xlyaDpCrg4M-epbQ-KqemjpDeabxBjZ7aVCvRgRLazE';
+
+    // ========================================================================
+    // 環境変数の設定
+    // ========================================================================
+
+    properties.setProperty(PROPERTY_KEYS.DIFY_API_URL, DIFY_API_URL);
+    properties.setProperty(PROPERTY_KEYS.DIFY_API_KEY, DIFY_API_KEY);
+    properties.setProperty(PROPERTY_KEYS.SPREADSHEET_ID, SPREADSHEET_ID);
+
+    Logger.log('✅ Dify環境変数の設定が完了しました');
+    Logger.log('');
+    Logger.log('設定内容:');
+    Logger.log('  DIFY_API_URL: ' + DIFY_API_URL);
+    Logger.log('  DIFY_API_KEY: ' + maskApiKey(DIFY_API_KEY));
+    Logger.log('  SPREADSHEET_ID: ' + SPREADSHEET_ID);
+    Logger.log('');
+    Logger.log('次のステップ: getDifyProperties() を実行して設定を確認してください');
+
+  } catch (error) {
+    Logger.log('❌ エラー: Dify環境変数の設定に失敗しました');
+    Logger.log('詳細: ' + error.toString());
+    throw new Error('環境変数の設定に失敗しました: ' + error.toString());
+  }
+}
+
+// ============================================================================
+// 環境変数取得関数
+// ============================================================================
+
+/**
+ * 設定されたDify環境変数を取得・確認します
+ *
+ * 取得する環境変数:
+ * - DIFY_API_URL: Difyワークフロー実行エンドポイント
+ * - DIFY_API_KEY: Dify APIキー（マスク表示）
+ * - SPREADSHEET_ID: Google SheetsのスプレッドシートID
+ *
+ * 実行方法:
+ * 1. Apps Scriptエディタでこのファイルを開く
+ * 2. 関数 getDifyProperties を選択して実行
+ * 3. 実行ログで設定内容を確認
+ *
+ * @returns {Object} 環境変数のオブジェクト
+ * @returns {string} returns.DIFY_API_URL - Dify API URL
+ * @returns {string} returns.DIFY_API_KEY - Dify API Key
+ * @returns {string} returns.SPREADSHEET_ID - スプレッドシートID
+ *
+ * @example
+ * // 実行例（Apps Scriptエディタで実行）
+ * const props = getDifyProperties();
+ * // ログ出力: 各環境変数の値
+ *
+ * @example
+ * // コード内での使用例
+ * const props = getDifyProperties();
+ * const apiUrl = props.DIFY_API_URL;
+ * const apiKey = props.DIFY_API_KEY;
+ */
+function getDifyProperties() {
+  try {
+    const properties = PropertiesService.getScriptProperties();
+
+    const difyApiUrl = properties.getProperty(PROPERTY_KEYS.DIFY_API_URL);
+    const difyApiKey = properties.getProperty(PROPERTY_KEYS.DIFY_API_KEY);
+    const spreadsheetId = properties.getProperty(PROPERTY_KEYS.SPREADSHEET_ID);
+
+    Logger.log('📋 Dify環境変数の取得結果:');
+    Logger.log('');
+    Logger.log('  DIFY_API_URL: ' + (difyApiUrl || '（未設定）'));
+    Logger.log('  DIFY_API_KEY: ' + (difyApiKey ? maskApiKey(difyApiKey) : '（未設定）'));
+    Logger.log('  SPREADSHEET_ID: ' + (spreadsheetId || '（未設定）'));
+    Logger.log('');
+
+    // 未設定の項目をチェック
+    const missingKeys = [];
+    if (!difyApiUrl) missingKeys.push('DIFY_API_URL');
+    if (!difyApiKey) missingKeys.push('DIFY_API_KEY');
+    if (!spreadsheetId) missingKeys.push('SPREADSHEET_ID');
+
+    if (missingKeys.length > 0) {
+      Logger.log('⚠️  未設定の環境変数があります: ' + missingKeys.join(', '));
+      Logger.log('setDifyProperties() を実行して設定してください');
+    } else {
+      Logger.log('✅ すべての環境変数が設定されています');
+    }
+
+    return {
+      DIFY_API_URL: difyApiUrl,
+      DIFY_API_KEY: difyApiKey,
+      SPREADSHEET_ID: spreadsheetId
+    };
+
+  } catch (error) {
+    Logger.log('❌ エラー: Dify環境変数の取得に失敗しました');
+    Logger.log('詳細: ' + error.toString());
+    throw new Error('環境変数の取得に失敗しました: ' + error.toString());
+  }
+}
+
+// ============================================================================
+// Dify接続テスト関数
+// ============================================================================
+
+/**
+ * Dify APIへの接続テストを実行します
+ *
+ * テスト内容:
+ * - 環境変数の存在確認
+ * - Dify API URLへのHTTPリクエスト送信
+ * - レスポンスステータスの確認
+ *
+ * 実行方法:
+ * 1. setDifyProperties() を実行して環境変数を設定
+ * 2. Apps Scriptエディタでこのファイルを開く
+ * 3. 関数 testDifyConnection を選択して実行
+ * 4. 実行ログで接続テスト結果を確認
+ *
+ * 注意:
+ * - 実際のDify Cloudアカウントとワークフロー作成が必要です
+ * - API Keyが正しく設定されていることを確認してください
+ *
+ * @returns {Object} テスト結果のオブジェクト
+ * @returns {boolean} returns.success - テスト成功フラグ
+ * @returns {string} returns.message - テスト結果メッセージ
+ * @returns {Object} returns.response - APIレスポンス（成功時）
+ *
+ * @example
+ * // 実行例（Apps Scriptエディタで実行）
+ * testDifyConnection();
+ * // ログ出力: 「✅ Dify API接続テスト成功」または「❌ 接続テスト失敗」
+ */
+function testDifyConnection() {
+  try {
+    Logger.log('🔄 Dify API接続テストを開始します...');
+    Logger.log('');
+
+    // 環境変数の取得
+    const properties = PropertiesService.getScriptProperties();
+    const difyApiUrl = properties.getProperty(PROPERTY_KEYS.DIFY_API_URL);
+    const difyApiKey = properties.getProperty(PROPERTY_KEYS.DIFY_API_KEY);
+
+    // 環境変数の存在確認
+    if (!difyApiUrl || !difyApiKey) {
+      Logger.log('❌ エラー: 環境変数が未設定です');
+      Logger.log('setDifyProperties() を実行して環境変数を設定してください');
+      return {
+        success: false,
+        message: '環境変数が未設定です'
+      };
+    }
+
+    Logger.log('環境変数の確認: ✅');
+    Logger.log('  DIFY_API_URL: ' + difyApiUrl);
+    Logger.log('  DIFY_API_KEY: ' + maskApiKey(difyApiKey));
+    Logger.log('');
+
+    // テスト用のリクエストペイロード
+    const testPayload = {
+      inputs: {
+        subject: '算数',
+        category: '四則計算',
+        test: true
+      },
+      response_mode: 'blocking',
+      user: 'gas-test-user'
+    };
+
+    // HTTPリクエストオプション
+    const options = {
+      method: 'post',
+      contentType: 'application/json',
+      headers: {
+        'Authorization': 'Bearer ' + difyApiKey
+      },
+      payload: JSON.stringify(testPayload),
+      muteHttpExceptions: true // エラーレスポンスも取得するため
+    };
+
+    Logger.log('🌐 Dify APIへリクエストを送信中...');
+    Logger.log('URL: ' + difyApiUrl);
+    Logger.log('');
+
+    // Dify APIへのリクエスト送信
+    const response = UrlFetchApp.fetch(difyApiUrl, options);
+    const responseCode = response.getResponseCode();
+    const responseText = response.getContentText();
+
+    Logger.log('📥 レスポンスを受信しました');
+    Logger.log('ステータスコード: ' + responseCode);
+    Logger.log('');
+
+    // レスポンスの解析
+    if (responseCode === 200) {
+      const responseData = JSON.parse(responseText);
+      Logger.log('✅ Dify API接続テスト成功');
+      Logger.log('');
+      Logger.log('レスポンス内容:');
+      Logger.log(JSON.stringify(responseData, null, 2));
+
+      return {
+        success: true,
+        message: '接続テスト成功',
+        response: responseData
+      };
+
+    } else {
+      Logger.log('❌ Dify API接続テスト失敗');
+      Logger.log('ステータスコード: ' + responseCode);
+      Logger.log('エラー内容: ' + responseText);
+      Logger.log('');
+      Logger.log('考えられる原因:');
+      Logger.log('  1. DIFY_API_URL が正しくない');
+      Logger.log('  2. DIFY_API_KEY が正しくない');
+      Logger.log('  3. Difyワークフローがまだ作成されていない');
+      Logger.log('  4. Difyワークフローが公開されていない');
+
+      return {
+        success: false,
+        message: '接続テスト失敗（ステータスコード: ' + responseCode + '）',
+        error: responseText
+      };
+    }
+
+  } catch (error) {
+    Logger.log('❌ エラー: Dify API接続テストでエラーが発生しました');
+    Logger.log('詳細: ' + error.toString());
+    Logger.log('');
+    Logger.log('考えられる原因:');
+    Logger.log('  1. ネットワーク接続エラー');
+    Logger.log('  2. URLが不正（例: プロトコル未指定）');
+    Logger.log('  3. Apps Scriptの外部API接続権限が不足');
+
+    return {
+      success: false,
+      message: '接続テスト中にエラーが発生しました: ' + error.toString()
+    };
+  }
+}
+
+// ============================================================================
+// 環境変数クリア関数（デバッグ用）
+// ============================================================================
+
+/**
+ * 設定されたDify環境変数をクリアします（デバッグ用）
+ *
+ * 削除される環境変数:
+ * - DIFY_API_URL
+ * - DIFY_API_KEY
+ * - SPREADSHEET_ID
+ *
+ * 実行方法:
+ * 1. Apps Scriptエディタでこのファイルを開く
+ * 2. 関数 clearDifyProperties を選択して実行
+ * 3. 実行ログで削除結果を確認
+ *
+ * 注意:
+ * - この操作は元に戻せません
+ * - 誤って実行しないように注意してください
+ * - 本番環境では使用しないでください
+ *
+ * @returns {void}
+ *
+ * @example
+ * // 実行例（Apps Scriptエディタで実行）
+ * clearDifyProperties();
+ * // ログ出力: 「✅ Dify環境変数のクリアが完了しました」
+ */
+function clearDifyProperties() {
+  try {
+    const properties = PropertiesService.getScriptProperties();
+
+    Logger.log('🔄 Dify環境変数のクリアを開始します...');
+    Logger.log('');
+
+    // 削除前の確認
+    const before = getDifyPropertiesInternal(properties);
+    Logger.log('削除前の設定:');
+    Logger.log('  DIFY_API_URL: ' + (before.DIFY_API_URL ? '設定あり' : '設定なし'));
+    Logger.log('  DIFY_API_KEY: ' + (before.DIFY_API_KEY ? '設定あり' : '設定なし'));
+    Logger.log('  SPREADSHEET_ID: ' + (before.SPREADSHEET_ID ? '設定あり' : '設定なし'));
+    Logger.log('');
+
+    // 環境変数の削除
+    properties.deleteProperty(PROPERTY_KEYS.DIFY_API_URL);
+    properties.deleteProperty(PROPERTY_KEYS.DIFY_API_KEY);
+    properties.deleteProperty(PROPERTY_KEYS.SPREADSHEET_ID);
+
+    Logger.log('✅ Dify環境変数のクリアが完了しました');
+    Logger.log('');
+    Logger.log('削除された環境変数:');
+    Logger.log('  - DIFY_API_URL');
+    Logger.log('  - DIFY_API_KEY');
+    Logger.log('  - SPREADSHEET_ID');
+    Logger.log('');
+    Logger.log('再設定する場合: setDifyProperties() を実行してください');
+
+  } catch (error) {
+    Logger.log('❌ エラー: Dify環境変数のクリアに失敗しました');
+    Logger.log('詳細: ' + error.toString());
+    throw new Error('環境変数のクリアに失敗しました: ' + error.toString());
+  }
+}
+
+// ============================================================================
+// ユーティリティ関数
+// ============================================================================
+
+/**
+ * API Keyをマスク表示します（セキュリティ対策）
+ *
+ * 例: 'app-abc123xyz789' → 'app-abc***xyz789'
+ *
+ * @param {string} apiKey - API Key
+ * @returns {string} マスク表示されたAPI Key
+ * @private
+ */
+function maskApiKey(apiKey) {
+  if (!apiKey || apiKey.length < 10) {
+    return '***';
+  }
+  const prefix = apiKey.substring(0, 7);
+  const suffix = apiKey.substring(apiKey.length - 6);
+  return prefix + '***' + suffix;
+}
+
+/**
+ * 環境変数を取得します（内部用、ログ出力なし）
+ *
+ * @param {PropertiesService.Properties} properties - Propertiesオブジェクト
+ * @returns {Object} 環境変数のオブジェクト
+ * @private
+ */
+function getDifyPropertiesInternal(properties) {
+  return {
+    DIFY_API_URL: properties.getProperty(PROPERTY_KEYS.DIFY_API_URL),
+    DIFY_API_KEY: properties.getProperty(PROPERTY_KEYS.DIFY_API_KEY),
+    SPREADSHEET_ID: properties.getProperty(PROPERTY_KEYS.SPREADSHEET_ID)
+  };
+}
+
+// ============================================================================
+// 使用例・実行手順
+// ============================================================================
+
+/**
+ * 【実行手順】
+ *
+ * 1. 環境変数の設定
+ *    - setDifyProperties() を実行
+ *    - 事前に関数内のダミー値を実際の値に置き換えてください
+ *
+ * 2. 設定の確認
+ *    - getDifyProperties() を実行
+ *    - 実行ログで設定内容を確認してください
+ *
+ * 3. 接続テスト
+ *    - testDifyConnection() を実行
+ *    - Dify APIへの接続が成功するか確認してください
+ *
+ * 4. 環境変数のクリア（必要な場合のみ）
+ *    - clearDifyProperties() を実行
+ *    - 誤って実行しないように注意してください
+ *
+ * 【Code.jsでの使用例】
+ *
+ * ```javascript
+ * // 環境変数の取得
+ * const properties = PropertiesService.getScriptProperties();
+ * const DIFY_API_URL = properties.getProperty('DIFY_API_URL');
+ * const DIFY_API_KEY = properties.getProperty('DIFY_API_KEY');
+ *
+ * // Dify APIへのリクエスト送信
+ * function callDifyAPI(inputs) {
+ *   const options = {
+ *     method: 'post',
+ *     contentType: 'application/json',
+ *     headers: {
+ *       'Authorization': 'Bearer ' + DIFY_API_KEY
+ *     },
+ *     payload: JSON.stringify({
+ *       inputs: inputs,
+ *       response_mode: 'blocking',
+ *       user: 'gas-orchestrator'
+ *     }),
+ *     muteHttpExceptions: true
+ *   };
+ *
+ *   const response = UrlFetchApp.fetch(DIFY_API_URL, options);
+ *   return JSON.parse(response.getContentText());
+ * }
+ * ```
+ */

V1.7.1/gas/setup_sheets_v2.js

@@ -0,0 +1,524 @@
+/**
+ * サイクル1.2.5: Google Sheets拡張（7シート構成への移行）
+ *
+ * このスクリプトは「超天才クイズDB」を4シート構成から7シート構成に自動拡張します。
+ *
+ * 実行方法:
+ * 1. Apps Scriptエディタで本ファイルを開く
+ * 2. setupSheetsV2関数を選択
+ * 3. 実行ボタンをクリック
+ * 4. ログで結果を確認
+ *
+ * 仕様:
+ * - 新規シート作成: Answers, Statistics, Evaluations（各ヘッダー + サンプルデータ）
+ * - 既存シート更新: Questions, Knowledge_Baseに`category`列追加
+ * - 安全機能: 既存シートチェック、重複チェック、エラーハンドリング
+ *
+ * 参照:
+ * - docs/data-model.md v2.0
+ * - docs/sheets-setup-manual-v2.md
+ *
+ * バージョン: 1.0
+ * 作成日: 2025-11-10
+ */
+
+// Note: SPREADSHEET_IDはCode.jsで定義済みのためここでは宣言しない
+
+/**
+ * メイン関数: Google Sheetsを7シート構成に拡張
+ */
+function setupSheetsV2() {
+  try {
+    Logger.log('=== Google Sheets拡張開始（v2.0: 7シート構成） ===');
+
+    // スプレッドシート取得（Code.jsで定義されたSPREADSHEET_IDを使用）
+    var spreadsheet = SpreadsheetApp.openById(SPREADSHEET_ID);
+    Logger.log('スプレッドシート取得成功: ' + spreadsheet.getName());
+
+    // 既存シート確認
+    Logger.log('\n--- 既存シート確認 ---');
+    checkExistingSheets(spreadsheet);
+
+    // 新規シート作成（3シート）
+    Logger.log('\n--- 新規シート作成 ---');
+    createAnswersSheet(spreadsheet);
+    createStatisticsSheet(spreadsheet);
+    createEvaluationsSheet(spreadsheet);
+
+    // 既存シート更新（2シート）
+    Logger.log('\n--- 既存シート更新 ---');
+    updateQuestionsSheet(spreadsheet);
+    updateKnowledgeBaseSheet(spreadsheet);
+
+    Logger.log('\n=== Google Sheets拡張完了！ ===');
+    Logger.log('結果: 7シート構成に拡張成功');
+    Logger.log('次のステップ: Google Sheetsを開いて7シート全て存在することを確認してください');
+
+  } catch (error) {
+    Logger.log('\n❌ エラー発生: ' + error.message);
+    Logger.log('スタックトレース: ' + error.stack);
+    throw error;
+  }
+}
+
+/**
+ * 既存シート確認
+ */
+function checkExistingSheets(spreadsheet) {
+  var sheets = spreadsheet.getSheets();
+  Logger.log('現在のシート数: ' + sheets.length);
+
+  for (var i = 0; i < sheets.length; i++) {
+    Logger.log('  - ' + sheets[i].getName());
+  }
+
+  // 必須シート確認（Users, Sessions, Questions, Knowledge_Base）
+  var requiredSheets = ['Users', 'Sessions', 'Questions', 'Knowledge_Base'];
+  for (var j = 0; j < requiredSheets.length; j++) {
+    var sheet = spreadsheet.getSheetByName(requiredSheets[j]);
+    if (!sheet) {
+      throw new Error('必須シート「' + requiredSheets[j] + '」が存在しません。サイクル1.2を先に実行してください。');
+    }
+  }
+  Logger.log('必須シート（4シート）確認完了');
+}
+
+/**
+ * Answersシート作成
+ */
+function createAnswersSheet(spreadsheet) {
+  var sheetName = 'Answers';
+
+  // 既存チェック
+  if (spreadsheet.getSheetByName(sheetName)) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既に存在します。スキップします。');
+    return;
+  }
+
+  Logger.log(sheetName + 'シートを作成中...');
+
+  // シート作成
+  var sheet = spreadsheet.insertSheet(sheetName);
+
+  // ヘッダー行（1行目）
+  var headers = [
+    'answer_id',
+    'session_id',
+    'question_id',
+    'user_answer',
+    'is_correct',
+    'time_taken',
+    'answered_at'
+  ];
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+
+  // サンプルデータ（2行）
+  var sampleData = [
+    ['ans-sample-001', 'session-sample-001', 'q-sample-001', 0, true, 12, '2025-11-04T10:31:15Z'],
+    ['ans-sample-002', 'session-sample-001', 'q-sample-002', 2, false, 18, '2025-11-04T10:31:33Z']
+  ];
+  sheet.getRange(2, 1, sampleData.length, headers.length).setValues(sampleData);
+
+  Logger.log('✅ ' + sheetName + 'シート作成完了（ヘッダー + サンプルデータ2行）');
+}
+
+/**
+ * Statisticsシート作成
+ */
+function createStatisticsSheet(spreadsheet) {
+  var sheetName = 'Statistics';
+
+  // 既存チェック
+  if (spreadsheet.getSheetByName(sheetName)) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既に存在します。スキップします。');
+    return;
+  }
+
+  Logger.log(sheetName + 'シートを作成中...');
+
+  // シート作成
+  var sheet = spreadsheet.insertSheet(sheetName);
+
+  // ヘッダー行（1行目）
+  var headers = [
+    'stat_id',
+    'user_id',
+    'subject',
+    'category',
+    'total_attempted',
+    'correct_count',
+    'accuracy_rate',
+    'last_updated'
+  ];
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+
+  // サンプルデータ（3行）
+  var sampleData = [
+    ['stat-001', 'sample-user-001', '国語', '漢字・語彙', 20, 16, 0.80, '2025-11-04T10:45:00Z'],
+    ['stat-002', 'sample-user-001', '国語', '物語文読解', 15, 9, 0.60, '2025-11-04T10:45:00Z'],
+    ['stat-003', 'sample-user-001', '算数', '平面図形', 10, 4, 0.40, '2025-11-04T10:45:00Z']
+  ];
+  sheet.getRange(2, 1, sampleData.length, headers.length).setValues(sampleData);
+
+  Logger.log('✅ ' + sheetName + 'シート作成完了（ヘッダー + サンプルデータ3行）');
+}
+
+/**
+ * Evaluationsシート作成
+ */
+function createEvaluationsSheet(spreadsheet) {
+  var sheetName = 'Evaluations';
+
+  // 既存チェック
+  if (spreadsheet.getSheetByName(sheetName)) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既に存在します。スキップします。');
+    return;
+  }
+
+  Logger.log(sheetName + 'シートを作成中...');
+
+  // シート作成
+  var sheet = spreadsheet.insertSheet(sheetName);
+
+  // ヘッダー行（1行目）
+  var headers = [
+    'eval_id',
+    'session_id',
+    'subject_evaluations',
+    'overall_evaluation',
+    'created_at'
+  ];
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+
+  // サンプルデータ（1行）
+  // JSON形式のデータは文字列として扱う（Google Sheetsは型なし）
+  var sampleData = [
+    [
+      'eval-001',
+      'session-sample-001',
+      '{"国語":["漢字・語彙は80%の正答率で安定"],"算数":["計算力が優れています"]}',
+      '["今回は合計29/40（72.5%）"]',
+      '2025-11-04T10:46:00Z'
+    ]
+  ];
+  sheet.getRange(2, 1, sampleData.length, headers.length).setValues(sampleData);
+
+  Logger.log('✅ ' + sheetName + 'シート作成完了（ヘッダー + サンプルデータ1行）');
+}
+
+/**
+ * Questionsシート更新（category列追加）
+ */
+function updateQuestionsSheet(spreadsheet) {
+  var sheetName = 'Questions';
+
+  Logger.log(sheetName + 'シートを更新中...');
+
+  // シート取得
+  var sheet = spreadsheet.getSheetByName(sheetName);
+  if (!sheet) {
+    throw new Error(sheetName + 'シートが存在しません');
+  }
+
+  // 現在のヘッダー行確認
+  var lastColumn = sheet.getLastColumn();
+  if (lastColumn === 0) {
+    Logger.log('⚠️ ' + sheetName + 'シートが空です。列追加をスキップします。');
+    return;
+  }
+
+  var headers = sheet.getRange(1, 1, 1, lastColumn).getValues()[0];
+  Logger.log('現在のヘッダー: ' + headers.join(', '));
+
+  // category列が既に存在するかチェック
+  var categoryIndex = headers.indexOf('category');
+  if (categoryIndex !== -1) {
+    Logger.log('⚠️ category列は既に存在します（列' + (categoryIndex + 1) + '）。スキップします。');
+    return;
+  }
+
+  // D列（subjectの次）に新規列を挿入
+  // 想定: A=question_id, B=session_id, C=subject, D=（新規category）, E=difficulty（元のD）...
+  var insertPosition = 4; // D列（1-indexed）
+  sheet.insertColumnBefore(insertPosition);
+
+  // D1にヘッダー「category」を追加
+  sheet.getRange(1, insertPosition).setValue('category');
+
+  // D2にサンプルデータを追加（既存のサンプルデータがある場合）
+  var lastRow = sheet.getLastRow();
+  if (lastRow >= 2) {
+    sheet.getRange(2, insertPosition).setValue('漢字・語彙');
+  }
+
+  Logger.log('✅ ' + sheetName + 'シート更新完了（D列にcategory追加）');
+}
+
+/**
+ * Knowledge_Baseシート更新（category列追加）
+ */
+function updateKnowledgeBaseSheet(spreadsheet) {
+  var sheetName = 'Knowledge_Base';
+
+  Logger.log(sheetName + 'シートを更新中...');
+
+  // シート取得
+  var sheet = spreadsheet.getSheetByName(sheetName);
+  if (!sheet) {
+    throw new Error(sheetName + 'シートが存在しません');
+  }
+
+  // 現在のヘッダー行確認
+  var lastColumn = sheet.getLastColumn();
+  if (lastColumn === 0) {
+    Logger.log('⚠️ ' + sheetName + 'シートが空です。列追加をスキップします。');
+    return;
+  }
+
+  var headers = sheet.getRange(1, 1, 1, lastColumn).getValues()[0];
+  Logger.log('現在のヘッダー: ' + headers.join(', '));
+
+  // category列が既に存在するかチェック
+  var categoryIndex = headers.indexOf('category');
+  if (categoryIndex !== -1) {
+    Logger.log('⚠️ category列は既に存在します（列' + (categoryIndex + 1) + '）。スキップします。');
+    return;
+  }
+
+  // C列（subjectの次）に新規列を挿入
+  // 想定: A=kb_id, B=subject, C=（新規category）, D=grade（元のC）...
+  var insertPosition = 3; // C列（1-indexed）
+  sheet.insertColumnBefore(insertPosition);
+
+  // C1にヘッダー「category」を追加
+  sheet.getRange(1, insertPosition).setValue('category');
+
+  // C2にサンプルデータを追加（既存のサンプルデータがある場合）
+  var lastRow = sheet.getLastRow();
+  if (lastRow >= 2) {
+    sheet.getRange(2, insertPosition).setValue('植物の成長');
+  }
+
+  Logger.log('✅ ' + sheetName + 'シート更新完了（C列にcategory追加）');
+}
+
+/**
+ * 空シート初期化関数: Sessions, Questions, Knowledge_Baseシートが空の場合に初期データを投入
+ *
+ * 実行方法:
+ * 1. Apps Scriptエディタで本ファイルを開く
+ * 2. initializeEmptySheets関数を選択
+ * 3. 実行ボタンをクリック
+ * 4. ログで結果を確認
+ *
+ * 処理内容:
+ * - Sessionsシート: ヘッダー + サンプルデータ1行
+ * - Questionsシート: ヘッダー（category列含む） + サンプルデータ1行
+ * - Knowledge_Baseシート: ヘッダー（category列含む） + サンプルデータ1行
+ *
+ * 安全機能:
+ * - シートが既にデータを持つ場合はスキップ
+ * - エラーハンドリング
+ * - 詳細ログ出力
+ */
+function initializeEmptySheets() {
+  try {
+    Logger.log('=== 空シート初期化開始 ===');
+
+    // スプレッドシート取得（Code.jsで定義されたSPREADSHEET_IDを使用）
+    var spreadsheet = SpreadsheetApp.openById(SPREADSHEET_ID);
+    Logger.log('スプレッドシート取得成功: ' + spreadsheet.getName());
+
+    // 各シートの初期化
+    Logger.log('\n--- シート初期化処理 ---');
+    initializeSessionsSheet(spreadsheet);
+    initializeQuestionsSheet(spreadsheet);
+    initializeKnowledgeBaseSheet(spreadsheet);
+
+    Logger.log('\n=== 空シート初期化完了！ ===');
+    Logger.log('結果: 3シート（Sessions, Questions, Knowledge_Base）の初期化が完了しました');
+    Logger.log('次のステップ: Google Sheetsを開いて各シートにヘッダーとサンプルデータが存在することを確認してください');
+
+  } catch (error) {
+    Logger.log('\n❌ エラー発生: ' + error.message);
+    Logger.log('スタックトレース: ' + error.stack);
+    throw error;
+  }
+}
+
+/**
+ * Sessionsシート初期化
+ */
+function initializeSessionsSheet(spreadsheet) {
+  var sheetName = 'Sessions';
+
+  Logger.log(sheetName + 'シートを確認中...');
+
+  // シート取得
+  var sheet = spreadsheet.getSheetByName(sheetName);
+  if (!sheet) {
+    Logger.log('⚠️ ' + sheetName + 'シートが存在しません。スキップします。');
+    return;
+  }
+
+  // 既存データ確認（空シートかどうか）
+  var lastRow = sheet.getLastRow();
+  if (lastRow > 0) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既にデータを持っています（' + lastRow + '行）。スキップします。');
+    return;
+  }
+
+  Logger.log(sheetName + 'シートを初期化中...');
+
+  // ヘッダー行（1行目）
+  var headers = [
+    'session_id',
+    'user_id',
+    'subjects',
+    'start_time',
+    'end_time',
+    'total_score',
+    'completed'
+  ];
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+
+  // サンプルデータ（1行）
+  var sampleData = [
+    ['session-sample-001', 'sample-user-001', '["国語","算数"]', '2025-11-04T10:30:00Z', '2025-11-04T10:45:00Z', 29, true]
+  ];
+  sheet.getRange(2, 1, sampleData.length, headers.length).setValues(sampleData);
+
+  Logger.log('✅ ' + sheetName + 'シート初期化完了（ヘッダー + サンプルデータ1行）');
+}
+
+/**
+ * Questionsシート初期化（category列含む）
+ */
+function initializeQuestionsSheet(spreadsheet) {
+  var sheetName = 'Questions';
+
+  Logger.log(sheetName + 'シートを確認中...');
+
+  // シート取得
+  var sheet = spreadsheet.getSheetByName(sheetName);
+  if (!sheet) {
+    Logger.log('⚠️ ' + sheetName + 'シートが存在しません。スキップします。');
+    return;
+  }
+
+  // 既存データ確認（空シートかどうか）
+  var lastRow = sheet.getLastRow();
+  if (lastRow > 0) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既にデータを持っています（' + lastRow + '行）。スキップします。');
+    return;
+  }
+
+  Logger.log(sheetName + 'シートを初期化中...');
+
+  // ヘッダー行（1行目）- category列を含む
+  var headers = [
+    'question_id',
+    'session_id',
+    'subject',
+    'category',
+    'difficulty',
+    'question_text',
+    'choices',
+    'correct_answer',
+    'explanation',
+    'created_at'
+  ];
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+
+  // サンプルデータ（1行）
+  var sampleData = [
+    [
+      'q-sample-001',
+      'session-sample-001',
+      '国語',
+      '漢字・語彙',
+      '標準',
+      '次の漢字の読みを選びなさい：「成就」',
+      '["じょうじゅ","せいしゅう","せいじゅ","じょうしゅう"]',
+      0,
+      '「成就」は「じょうじゅ」と読みます。',
+      '2025-11-04T10:31:00Z'
+    ]
+  ];
+  sheet.getRange(2, 1, sampleData.length, headers.length).setValues(sampleData);
+
+  Logger.log('✅ ' + sheetName + 'シート初期化完了（ヘッダー（category列含む） + サンプルデータ1行）');
+}
+
+/**
+ * Knowledge_Baseシート初期化（category列含む）
+ */
+function initializeKnowledgeBaseSheet(spreadsheet) {
+  var sheetName = 'Knowledge_Base';
+
+  Logger.log(sheetName + 'シートを確認中...');
+
+  // シート取得
+  var sheet = spreadsheet.getSheetByName(sheetName);
+  if (!sheet) {
+    Logger.log('⚠️ ' + sheetName + 'シートが存在しません。スキップします。');
+    return;
+  }
+
+  // 既存データ確認（空シートかどうか）
+  var lastRow = sheet.getLastRow();
+  if (lastRow > 0) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既にデータを持っています（' + lastRow + '行）。スキップします。');
+    return;
+  }
+
+  Logger.log(sheetName + 'シートを初期化中...');
+
+  // ヘッダー行（1行目）- category列を含む
+  var headers = [
+    'kb_id',
+    'subject',
+    'category',
+    'grade',
+    'content',
+    'difficulty',
+    'usage_count',
+    'last_used'
+  ];
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+
+  // サンプルデータ（1行）
+  var sampleData = [
+    [
+      'kb-sample-001',
+      '理科',
+      '植物の成長',
+      5,
+      '種子が発芽するためには、水・空気・適切な温度が必要である。',
+      2,
+      5,
+      '2025-11-04T09:00:00Z'
+    ]
+  ];
+  sheet.getRange(2, 1, sampleData.length, headers.length).setValues(sampleData);
+
+  Logger.log('✅ ' + sheetName + 'シート初期化完了（ヘッダー（category列含む） + サンプルデータ1行）');
+}
+
+/**
+ * テスト関数: setupSheetsV2の動作確認
+ */
+function testSetupSheetsV2() {
+  Logger.log('=== テスト実行: setupSheetsV2 ===');
+  setupSheetsV2();
+  Logger.log('=== テスト完了 ===');
+}
+
+/**
+ * テスト関数: initializeEmptySheetsの動作確認
+ */
+function testInitializeEmptySheets() {
+  Logger.log('=== テスト実行: initializeEmptySheets ===');
+  initializeEmptySheets();
+  Logger.log('=== テスト完了 ===');
+}

V1.7.1/gas/setup_sheets_v3.js

@@ -0,0 +1,401 @@
+/**
+ * 超天才クイズv3 シートリセット・初期化スクリプト v3
+ *
+ * v1.6.8用: 現行Code.jsのスキーマに合わせたシート初期化
+ *
+ * 実行方法:
+ * 1. Apps Scriptエディタで本ファイルを開く
+ * 2. 実行したい関数を選択
+ * 3. 実行ボタンをクリック
+ *
+ * 提供関数:
+ * - deleteAllSheetsExceptQuestionDB(): QuestionDatabase以外のシートを削除
+ * - initializeAllSheets(): 現行スキーマで全シートを初期化
+ * - resetAndInitialize(): 削除 + 初期化を一括実行
+ *
+ * @version 3.0
+ * @date 2025-12-20
+ */
+
+// Note: SPREADSHEET_IDはCode.jsで定義済み
+
+/**
+ * QuestionDatabase以外の全シートを削除
+ *
+ * 注意: この操作は取り消せません！
+ * QuestionDatabaseシートは保護されます。
+ */
+function deleteAllSheetsExceptQuestionDB() {
+  try {
+    Logger.log('=== シート削除開始（QuestionDatabase以外） ===');
+
+    const spreadsheet = SpreadsheetApp.openById(SPREADSHEET_ID);
+    const sheets = spreadsheet.getSheets();
+
+    Logger.log('現在のシート数: ' + sheets.length);
+
+    // 保護するシート
+    const protectedSheets = ['QuestionDatabase'];
+
+    // 削除対象シートを収集
+    const sheetsToDelete = [];
+    for (let i = 0; i < sheets.length; i++) {
+      const sheetName = sheets[i].getName();
+      if (!protectedSheets.includes(sheetName)) {
+        sheetsToDelete.push(sheetName);
+      } else {
+        Logger.log('✅ 保護: ' + sheetName);
+      }
+    }
+
+    // シート削除（最低1シートは残す必要があるため、仮シートを作成）
+    if (sheetsToDelete.length === sheets.length) {
+      // 全シート削除しようとしている場合、一時シートを作成
+      spreadsheet.insertSheet('_temp_');
+      Logger.log('一時シート作成（全削除防止）');
+    }
+
+    // 削除実行
+    for (let i = 0; i < sheetsToDelete.length; i++) {
+      const sheetName = sheetsToDelete[i];
+      const sheet = spreadsheet.getSheetByName(sheetName);
+      if (sheet) {
+        spreadsheet.deleteSheet(sheet);
+        Logger.log('❌ 削除: ' + sheetName);
+      }
+    }
+
+    Logger.log('\n=== シート削除完了 ===');
+    Logger.log('削除したシート: ' + sheetsToDelete.join(', '));
+    Logger.log('残りのシート数: ' + spreadsheet.getSheets().length);
+
+    return { success: true, deleted: sheetsToDelete };
+
+  } catch (error) {
+    Logger.log('\n❌ エラー発生: ' + error.message);
+    throw error;
+  }
+}
+
+/**
+ * 現行スキーマで全シートを初期化
+ *
+ * Code.jsのSHEET_NAMESとgetOrCreateSheet()の定義に基づく
+ */
+function initializeAllSheets() {
+  try {
+    Logger.log('=== シート初期化開始（v3スキーマ） ===');
+
+    const spreadsheet = SpreadsheetApp.openById(SPREADSHEET_ID);
+
+    // 一時シートがあれば後で削除
+    const tempSheet = spreadsheet.getSheetByName('_temp_');
+
+    // 各シートを初期化
+    initializeUsersSheet(spreadsheet);
+    initializeSessionsSheet(spreadsheet);
+    initializeAnswersSheet(spreadsheet);
+    initializeStatisticsSheet(spreadsheet);
+    initializeEvaluationsSheet(spreadsheet);
+    initializeGeneratedQuestionsSheet(spreadsheet);
+    initializeSummariesSheet(spreadsheet);
+
+    // 一時シートを削除
+    if (tempSheet) {
+      spreadsheet.deleteSheet(tempSheet);
+      Logger.log('一時シート削除');
+    }
+
+    Logger.log('\n=== シート初期化完了 ===');
+    Logger.log('次のステップ: Google Sheetsを開いて各シートのヘッダーを確認してください');
+
+    return { success: true };
+
+  } catch (error) {
+    Logger.log('\n❌ エラー発生: ' + error.message);
+    throw error;
+  }
+}
+
+/**
+ * シート削除 + 初期化を一括実行
+ */
+function resetAndInitialize() {
+  Logger.log('========================================');
+  Logger.log('シートリセット＆初期化 開始');
+  Logger.log('========================================\n');
+
+  deleteAllSheetsExceptQuestionDB();
+
+  Logger.log('\n');
+
+  initializeAllSheets();
+
+  Logger.log('\n========================================');
+  Logger.log('シートリセット＆初期化 完了！');
+  Logger.log('========================================');
+}
+
+// ============================================================================
+// 個別シート初期化関数
+// ============================================================================
+
+/**
+ * Usersシート初期化
+ * スキーマ: user_id, username, created_at, total_sessions, total_questions
+ */
+function initializeUsersSheet(spreadsheet) {
+  const sheetName = 'Users';
+  Logger.log(sheetName + 'シートを初期化中...');
+
+  let sheet = spreadsheet.getSheetByName(sheetName);
+  if (sheet) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既に存在します。スキップします。');
+    return;
+  }
+
+  sheet = spreadsheet.insertSheet(sheetName);
+
+  const headers = [
+    'user_id',
+    'username',
+    'created_at',
+    'total_sessions',
+    'total_questions'
+  ];
+
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+  sheet.getRange(1, 1, 1, headers.length).setFontWeight('bold');
+
+  Logger.log('✅ ' + sheetName + 'シート初期化完了');
+}
+
+/**
+ * Sessionsシート初期化
+ * スキーマ: session_id, user_id, subjects, start_time, end_time, total_score, completed
+ */
+function initializeSessionsSheet(spreadsheet) {
+  const sheetName = 'Sessions';
+  Logger.log(sheetName + 'シートを初期化中...');
+
+  let sheet = spreadsheet.getSheetByName(sheetName);
+  if (sheet) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既に存在します。スキップします。');
+    return;
+  }
+
+  sheet = spreadsheet.insertSheet(sheetName);
+
+  const headers = [
+    'session_id',
+    'user_id',
+    'subjects',
+    'start_time',
+    'end_time',
+    'total_score',
+    'completed'
+  ];
+
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+  sheet.getRange(1, 1, 1, headers.length).setFontWeight('bold');
+
+  Logger.log('✅ ' + sheetName + 'シート初期化完了');
+}
+
+/**
+ * Answersシート初期化
+ * スキーマ: answer_id, session_id, question_id, subject, category, user_answer, correct_answer, is_correct, time_spent, submitted_at
+ *
+ * ★重要: v1.6.6で修正されたスキーマ（10列）
+ */
+function initializeAnswersSheet(spreadsheet) {
+  const sheetName = 'Answers';
+  Logger.log(sheetName + 'シートを初期化中...');
+
+  let sheet = spreadsheet.getSheetByName(sheetName);
+  if (sheet) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既に存在します。スキップします。');
+    return;
+  }
+
+  sheet = spreadsheet.insertSheet(sheetName);
+
+  // v1.6.6で修正されたスキーマ（10列）
+  const headers = [
+    'answer_id',      // A
+    'session_id',     // B
+    'question_id',    // C
+    'subject',        // D
+    'category',       // E
+    'user_answer',    // F
+    'correct_answer', // G ★追加
+    'is_correct',     // H
+    'time_spent',     // I
+    'submitted_at'    // J
+  ];
+
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+  sheet.getRange(1, 1, 1, headers.length).setFontWeight('bold');
+
+  Logger.log('✅ ' + sheetName + 'シート初期化完了（10列スキーマ）');
+}
+
+/**
+ * Statisticsシート初期化
+ * スキーマ: stat_id, user_id, subject, category, total_attempted, correct_count, accuracy_rate, last_updated
+ */
+function initializeStatisticsSheet(spreadsheet) {
+  const sheetName = 'Statistics';
+  Logger.log(sheetName + 'シートを初期化中...');
+
+  let sheet = spreadsheet.getSheetByName(sheetName);
+  if (sheet) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既に存在します。スキップします。');
+    return;
+  }
+
+  sheet = spreadsheet.insertSheet(sheetName);
+
+  const headers = [
+    'stat_id',
+    'user_id',
+    'subject',
+    'category',
+    'total_attempted',
+    'correct_count',
+    'accuracy_rate',
+    'last_updated'
+  ];
+
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+  sheet.getRange(1, 1, 1, headers.length).setFontWeight('bold');
+
+  Logger.log('✅ ' + sheetName + 'シート初期化完了');
+}
+
+/**
+ * Evaluationsシート初期化
+ * スキーマ: evaluation_id, session_id, subject, advice, strengths, weaknesses, recommended_topics, created_at
+ */
+function initializeEvaluationsSheet(spreadsheet) {
+  const sheetName = 'Evaluations';
+  Logger.log(sheetName + 'シートを初期化中...');
+
+  let sheet = spreadsheet.getSheetByName(sheetName);
+  if (sheet) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既に存在します。スキップします。');
+    return;
+  }
+
+  sheet = spreadsheet.insertSheet(sheetName);
+
+  const headers = [
+    'evaluation_id',
+    'session_id',
+    'subject',
+    'advice',
+    'strengths',
+    'weaknesses',
+    'recommended_topics',
+    'created_at'
+  ];
+
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+  sheet.getRange(1, 1, 1, headers.length).setFontWeight('bold');
+
+  Logger.log('✅ ' + sheetName + 'シート初期化完了');
+}
+
+/**
+ * GeneratedQuestionsシート初期化
+ * スキーマ: question_id, session_id, subject, genre_id, answer, question_text, choices, correct_answer, difficulty, created_at
+ */
+function initializeGeneratedQuestionsSheet(spreadsheet) {
+  const sheetName = 'GeneratedQuestions';
+  Logger.log(sheetName + 'シートを初期化中...');
+
+  let sheet = spreadsheet.getSheetByName(sheetName);
+  if (sheet) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既に存在します。スキップします。');
+    return;
+  }
+
+  sheet = spreadsheet.insertSheet(sheetName);
+
+  const headers = [
+    'question_id',
+    'session_id',
+    'subject',
+    'genre_id',
+    'answer',
+    'question_text',
+    'choices',
+    'correct_answer',
+    'difficulty',
+    'created_at'
+  ];
+
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+  sheet.getRange(1, 1, 1, headers.length).setFontWeight('bold');
+
+  Logger.log('✅ ' + sheetName + 'シート初期化完了');
+}
+
+/**
+ * Summariesシート初期化
+ * スキーマ: summary_id, session_id, subject, keywords, topics, summary, created_at
+ */
+function initializeSummariesSheet(spreadsheet) {
+  const sheetName = 'Summaries';
+  Logger.log(sheetName + 'シートを初期化中...');
+
+  let sheet = spreadsheet.getSheetByName(sheetName);
+  if (sheet) {
+    Logger.log('⚠️ ' + sheetName + 'シートは既に存在します。スキップします。');
+    return;
+  }
+
+  sheet = spreadsheet.insertSheet(sheetName);
+
+  const headers = [
+    'summary_id',
+    'session_id',
+    'subject',
+    'keywords',
+    'topics',
+    'summary',
+    'created_at'
+  ];
+
+  sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+  sheet.getRange(1, 1, 1, headers.length).setFontWeight('bold');
+
+  Logger.log('✅ ' + sheetName + 'シート初期化完了');
+}
+
+// ============================================================================
+// テスト関数
+// ============================================================================
+
+/**
+ * シート一覧を表示（デバッグ用）
+ */
+function listAllSheets() {
+  const spreadsheet = SpreadsheetApp.openById(SPREADSHEET_ID);
+  const sheets = spreadsheet.getSheets();
+
+  Logger.log('=== シート一覧 ===');
+  for (let i = 0; i < sheets.length; i++) {
+    const sheet = sheets[i];
+    const lastRow = sheet.getLastRow();
+    const lastCol = sheet.getLastColumn();
+    Logger.log((i + 1) + '. ' + sheet.getName() + ' (' + lastRow + '行 x ' + lastCol + '列)');
+
+    // ヘッダー行を表示
+    if (lastCol > 0) {
+      const headers = sheet.getRange(1, 1, 1, lastCol).getValues()[0];
+      Logger.log('   ヘッダー: ' + headers.join(', '));
+    }
+  }
+  Logger.log('=== 合計: ' + sheets.length + 'シート ===');
+}

V1.7.1/knowledge/ORIGINAL/算数/つまずきやすいところが絶対つまずかない! 小学校6年間の図形の教え方.md

@@ -0,0 +1,832 @@
+# 図形の教え方（小学校6年間）
+
+[CHUNK]
+## 図形学習のつまずき解消と本書の目的
+本書は、小学校算数における図形問題でつまずきやすい子どもたちに向けて、苦手意識を克服し、図形問題の解き方を習得できるよう構成されている。プロ家庭教師の経験に基づき、図形問題が苦手な子どもの特徴を分析し、克服のための具体的なアプローチを提示する。図形問題はセンスや才能ではなく、正しい方法と訓練で誰でも解けるようになることを強調する。
+
+[CHUNK]
+## 図形問題克服の重要性と身体感覚の活用
+センスや才能に頼らず、図形問題は正しいアプローチと訓練で克服可能である。特に、道具の正しい使い方や、図形をかく、折る、切る、ひっくり返すといった身体感覚が重要となる。低学年のうちにこれらの経験を積むことが望ましい。経験を言葉で表現することで、知識として定着を促す。
+
+[CHUNK]
+## 身の回りの形を通じた学習と本書の活用
+身の回りの形を通して、お子さんと楽しくコミュニケーションをとることが重要。「折り紙をななめに折ったら三角形になったね」「きゅうりをまっすぐ切ったら、切り口はぜんぶ丸だね」などの声かけが効果的。高学年でも遅すぎることはなく、中学、高校の数学につながる。本書は教科書の応用問題が解けるようになることを目標に、図形問題に強くなるヒントを提供する。
+
+[CHUNK]
+## 本書を通じた親子の成長と良好な関係構築
+本書を通して、親御さんがお子さんとともに、問題が解ける喜びや達成感を味わい、親子の良好な関係が育まれることを願っている。教科書の応用問題が解けるようになることを目標に、図形問題に強くなるヒントを随所にちりばめた。ぜひ、参考にしてください。
+
+# 小学校6年間の図形の教え方
+
+[CHUNK]
+## 図形学習の導入と苦手意識克服
+図形問題が苦手な子どもは多い。図形問題を解く力は、身の回りの図形を実際に見て、触って、手を動かす経験で伸ばせる。行き詰まったら、問題から離れ、日常生活で図形に親しむ機会を増やそう。
+図形が得意な子は、つみきや折り紙が好きで、身の回りにある形に気づきやすい。苦手な子は、図形と自分との関わりを感じにくく、面積の公式などを暗記に頼りがちである。
+
+[CHUNK]
+## 図形学習における親の役割と教え方のコツ
+図形を教える際は、子どもの中から答えを引き出すことを重視する。自分で答えが出せた経験は自信につながり、解き方の手順も身につく。どんな小さなことでも褒めて、子どものやる気を引き出す。
+結論を一方的に説明するのではなく、「〇〇の公式は覚えてる？」「□□って何だっけ？」と優しく問いかけながら、一緒に考える姿勢が大切。コミュニケーションを取りながら進めることで、図形学習を楽しいものにし、苦手意識を克服する。
+
+[CHUNK]
+## 日常生活での図形との触れ合い方
+身の回りにあるものの形を探す（例：将棋の駒は五角形、傘は八角形）。トランプのマークが線対称であることを見つけるなど、遊びの中で図形の性質に触れる。
+自分の体を使って角度を作る（例：座って足を何度まで開けるか）。料理の手伝いを通して、かさの感覚を養う（例：鍋に1Lの水を入れてくれる？）。本書p.14の「お助けアイテム」も参考に。
+公式や手順を丸暗記するのではなく、「なぜそうなるのか」の背景を理解することが重要。感動したことや自分で気づいたことは忘れずに、応用問題にも生かせるようにする。
+
+[CHUNK]
+## 作図が苦手な子へのアプローチ
+作図ができるようになると図形全般の理解度が高まる。まずは身近な道具や身の回りのものを使って、手を動かすことから始める。
+対称な図形の感覚を養うには、折り紙を折って切って広げるのが効果的。好きな形を簡単につくれる点、ひっくり返したり裏返したりと図形を実際に動かせる点も優れている。頭の中で図形を動かして考える練習になる。
+
+[CHUNK]
+## 作図練習のステップ
+直線を引く練習：定規は目盛りのない面を上にし、利き手と反対の手でしっかり押さえる。定規が動かないように、5～10本、30cmくらいの線を引く。
+コンパス選び：針がしっかり刺さるものを選ぶ。コンパスを使えばきれいな円が自分でかけるという経験は、自信に��ながる。
+図形をなぞってかく：問題集などに載っている図を上からなぞらせる。三角形や四角形、円から始め、複合図形や立体の見取り図など、複雑な図を何度もなぞって自分のものにする。慣れてきたら、図を見ながらノートにかく練習もする。
+
+[CHUNK]
+## 親御さんの不安解消と図形学習サポート
+「図形が苦手」「算数が苦手」「応用問題が苦手」という親御さんも大丈夫。本書には、親子で図形に親しみ、図形の問題が得意になるヒントが多数ある。
+本書には、多くの子どもが納得できる解説が書かれているため、親御さんもすんなり理解できる。難しく感じる場合は、前の学年にもどって、基本から1つずつ理解していくとよい。
+
+[CHUNK]
+## 図形問題克服のためのアイテム
+図形を身近に感じ、問題をすらすら解けるようにする道具を紹介。勉強のときだけでなく、ふだんの生活や遊びの中に取り入れる。
+定規・メジャー：長さの単位に慣れる。子どもの身長、手の大きさ、指の長さなどを測る。
+三角定規：平行や垂直な線を引く。直角三角形の典型的な見本として覚えておく。
+分度器：角度を測る。家の中のいろいろなものを測ってみる。
+
+[CHUNK]
+## 図形学習をサポートするアイテム（続き）
+コンパス：円をかく。作図のときにも頻繁に使用。円をたくさんかいてコンパスの扱いに慣れる。
+計量カップ・計量スプーン：かさや重さの単位を実感。1Lのペットボトルに水を入れて、1kgの重さを体感させる。
+折り紙：折ったり、切ったり、楽しみながら図形の性質を身につける。三角形、四角形、角度、対称な図形など、活用方法は無限。
+空き箱：立体の感覚をつかむ。ティッシュペーパーの空き箱は、開いて展開図にできるなど活用しやすい。
+方眼用紙：正確な図形の感覚を身につけるために便利。5mm方眼がおすすめだが、ノートのマス目を利用してもOK。
+
+[CHUNK]
+## 単位の理解：視覚的アプローチの重要性
+単位は、「何倍の関係か」を視覚的に身につけることが重要。
+牛乳パックはサイコロ1000個分：1辺の長さ1cm (1cm³=1mL) の市販のサイコロを1個用意し、1000個集めると牛乳パック1個の大きさ(1000cm³)になることを視覚的に理解させる。計量カップ (200mL)で、空の牛乳パックに水を入れ、5杯でいっぱいになることを確認するのも効果的。
+
+[CHUNK]
+## 水の体積と重さの関係を体感する
+水の体積と重さの関係を実感させる：計量カップをのせた状態で0gに合わせたはかりを使って、水の重さを実際に確かめる。
+100mL (100cm³) の水の重さが100gということが確認できたら、「実は重さの単位は水の重さを基準に決められているんだって」と声かけを。理科の勉強にも役立つ、とても大切な感覚が身につく。
+単位の変換をするときは、0がいくつ増える・減る関係か、イメージがわくようになるとよい。
+
+[CHUNK]
+## 単位換算の注意点と練習問題
+単位換算では、かくれた「0」を見逃さないように注意する。
+例：1L50mL = (1050)mL。上下にケタをそろえて筆算を書くように伝え、かくれた100の位の「0」を見せて意識させる。方眼ノートを使ってみるのも効果的。
+単位の変換をするときは、0がいくつ増える・減る関係か、イメージがわくようになるとよい。
+
+# 小学校算数つまずきポイント解決ナレッジベース
+
+[CHUNK]
+## 2年生: くり下がりのある単位の計算 (cm, mm)
+2年生でつまずきやすい、くり下がりのある単位の計算（例：3cm2mm - 1cm7mm）について解説します。前提として、1m=100cm、1cm=10mmといった基本的な単位の知識が定着している必要があります。本質的な理解のため、最初はmmに変換して計算し、慣れてきたらcmとmmのまま計算する方法を練習します。mmに直して計算する際は、3cm2mmを32mm、1cm7mmを17mmに変換し、32mm - 17mm = 15mm = 1cm5mmと計算します。cmとmmのまま筆算する場合は、位を揃えて書き、1cmを10mmとして繰り下げて計算します。
+
+[CHUNK]
+## 2年生: くり下がりのある単位の計算練習と指導のポイント
+cmとmmのまま筆算する場合は、位を揃えて書き、1cmを10mmとして繰り下げて計算します。単位換算の練習として、「3cmは何mm？」「3cm2mmは何mm？」といった質問を投げかけ、基本的な単位間の関係を理解させることが重要です。いきなり「3cm2mmは何mm？」と聞くのではなく、「1cmは���mm？」「1mは何cm？」「1kgは何g？」といった基本的な単位間の関係を声かけしながら練習することがポイントです。練習問題として、5cm4mm-3cm6mm、1m45cm-77cm、2kg300g-1kg600g、5L3dL-3L7dL、3m7cm-89cmなどが考えられます。
+
+[CHUNK]
+## 2年生: 間に0が入る単位の変換 (m, cm)
+2年生でつまずきやすい、間に0が入る単位の変換（例：3m7cm = cm）について解説します。長さ、かさ、重さの単位の変換が定着していないと、見たままの数字で答えてしまうことがあります。1m=100cmということがしっかり定着していないと、省略されている0に気づけず「3m7cm=37cm」といったミスをしてしまいます。3m7cm = 37cm ?という誤答に対して、3と7の間の0に気づいていないことを指摘します。
+
+[CHUNK]
+## 2年生: 単位変換の指導と練習問題
+3m7cm = 37cm ?という誤答に対して、3と7の間の0に気づいていないことを指摘します。「3mは何cm？」の声かけとケタをそろえた書き方を習慣づけることで、あわててミスすることがなくなります。3m = 300cm、7cmをたてにそろえて書く練習をします。方眼ノートを使うと、そろえて書きやすいでしょう。「3mは300cm」と書いて、「7cm」も書いて、目で見て確認します。その中で「ケタをそろえる」を習慣にするのが最大のポイントです。練習問題として、4m8cm=( )cm、12m5cm=( )cm、4L80mL=( )mL、105cm=( )m( )cm、3075mL =( )L( )mLなどが考えられます。
+
+[CHUNK]
+## 6年生: 水のかさ、重さ、体積の変換 (L, mL, cm³)
+6年生でつまずきやすい、水のかさ、重さ、体積の変換（例：水1L500mLの重さ）について解説します。ものの重さは水を基準に決まっていて、水1mLの重さを1gとしています。つまり体積の単位を正しく知っておくことで、水の重さがわかるようになります。cm³とL(リットル)、dL(デシリットル)、mL(ミリリットル) の関係がわかっていないと、まちがえてしまいます。1L500mLの重さは何gか？という問題に対して、1Lは何mLだったっけ？という疑問が生じます。
+
+[CHUNK]
+## 6年生: 体積と重さの関係理解と練習問題
+1L500mLの重さは何gか？という問題に対して、1Lは何mLだったっけ？という疑問が生じます。1cm³と1mLは同じ量です。そして1Lは1000mL (1000cm³)です。だから1L500mLは1500 cm³ (mL) となることを確認します。体積と重さの変換を、くり返し質問することが重要です。かさから体積、重さから体積、体積から重さと何度もくり返し質問して、答えてもらうようにしましょう。1Lのペットボトルに水を入れて、量と重さを確認するのもよいでしょう。水1cm³ = 1g、1000cm³ = 1000g、1L = 1kgという関係を理解させます。「重さの単位は水を基準に決められている」と伝えると、多くの子どもが「へ~そうなんだ!」とおどろきます。そんなおどろきが、忘れない記憶のもとになります。練習問題として、次の量の水の重さは何gですか。980mL、2L400mL、1200 cm³、1L3dL、2.5Lなどが出題できます。
+
+[CHUNK]
+## 図形の性質: 分度器と角度の理解
+図形の性質の理解におけるつまずきを解消します。分度器の性質、使い方、「1周の角=360°」を理解することが重要です。まずは「かいてみて確かめる」ことを習慣にしましょう。例として、正方形の対称の軸はいくつありますか？という問題を通して、図形を実際に描いてみることで理解を深めます。対称の軸とは、1つの図形を2つの同じ形に分ける線のことですが、まずは「かいてみてごらん」という声かけを。そしてさらに声かけで正しい考え方、気づきに導いてあげましょう。
+
+[CHUNK]
+## 図形の性質: 角度の測定と練習問題
+正方形の対称の軸を求める問題を通して、図形を実際に描いてみることで理解を深めます。「ちょっとかいてみてごらん」といった声かけをすることで、子どもたちは自ら考え、試行錯誤することができます。正五角形・正六角形の対称の軸を全部かいてみましょう。角度の問題では、「平行線→同じ大きさの角ができる」ということをおさえておきましょう。また、拡大図・縮図では、「1つの点(線)を固定してかく」ことが、作図のポイントです。角度の大きさの概算を問う問題を通して、角度の感覚を養います。
+
+[CHUNK]
+## 4年生: 直角より大きな角の理解
+4年生でつまずきやすい、直角より大きな角（鈍角）の理解について解説します。例として、鈍角の角度を求める、水���より大きな角度を求める問題を取り上げます。「角」というのは、とがっているもの、開き方がせまいものだけではありません。90°(直角)や180°(水平)をこえる角もあることがつかめるようにしましょう。90°をこえる角を「角」と考えられない場合、鈍角(90°より大きく開いた角)を角として考えられず、どう測ったらよいかがわからないことがあります。
+
+[CHUNK]
+## 4年生: 鈍角の測定と指導のポイント
+90°をこえる角を「角」と考えられない場合、鈍角(90°より大きく開いた角)を角として考えられず、どう測ったらよいかがわからないことがあります。「とがっていなくても角だよ」と声かけをすることが重要です。とがっているものだけが角ではないことを伝えます。分度器をあてて、90°より大きい角も分度器で測れること (180°まで測れること)を、確認しましょう。180°より大きい角が測れない場合、「1周360°」 という感覚が身についていないと、大きさの測り方がわかりません。分度器よりも大きな角の測り方がわからない場合は、「ぐるんと1周で360°なんだよ」と声かけをしてあげましょう。小さいほうの角を測るということに自分で気づけるとよいですね。練習問題として、様々な角度の角の大きさを分度器で測る問題に取り組みましょう。
+
+# 図形問題最適化ナレッジベース
+        
+[CHUNK]
+## 角度計算の基本と交差する直線
+角度計算の基本は、交わる直線や平行線における角の性質理解にある。一つの角の大きさがわかれば、分度器を使わずに他の角も計算可能。隣り合う角や対応する角の関係性を把握することが重要。見た目だけで判断せず、理屈に基づいた考え方を養う。角度を測る際は分度器を使用し、54°の角と隣接する角の合計が180°になることを確認する。
+        
+[CHUNK]
+## 交差する直線における角度の求め方
+54°の角と隣接する角の合計が180°になることを確認する。180°から54°を引いて隣接する角が126°であることを導く。対頂角は等しいという性質を利用し、向かい合う角も54°であることを確認する。平行線においては、他の直線と同じ角度で交わるため、離れた場所でも同じ大きさの角を見つけられる。
+        
+[CHUNK]
+## 平行線と角度の関係
+平行線においては、他の直線と同じ角度で交わるため、離れた場所でも同じ大きさの角を見つけられる。角度を求める際は、既知の角から順に全ての角を求めることで混乱を防ぐ。分度器を用いて実際に角度を測り、合わせて180°になる角を確認する。平行線が他の直線と交わる際にできる角の関係性を理解する。
+        
+[CHUNK]
+## 平行線と角度の関係の応用
+平行線が他の直線と交わる際にできる角の関係性を理解することで、未知の角を求める。例えば、110°の角がある場合、その隣の角は180° - 110° = 70°となる。平行線の性質から、対応する角も70°となるため、さらに隣の角は180° - 70° = 110°と計算できる。
+        
+[CHUNK]
+## 平行と垂直な直線の作図
+平行な直線や垂直な直線を作図する際、三角定規を適切に使用することが重要。特に、斜めになっている直線に対して作図を行う場合、三角定規の使い方が理解度を左右する。目分量で線を引くのではなく、三角定規を用いて正確に作図する習慣を身につける。平行線や垂直線を作図する際は、2つの三角定規を使用する。
+        
+[CHUNK]
+## 三角定規を用いた平行線作図
+平行線を作図する際は、三角定規の直角部分を基準となる直線に合わせ、もう一枚の三角定規を添える。その後、基準となる三角定規を固定したまま、もう一枚の三角定規をスライドさせることで平行線を作図する。三角定規の直角部分を上手に活用することで、平行な直線を簡単に引けることを体験させる。
+        
+[CHUNK]
+## 三角定規を用いた垂直線作図
+三角定規の直角部分を基準となる直線に合わせ、もう一枚の三角定規を直角に添えることで垂直線を作図する。三角定規を繰り返し練習することで、作図スキルを向上させる。平行線と垂直線の見分け方では、「見た目」だけで判断せず、三角定規を用いて実際に角度を測り、垂直であるかを確認する。
+        
+[CHUNK]
+## 平行・垂直な直線の見分け方
+平行・垂直な直線の見分け方では、「見た目」だけで判断せず、三角定規を用いて実���に角度を測り、垂直であるかを確認する。方眼を利用して直線の傾きを確認し、平行であるかを判断する。例えば、直線が右に1マス、下に2マス傾いている場合、別の直線も同じ傾きであれば平行である。
+        
+[CHUNK]
+## 方眼を用いた平行の確認
+直線が右に1マス、下に2マス傾いている場合、別の直線も同じ傾きであれば平行である。平行な直線を見つける際は、方眼のマス目を数えて傾きを比較する。垂直な直線を見つける際は、三角定規を当てて直角になっているか確認する。
+        
+[CHUNK]
+## 拡大図・縮図の基本
+拡大図・縮図は、元の図形と同じ形で、すべての辺の長さを一定の割合で拡大または縮小した図形。作図の際には、まず一つの頂点を固定し、そこから各頂点への距離を拡大または縮小する。拡大図や縮図を作成する際、どの頂点を固定するかを最初に決めることが重要。
+        
+[CHUNK]
+## 拡大図・縮図の作図手順
+拡大図や縮図を作成する際、どの頂点を固定するかを最初に決めることが重要。左下の頂点を固定し、他の頂点までの距離を測り、指定された倍率で拡大または縮小する。コンパスを用いて各頂点の位置を決定し、最後に各頂点を線で結ぶ。拡大図や縮図は、元の図形と形が同じであることが重要。
+        
+[CHUNK]
+## 拡大図・縮図における辺と角の関係
+拡大図・縮図では、対応する角の大きさは常に等しい。辺の長さは拡大率または縮小率に応じて変化するが、図形の形状は変わらない。拡大図・縮図の問題を解く際には、元の図形と拡大・縮小された図形が「全く同じ形」であることを意識する。
+        
+[CHUNK]
+## 拡大図・縮図の応用問題
+拡大図・縮図の問題では、辺の長さだけでなく、角の大きさも問われる。例えば、三角形ABCの縮図である三角形DEFにおいて、辺DEの長さが与えられた場合、対応する辺ABの長さを求める。角Eの大きさは、対応する角Bの大きさと等しくなる。
+
+# 小学校6年間の図形の教え方
+
+[CHUNK]
+## 線対称・点対称な図形の理解と作図のポイント
+小学校6年生で学ぶ線対称・点対称な図形について、特に点対称な図形が苦手な児童が多い。点対称とは何かを丁寧に説明し、理解を深める必要がある。線対称な図形は比較的容易に作図できる。点対称な図形を作図する際には、対応する点を正確にとらえることが重要となる。線対称では、対称の軸に対して同じ長さになっているかを意識することが重要。
+
+[CHUNK]
+## 点対称図形の作図: 対応点の特定と線での連結
+線対称な図形は正しくかける子が多いのですが、点対称な図形になると、かけない子がグッと増えます。点対称がどういうことかをしっかり説明してあげましょう。点対称図形を作図する際は、対応する点を一つ一つ丁寧に見つけ、線で結ぶことが重要。各点に記号をふり、質問を重ねることで、対応点を見つけやすくする。すべての点を見つけたら、順番に線でつなぎ、図形を完成させる。
+
+[CHUNK]
+## 点対称図形の作図における注意点とアドバイス
+点対称図形をかくのが少し手ごわいですが、「対称の中心までの長さが等しくなる点」を先にかいて、それを結ぶようアドバイスしてあげましょう。点対称では、1つ1つていねいに点をとらないと、線対称と混在してしまうところがあります。線対称みたいに、かんたんにできればいいんだけど……。落ち着いて、まず点をとってみようね。鏡に映したみたいになればいいのかな……? その通り! 長さをよく確認しながらかこうね。
+
+[CHUNK]
+## 正多角形と対称性の理解: 線対称と点対称の識別
+正多角形と対称性について学習する。正三角形の対称軸の数や、点対称となる多角形を見つける問題に取り組む。形を見て考えることが大切だが、表にまとめた結果からわかることもある。自分で対称の軸が引けない場合は、正多角形の紙を用意して、折ってみせるとよい。正多角形はすべて線対称であり、辺・頂点の数が偶数のものは点対称でもある。
+
+[CHUNK]
+## 正多角形の対称軸の数え方と回転による確認
+正多角形の線対称の「対称の軸」の本数がわからない。辺・頂点の数が多い図形になると混乱するので、まずは正三角形や正方形で、見て確かめることから始めましょう。正三角形は線対称な図形だね。でも対称の���は何本だろう……? 1本はわかるけど……。ほかにもありそうだね。図形を実際に回転させてみる。紙にかいて切り取ってもよいですし、本を持って上下をさかさまにしてもよいでしょう。目で見て確認することがポイントです。
+
+[CHUNK]
+## 正多角形の対称性のまとめと練習問題
+180°まわしたらもとの図とぴったり重なるのが点対称だね! 正五角形は無理みたい。正六角形は重なるね! 辺・頂点の数と同じ数だけ対称の軸があることを確認する。正三角形(辺・頂点の数が3)、正方形(辺・頂点の数が4) を使って、対称の軸の数が辺・頂点の数と同じだけあることを確かめましょう。頂点の多い正多角形でも同じことになると納得できれば素晴らしいですね。
+
+[CHUNK]
+## 対称の中心と対応点の特定: 平行四辺形を例に
+点対称図形には、必ず「対称の中心」 と 「対応する点」があります。自分で見つけられるようにしましょう。点対称図形の「対称の中心」を目分量で答える。対称の中心の見つけ方がわからず、「だいたい」で答えてしまうことがあります。このあたり? だいたいこのあたりかな……? わかりやすい「対応する点」を結ぶ。わかりやすい「対応する点」を結んで、その交点を調べることで「対称の中心」を見つけることができる。
+
+[CHUNK]
+## 対称の中心の見つけ方と対応点の関係性
+「点Aはくるんと180°まわると、どこにくる?」と声かけをして「対応する点」を見つけられるよう促しましょう。どの点とどの点が対応してるかな? AとCかな? あとはBとD? そう! どの点も、対称の中心から等しい距離にあるんだよね? じゃあ、こう? その通り! 対応する点どうしを結んで交わったところが対称の中心だね! つねに対称の中心を探す。まずは対称の中心を見つけないと、対応する点は特定できません。点対称では対称の中心が重要だということを伝えましょう。
+
+[CHUNK]
+## 対応点の特定: 対称の中心からの距離と方向
+180° 「くるん」とまわしたとき、どのあたりにくるかっていうことだよね。ちょうど反対側にくるね。何に対して反対なのかな? あ! 「対称の中心」だ! わかりやすく見つけられる「対応する点」から「対称の中心」を見つけることもできるし、「対称の中心」から「対応する点」を見つけることもできます。大切なのは「だいたい」で済まさないことです。
+
+# 小学校算数_図形_RAG最適化
+
+[CHUNK]
+## 単位換算の基本と「単位のはしご」の概念
+単位換算は、L(リットル)、mL(ミリリットル)、kg(キログラム)、g(グラム)など、体積や重さを別の単位に変換する際に重要。1kg = 1000gのような関係を利用。単位換算を容易にするツールとして「単位のはしご」を紹介。特に1000倍で単位が変わる体積や重さに有効。7マスの「はしご」を利用し、単位を視覚的に変換。
+単位のはしごは、体積や重さの単位換算を容易にする視覚的ツール。1000倍で単位が変わる場合に特に有効。
+
+[CHUNK]
+## 「単位のはしご」を使った体積と重さの単位換算
+「単位のはしご」は、体積(KL, L, mL)や重さ(t, kg, g)の単位換算に適用可能。例として、14850gをkgに変換するケースを提示。1kg=1000gの関係から、14.85kgと算出。はしご上で小数点位置を調整することで、単位換算を視覚的にサポート。1L=10dLのような関係も考慮し、必要に応じてdLを追記。長さ(mm, cm, m, km)や面積(mm², cm², m², a, ha, km²)でも同様の「単位のはしご」が作成可能。
+長さや面積、水のかさと重さの単位換算にも「単位のはしご」は応用可能。
+
+[CHUNK]
+## 三角形と四角形の学習導入と作図の基本
+part3では、身近な三角形と四角形を通して図形の知識を深める。三角形・四角形の性質や面積など、図形問題の基礎を習得。作図の基本として、コンパスと分度器の適切な使用法を解説。例として、定規、コンパス、分度器の中から、三角形作図に必要な道具を選択する問題。角度情報がない場合、定規とコンパスを使用。
+三角形と四角形の学習では、図形問題の基礎を習得し、コンパスと分度器の適切な使用法を理解する。
+
+[CHUNK]
+## コンパスを用いた作図と四角形の性質理解
+コンパスは、長さの取得に利用。10cmの辺を描いた後、コンパスで8cmと6cmの長さを設定し、交点を結んで三角形を作図。長さが既知の場合は定規とコンパス、角度が既知の���合は定規と分度器を使用。四角形の性質理解では、特徴の少ない順（台形→平行四辺形→長方形→ひし形→正方形）に確認。
+コンパスは長さの取得に利用し、四角形の性質は特徴の少ない順に確認することで効率的に理解する。
+
+[CHUNK]
+## 四角形の分類と特徴、複合図形の面積計算
+各四角形（台形、平行四辺形、長方形、ひし形、正方形）の特徴を整理。例えば、平行四辺形は2組の辺が平行で長さが等しい。長方形は4つの角が全て直角。ひし形は対角線が垂直に交わる。複合図形の面積を求める際は、足し算だけでなく引き算も利用。全体から不要部分を引くことで計算を簡略化。
+四角形は特徴の少ない順に分類し、複合図形の面積計算は引き算も利用することで簡略化する。
+
+[CHUNK]
+## 複合図形の面積計算例と三角形の合同条件
+複合図形の面積計算例として、複雑な図形を長方形と三角形に分割し、それぞれの面積を足し合わせる方法と、長方形から不要な三角形を引く方法を比較。三角形の合同条件（2辺とその間の角、2角とその間の辺、3辺）を提示。合同条件に基づき、図形が合同であるかを判断。
+複合図形の面積計算は、分割して足す方法と全体から引く方法を比較検討。三角形の合同条件を理解し、図形の合同判断を行う。
+
+[CHUNK]
+## 二等辺三角形の作図と平行四辺形の作図
+二等辺三角形の作図では、コンパスを使用。指定された辺の長さ（例：8cm、6cm、6cm）で三角形を作図。定規のみでの作図は困難。平行四辺形の作図では、4点目を試行錯誤で決定。平行四辺形になる点を複数試し、平行四辺形の性質を理解。
+二等辺三角形の作図にはコンパスを使用し、平行四辺形の作図は試行錯誤を通して理解を深める。
+
+[CHUNK]
+## 平行四辺形の作図と試行錯誤の重要性
+平行四辺形の作図では、与えられた3点から4つ目の点を決定。試行錯誤を通じて、平行四辺形を完成させる。試行錯誤力は算数の重要な要素。平行四辺形にならない場合でも、手を動かして試すことが重要。
+平行四辺形の作図は試行錯誤を通して理解を深め、試行錯誤力を養う。
+
+# 図形の教え方
+
+[CHUNK]
+## 四角形の対角線と類推
+四角形の対角線から四角形を類推する問題。対角線の端点を結び四角形を完成させる。微妙な図形は四角形の性質から考える。対角線から四角形をイメージできない場合は、与えられた対角線の端を結んでみる。
+
+[CHUNK]
+## 対角線の特徴と四角形の関係
+与えられた対角線の端を結び四角形を完成させる。四角形とその対角線をかいて確認する。対角線とあるから、それぞれの端を結ぶ。四角形は対角線から読み取れる。各四角形の特徴を整理し復習する。向きのイメージで形を覚えている場合、向きだけでなく対角線の特徴を考える。
+
+[CHUNK]
+## 四角形の対角線と特徴の整理
+向きだけでなく対角線の特徴を考える。次の図のような対角線をもつ四角形はどんな四角形か考える。四角形の特徴を表にまとめる問題。実際に四角形をかいてみて、辺の長さ、角の大きさ、対角線の長さや交わり方などを思い出してみることが大切。
+
+[CHUNK]
+## 四角形の特徴の整理と図形
+それぞれの四角形について、特徴がわかりやすい図がないと、うまくかけない。教科書や参考書の図を参考に、いろいろな四角形の図を子どもにかかせ、特徴を言い合ってみる。四角形の名前、特徴をまとめる。2本の対角線が垂直に交わるか、長さが等しいか、まん中で交わるか、角がすべて直角か、向かい合った辺が平行か、辺の長さがすべて等しいかなどを確認する。
+
+[CHUNK]
+## 四角形の特徴と図形の分類
+四角形の特徴をまとめる。図のア〜エにあてはまる四角形を考える。四角形、1組の辺が平行、2組の辺が平行、角がすべて直角、4本の辺の長さが等しいなどの条件から図形を特定する。
+
+[CHUNK]
+## 長方形の面積を求める
+L字形やコの字形の図形の面積を求める問題。「切り分けて求める」発想に加え、「いらないところを引く」発想も重要。大きな四角形からいらない部分を引く発想ができない場合、「引き算」に抵抗があると「切り分けて求める」となりがち。問題によっては手間が多くまちがいやすくなる。
+
+[CHUNK]
+## 面積計算の工夫
+手間が多くまちがいやすくなる場合がある。計算し���すい形に変える。「切り分けて求める」ができたら、「いらないものを引く」という発想を促す。上と下に切り分けたり、右と左で考えたり、他の方法があるか検討する。
+
+[CHUNK]
+## 図形の面積計算
+確かに「切り分けて足し算」でも正解が出せる問題は多いが、「いらないものを引く」という考え方は、ほかの問題でもよく使うので知っておくとよい。次の図の面積を求める。
+
+[CHUNK]
+## 三角形・平行四辺形の高さ
+鈍角になると高さがわからなくなる場合、「底辺と同じ高さのところから、いちばん高いところまで」と考えるようにする。方眼上でどの部分を数えれば高さになるのかわかっていない場合は、平行四辺形の面積の公式は、底辺×高さ。底辺が3cmだとすると、ななめのところが高さかな?と考える。
+
+[CHUNK]
+## 図形の高さの考え方
+底辺と同じ高さのところから、いちばん高いところまでが「高さ」と伝える。図形単体で考えるのではなく、底辺を延長する考え方が必要。声かけをして、気づかせてあげる。底辺と同じ高さのところ」つまり底辺の延長線上から頂点までの垂直な線が高さ。
+
+[CHUNK]
+## 高さの確認と面積計算
+底辺と同じ高さのところから、いちばんてっぺんまでが「高さ」と確認する。次の図の面積を求める。底辺は4cmで高さも4cm?底辺の年と辺の交差するところを数えている場合、高さは底辺のところから垂直にいちばん高いところまでと教える。
+
+[CHUNK]
+## 面積から三角形の高さや辺の長さを求める
+「底辺×高さ→面積」の1方向だけでなく、面積の公式を逆に計算して求める練習を、くり返し行う。公式は「あてはめて答えを出すもの」と思っていて、「わかっていることを書き込んで、未知数を求める」ということができない場合がある。
+
+[CHUNK]
+## 面積からの逆算
+面積(答え)はわかっているんだよね?」と声かけをする。面積の公式は「面積を求めるときにだけ使うもの」と思っている子どもは多い。声かけをし、答えを書き込んだ公式を書いてみてあげる。三角形の面積を求める公式は底辺×高さ÷2=面積と教える。
+
+[CHUNK]
+## 公式の逆算と面積計算
+小学生にとって、式は「=」の右の答えを出すためのもの」という認識。答えがわかっている式の逆算を一緒に練習して、考え方をマスターさせる。次の図の□にあてはまる数を求める。
+
+# 小学校算数図形問題集
+
+[CHUNK]
+## 複合図形の面積：道の面積の求め方（四角形内）
+四角形の中の道の面積を求める問題。道の部分の面積は、縦横の重なりがあるため、工夫が必要。糸口を見つけるには、図を移動させるなど、工夫して面積を楽に求める発想が重要。
+道の端への移動による等積変形を利用し、全体から道以外の部分を引く方法が有効。例: 全体(8m×15m)から道以外の部分(6m×13m)を引く。
+冗長な説明を削除し、簡潔な表現に修正。
+
+[CHUNK]
+## 複合図形の面積：平行四辺形を含む道の面積
+前のチャンクから50トークンの重複：道の端への移動による等積変形を利用し、全体から道以外の部分を引く方法が有効。例: 全体(8m×15m)から道以外の部分(6m×13m)を引く。
+平行四辺形と長方形が混ざった図形の面積問題。底辺と高さが同じ長方形と平行四辺形は面積が同じであることに着目。長方形の「たて」は平行四辺形の「高さ」にあたる。
+図形を自在に動かすことで、問題を簡略化。底辺と高さを変えなければ面積は変わらない。
+
+[CHUNK]
+## 合同な図形：合同の定義と見つけ方
+まったく同じ形・大きさの図形を「合同」と定義。ピッタリと重なるものが合同。裏返しの場合も含む。
+「だいたいの形」が似ているだけで合同と判断しないよう注意。合同＝同じ形という認識では不十分。
+辺の長さや角度を書き込むことで、より正確に判断可能。2つの辺とその間の角が同じなら、同じ三角形。直角三角形がわかりやすい。
+
+[CHUNK]
+## 合同な図形：合同な図形の見つけ方（続き）
+前のチャンクから50トークンの重複：辺の長さや角度を書き込むことで、より正確に判断可能。2つの辺とその間の角が同じなら、同じ三角形。直角三角形がわかりやすい。
+方眼を活用し、長さを書き込むことで、より正確に合同な図形を見つける。
+「だいたい」で判断せず、具体的な数値で確認することが重要。
+
+[CHUNK]
+## 合同な三角形の作図：作図条件の理解
+合同な三角形を作図するには、三角形の合同条件を覚えることが不可欠。条件によって使用する道具が異なる。
+三角形の合同条件が不明確だと、どの道具をどう使えば良いか判断できない。
+三角形の合同条件（3辺相等、2辺夾角相等、2角夾辺相等）を理解させることが重要。
+
+[CHUNK]
+## 合同な三角形の作図：作図手順と道具の選択
+前のチャンクから50トークンの重複：三角形の合同条件（3辺相等、2辺夾角相等、2角夾辺相等）を理解させることが重要。
+合同条件に応じて、定規、コンパス、分度器を適切に使い分ける。角度がわかっている場合は分度器、長さのみの場合はコンパスを使用。
+作図手順を具体的に解説。例：底辺を引く→分度器で角度を測る→定規で線を引く。
+
+[CHUNK]
+## 三角形の角度：重なりから角度を求める方針
+三角形の重なりから角度を求める問題。不要な角まで求めてしまう誤りを防ぐため、解法の方針を定めることが重要。
+三角形の内角の和や外角の性質など、どの知識を使うか事前に考える。
+「わかる角度」を書き込むだけでなく、必要な角度を絞り込む。
+
+[CHUNK]
+## 三角形の角度：解法と知識の活用
+前のチャンクから50トークンの重複：「わかる角度」を書き込むだけでなく、必要な角度を絞り込む。
+必要な角度を特定し、三角形の内角の和（180°）や外角の定理を活用。
+例：三角形DECの内角から角イを求め、角イから角アを求める。
+
+# 小学校6年間の図形の教え方
+
+[CHUNK]
+## ワークの答え (p.51-75): 図形問題の解答と解説
+
+p.51: 中点と垂直に関する問題。図形の中点を求め、垂直な線を見つける。
+p.53: アとエの図形が該当する問題。図形の形状を識別する。
+p.55: 図形の辺の長さを測定し、指定された図形を作成する。図形の辺の長さと形状を理解する。
+p.57: 図形内の指定された位置に頂点を配置し、線で接続する。頂点の位置と線の接続方法を理解する。
+p.59: 平行四辺形、長方形、正方形を識別する。四角形の特性を理解する。
+p.61: 台形、平行四辺形、長方形、ひし形を識別する。四角形の特性を理解する。
+p.63: 図形の面積を計算する。面積の計算方法を適用する。
+p.65: 図形の面積を計算する。単位換算も含む。面積の計算と単位換算を理解する。
+
+[CHUNK]
+## 図形の面積計算と形状識別 (p.67-75): 解答と解説 (重複50トークン)
+p.67: 図形の辺の長さを計算する。図形の辺の長さの計算方法を理解する。
+p.69: 図形の面積を計算する。単位換算も含む。面積の計算と単位換算を理解する。
+p.71: アとエ、イとオ、カとクの図形を識別する。図形の形状を識別する。
+p.73: 指定された条件で図形を作成する。分度器と定規の使用方法を理解する。
+p.75: 角度を計算する。角度の計算方法を理解する。
+p.76: 指定された条件で図形を作成する。図形の作成方法を理解する。
+p.77: 図形の面積を計算する。複雑な図形の面積計算方法を理解する。
+
+[CHUNK]
+## 三角形・四角形の復習と角の合計 (p.76-80): 図形問題の解答と解説 (重複50トークン)
+p.76: 図形の頂点を指定された位置に配置し、線で接続する。これにより、様々な四角形を作成する。
+p.77: 複雑な図形の面積を計算する。補助線を利用して、図形を分割し、面積を計算する。角度を計算する問題も含む。
+p.78-79: 図形問題の解答。様々な図形の特性を理解し、問題を解決する。
+p.80: コラム: ☆形の角の合計は常に一定であることを解説。三角形の外角の性質を利用して証明する。
+
+[CHUNK]
+## 円の基本要素と円周の理解 (p.82-84): 円の定義と円周率 (重複50トークン)
+p.82: 円の基本要素（半径、直径、中心、円周、面積）を定義する。円の各部分の関係性を理解する。
+p.83: 円を8つ折りにする方法とコンパスを使った円の描き方を説明する。円の作成方法を理解する。
+p.84: 円周の長さを実際に測って体感する方法を説明する。円周率（約3.14）を導入する。円周と直径の関係を理解する。
+
+[CHUNK]
+## 円の面積とコンパスの使い方 (p.84-87): 円の面積計算と作図 (重複50トークン)
+p.84: 円の面積を求めるために、円を細かく分割して四角形に近似する方法を説明する。円の面積の公式（半径×半径×3.14）を導出する。
+p.85: 円周の長さと直線の長さを比較する��題。円周の概念を理解する。
+p.86: コンパスを使って円をかく方法をステップごとに説明する。コンパスの選び方や準備についても解説する。
+p.87: コンパスを使って実際に円をかく練習問題。指定された点を中心に、指定された半径の円をかく。
+
+# 小学校算数図形問題 RAG最適化ナレッジベース
+
+[CHUNK]
+## 3年生: 円と四角形 - 半径から長方形の辺を求める
+半径3cmの円が長方形に内接している時、長方形の辺長を求める問題。円の半径と長方形の辺の関係理解が重要。半径は円の中心からどの方向へ引いても同じ長さである点を理解させる。半径が斜めに示されている場合に、縦横の辺との関係を見つけ出すのが難しい。
+
+[CHUNK]
+## 3年生: 円と四角形 - 直径と補助線による辺長特定
+半径3cmの円が内接する長方形の辺長を求める。円の直径が長方形の辺と一致することに気づかせる。補助線として、円の中心を通る縦横の線を引き、直径を視覚的に捉えやすくする。直径は半径の2倍であるため、半径から直径を計算する。
+
+[CHUNK]
+## 3年生: 円と四角形 - 具体例と演習問題
+半径3cmの円が縦に2つ、横に3つ並んで長方形に内接している場合、縦の長さは直径6cmの2倍で12cm、横の長さは直径の3倍で18cmとなる。半径4cmの円が4つ内接する長方形の縦の長さ、指定された点間の距離を求める演習問題。図形問題は手を動かし、試行錯誤を通じて解法を発見させることが重要。
+
+[CHUNK]
+## 5年生: 円と三角形 - 半径を用いた正三角形の作図
+半径2cmの円を利用し、一辺2cmの正三角形を作図する問題。円の半径はどこも同じ長さであるという性質を活用。コンパスを用いて円周上に点を取ることで正三角形を作図できることを体感的に理解する。定規のみで正三角形を作図しようとする誤りを防ぐため、コンパスの使用に慣れさせる。
+
+[CHUNK]
+## 5年生: 円と三角形 - コンパスを用いた花びら模様の作図
+半径2cmの円を利用した正三角形作図。円周上にコンパスの針を置き、同じ半径で円を描くことで花びらのような模様を作る。模様の各交点が正三角形の頂点となることを理解する。円とコンパスの性質理解を促し、今後の図形学習への応用力を養う。
+
+[CHUNK]
+## 5年生: 円と三角形 - 花びら模様と正三角形の関係
+花びら模様の中心の円に着目すると、内部に6つの正三角形が存在する。円周上の点から半径2cmで半円を描き、元の円との交点を結ぶことで正三角形を作図できる。円とコンパスを用いた作図を通して、図形の性質を視覚的に理解させることが重要。二等辺三角形を作図する演習問題。
+
+[CHUNK]
+## 5年生: 円周 - 円周から直径を求める
+円周の長さが30cmの円の半径を概数で求める問題。円周率（3.14）を用いて円周から直径を求める計算。割り算よりも掛け算の関係で理解を深める。「直径×3.14=円周」という関係式を理解させ、既知の情報から未知の情報を導き出す思考力を養う。
+
+[CHUNK]
+## 5年生: 円周 - 関係式と質問による理解促進
+円周から直径を求める問題。「直径×3.14=円周」の関係式に既知の円周の長さを代入し、直径を求める式を導き出す。質問形式で子供の知識を引き出し、能動的な問題解決を促す。直径を求めるために割り算が必要となることを理解させる。
+
+[CHUNK]
+## 5年生: 円周 - 概数計算と演習問題
+円周から求めた直径を概数で表す。10分の1の位までの概数を求めるには、100分の1の位まで計算し四捨五入する。円周の長さが37.68cmの円の直径を求める演習問題。計算スキルだけでなく、問題文の意味を理解し、適切な公式を選択する能力も重要。
+
+[CHUNK]
+## 5年生: おうぎ形のまわりの長さ - 基本概念
+中心角が90°や180°のおうぎ形の周りの長さを求める問題。おうぎ形の弧の長さと半径（または直径）を足し合わせる必要がある。90°は円周の1/4、180°は円周の1/2であるという理解が前提。周りの長さの意味を理解していないと、弧の長さのみを計算して終わってしまう。
+
+[CHUNK]
+## 5年生: おうぎ形のまわりの長さ - 計算手順と視覚化
+おうぎ形の周りの長さを求める際、計算の順序を意識させることが重要。弧の長さを計算しただけで終わらないように、計算を始める前に全体の流れを確認する。弧の部分を波線、直径や半径を直線でなぞり、視覚的に区別することで、足し��れを防ぐ。
+
+[CHUNK]
+## 5年生: おうぎ形のまわりの長さ - 計算例と演習問題
+中心角90°のおうぎ形の場合、弧の長さは (直径)×3.14÷4 で求められる。求めた弧の長さに半径2つ分の長さを足すことで、周りの長さを算出する。中心角60°のおうぎ形の周りの長さを求める演習問題。図形問題は、視覚的な補助と丁寧な計算が重要。
+
+[CHUNK]
+## 5年生: 半円組み合わせ図形の周りの長さ - 全体像把握の重要性
+複数の半円を組み合わせた図形の周りの長さを求める問題。一度に計算しようとせず、個々の半円に分割して考える。各半円の直径と半径を正確に把握し、それぞれの弧の長さを計算する。複雑な図形を単純化し、一つずつ解決していく能力が求められる。
+
+[CHUNK]
+## 5年生: 半円組み合わせ図形の周りの長さ - 式の可視化と計算
+個々の半円の周りの長さを式で表現する。各半円の直径を基に、円周の半分の長さを計算する。計算過程を可視化することで、誤りを減らす。各半円の式を縦に揃えて書き、同じ種類の数（3.14など）をまとめて計算する。
+
+[CHUNK]
+## 5年生: 半円組み合わせ図形の周りの長さ - 計算効率化と分配法則
+各半円の周の長さを足し合わせる。3.14を各項に分配し、計算を効率化する。分配法則を理解することで、より複雑な計算もスムーズに行えるようになる。複数の半円を組み合わせた図形の周りの長さを求める演習問題。
+
+# 図形の教え方
+
+[CHUNK]
+## 半円・おうぎ形組み合わせ問題：基本と計算ミス対策
+小学校6年生で学習する半円やおうぎ形を組み合わせた図形の面積問題について解説。計算ミスを防ぐために、式をまとめて3.14のかけ算を1回にすること、3.14にかける数を小さくすることの重要性を説明。分配法則の逆利用で計算を効率化。
+
+[CHUNK]
+## 分配法則の逆利用と計算例：半円・おうぎ形組み合わせ問題
+分配法則の逆利用（例：2×10+3×10=(2+3)×10=50円）を解説。複雑な図形の面積計算例として、12×12×3.14÷2 - 8×8×3.14÷2 + 4×4×3.14÷2 = (72-32+8)×3.14 = 48×3.14 = 150.72cm² を提示。式をまとめることで計算が容易になることを示す。
+
+[CHUNK]
+## 図形問題応用：半径の異なる円の面積の和
+半径6cmの円と8cmの円の面積の和が、半径何cmの円の面積と等しいかを問う問題。6×6×3.14 + 8×8×3.14 = (36+64)×3.14 = 100×3.14 より、半径10cmの円と等しいことを解説。
+
+[CHUNK]
+## 正方形とおうぎ形組み合わせ問題：図形分解と線分図の活用
+正方形とおうぎ形を組み合わせた図形の面積問題について、図を分解して考えることの重要性を解説。1辺が8cmの正方形内の特定部分の面積を求める例題を通して、線分図を使った考え方を練習する。
+
+[CHUNK]
+## 線分図による長さの算出：正方形とおうぎ形組み合わせ問題
+線分図を用いて、複雑な図形内の線分の長さを求める方法を解説。AからC、DからB、CからDまでの長さをABから他の線分を引くことで算出する。例：AからCまで = AB - CB = 10 - 7 = 3cm。
+
+[CHUNK]
+## 線分図の応用：線分の分割と組み合わせによる問題解決
+ABの中点をEとしたとき、CからE、EからDの長さを線分図で求める。CからDまでの長さはCE+DEで計算。わかっていることを3つの線に分け、AD + CB - AB = CD の関係からCDの長さを求める。
+
+[CHUNK]
+## 図形問題の解法：線分図で理解した知識の応用
+線分図で理解した考え方を実際の図形問題に応用する。正方形、三角形、おうぎ形に図形を分割し、それぞれの面積を求める。8cmの正方形、三角形、おうぎ形を組み合わせた図形の面積を計算する例を示す。
+
+[CHUNK]
+## 図形面積計算：複数の解法アプローチ
+複数の解法で同一の図形問題（正方形とおうぎ形の組み合わせ）を解く。64 - 50.24 = 13.76cm²、64 - 13.76×2 = 36.48cm²、50.24 - 32 = 18.24cm²、18.24 + 18.24 = 36.48cm²、50.24 + 50.24 - 64 = 36.48cm² など、異なるアプローチで同じ答えが得られることを示す。
+
+[CHUNK]
+## 図形問題演習：色を塗った部分の面積を求める
+20cmの正方形内に配置された図形の、色を塗った部分の面積を求める演習問題。線分図で考え方を練習した後、同様の問題に応用する。
+
+[CHUNK]
+## 円の復習：円周と面積の計算
+円の復習として、様々な図形の円周の長さと面積を求める問題。半径や直径が与えられた円、半円、扇形などについて、それぞれの円周の長さと面積を計算する。
+
+[CHUNK]
+## 図形の面積計算：複合図形
+複合図形において、特定の部分（例：斜線部分）の面積を求める問題。正方形や扇形など、複数の図形が組み合わさった図形について、指定された部分の面積を計算する。
+
+[CHUNK]
+## 円の比較と応用：円周と面積の倍数計算
+半径の異なる円（例：半径8cmの円と半径4cmの円）の円周や面積の倍数を計算する問題。文中の空欄に数字を埋める形式で、円の性質を理解する。
+
+[CHUNK]
+## 図形の割合：正方形と内接円
+正方形と内接円の関係について、文中の空欄に数字を埋める形式で理解を深める。左の円の面積は、色を塗ってある正方形の面積の約何倍か、正方形の面積が80cm²のとき、中にきっちり入っている円の面積はいくらか、といった問題に取り組む。
+
+[CHUNK]
+## 解答：図形問題の解答
+p.85からp.103までのワークの解答を示す。円周、面積、複合図形の面積など、様々な図形問題の解答を一覧で提示。
+
+[CHUNK]
+## 解答詳細：図形問題の解答と解説
+p.104とp.105の円の復習問題の解答と解説。円周の長さ、面積、複合図形の面積などを求める計算過程を詳細に説明。図形問題の理解を深める。
+
+[CHUNK]
+## 解答詳細：図形問題の解答と解説（続き）
+p.107の図形問題の解答と解説。正方形と円の複合図形における面積計算、円周の長さなどを求める過程を詳細に説明。図形問題の理解を深める。
+
+# 小学校算数図形問題RAG最適化ナレッジベース
+
+[CHUNK]
+## 円の模様作りと図形観察の導入
+コンパスを使った円の模様作りは、図形への興味を引き出す導入として効果的。同じ半径の円を重ねて描くことで、美しい模様が生まれる。模様作りを通して、図形の規則性や対称性への気づきを促す。半円を組み合わせた図形の円周を調べる活動も、図形観察の基礎となる。模様作りの手順: (1)半径2cmの円を描く。(2)コンパスの幅を変えずに円周上に針を置いて別の円を描く。(3)交点を中心にさらに円を描き、繰り返す。完成した模様から、図形的な特徴(花びらのような形)を発見させる。
+
+[CHUNK]
+## 図形観察と円周の関係性
+模様作りを通して、図形の規則性や対称性への気づきを促す。半円を組み合わせた図形の円周を調べる活動も、図形観察の基礎となる。半円を組み合わせた図形の円周の長さを求める問題を通して、円周率の理解を深める。図形の周りの長さを求める際、半径の異なる半円を組み合わせることで、計算の複雑さを増し、応用力を養う。最終的に、最も大きな円の円周と等しくなるという結論を導き出す。
+
+[CHUNK]
+## 半円組み合わせ図形の円周計算
+図形の周りの長さを求める際、半径の異なる半円を組み合わせることで、計算の複雑さを増し、応用力を養う。最終的に、最も大きな円の円周と等しくなるという結論を導き出す。例:半径6cm, 4cm, 2cmの半円を組み合わせた図形の周りの長さは、12×3.14で計算できる。計算過程を示すことで、理解を助ける。12×3.14+2+8×3.14+2+4×3.14+2 = (6+4+2)×3.14 = 12×3.14。
+
+[CHUNK]
+## 立体の見取り図の描き方とポイント
+空間認識力を養うには、見取り図の作成が不可欠。見取り図を描く際のポイントは、平行線を意識すること。方眼紙を利用して、見取り図の描き方を段階的に習得する。手順:(1)正面の長方形を描く。(2)方眼の格子の点を数えながら平行線を引く。(3)各頂点を線で結ぶ。慣れてきたらフリーハンドで描く練習をする。
+
+[CHUNK]
+## 見取り図の応用と斜め線の練習
+各頂点を線で結ぶ。慣れてきたらフリーハンドで描く練習をする。斜め線の傾きを変えることで、様々な方向から見た立体を描く練習をする。見える部分は実線、見えない部分は点線で表現する。立方体の見取り図を例に、斜め線の引き方、実線と点線の使い分けを練習する。
+
+[CHUNK]
+## 底面と高さの関係理解
+立体図形の体積を理解するためには、底面と高さの関係を理解することが重要。底面と高さは見る方向によって変わることを、具体例を通して理解する。ティッシュペーパーの箱など身近な物を使って、底面を変えた場合に高さがどう変わるかを確認する。牛乳パックを例に、体積の目安を把握することも有効。
+
+[CHUNK]
+## 体積計算における工夫
+牛乳パックを例に、体積の目安を把握することも有効。体積計算では、計算の順序��工夫することで、計算を簡単にすることができる。例:5×15÷2×20の計算を、5×15×(20÷2)とすることで、計算が容易になる。3つの数字のかけ算では、順序を工夫することで計算ミスを減らせる。
+
+[CHUNK]
+## 直方体の体積と辺の長さの関係
+直方体の体積から辺の長さを求める問題を通して、体積の理解を深める。□を使った式を立てて計算する方法と、底面積から高さを求める方法を習得する。交換法則を利用して計算を簡単にする方法も有効。例:8×□×15=1080という式を、8×15×□=1080と変形することで、計算が容易になる。
+
+[CHUNK]
+## 高さから底面を見つける
+交換法則を利用して計算を簡単にする方法も有効。例:8×□×15=1080という式を、8×15×□=1080と変形することで、計算が容易になる。高さが与えられた場合に、どの面が底面になるかを判断する練習をする。底面に色を塗ることで、視覚的に理解を助ける。体積がわかっている直方体で、辺の長さを求める練習問題に取り組む。
+
+# 小学校6年間の図形の教え方
+
+[CHUNK]
+## 直方体の体積：複雑な立体の攻略
+直方体を取り除いたり、はり合わせたりする問題では、どちらの考え方でも良いという安心感が重要。体積の基本は(たて)×(よこ)×(高さ)だが、(底面積)×(高さ)も理解することで、立体図形への理解が深まる。複雑な立体に対して抵抗感をなくすため、手順を一つずつ確認し、体感させることが重要。
+
+[CHUNK]
+## 複雑な立体の体積：計算手順と教え方
+抵抗感をなくすため、手順を一つずつ確認し、体感させることが重要。「はり合わせ」「取りのぞき」の2つの解法を提示し、両方で解けることを伝える。図に直接書き込み、解く道筋を視覚的に示すことが効果的。例として、複雑な立体を分割し、各部分の体積を計算して合計する方法を示す。
+
+[CHUNK]
+## 複雑な立体の体積：計算例と底面積の活用
+各部分の体積を計算して合計する方法を示す。例えば、底面積を分割して考え、それぞれの面積を計算し、合計することで全体の底面積を求める。体積は(底面積)×(高さ)で計算できることを再確認する。
+
+[CHUNK]
+## 体積と容積：違いの理解と問題解決
+体積と容積はどちらも「かさ」を表すが、体積は「そのもの自体のかさ」、容積は「入れ物に入るもののかさ」を指す。厚さのある入れ物の場合、体積と容積の違いを理解することが重要。容積を求める際に体積を答えてしまう間違いを防ぐ必要がある。
+
+[CHUNK]
+## 体積と容積：計算と単位換算
+容積を求める際に体積を答えてしまう間違いを防ぐ必要がある。体積と容積の問題では、「内のり」の寸法を図に書き込ませることが有効。板の厚さを考慮して内側の寸法を計算し、容積を求める。体積の単位はcm³、容積の単位はmL、Lなどを使用し、単位換算の理解も重要。
+
+[CHUNK]
+## 体積と容積：単位換算と板の体積
+mL、Lなどを使用し、単位換算の理解も重要。1mL=1cm³であることを理解し、Lとcm³の相互換算ができるようにする。木の板の体積がどこを指すか理解することも重要。直方体全体の体積から容積を引くことで、木の板の体積を求められることを説明する。
+
+[CHUNK]
+## いろいろな立体の体積：底面の見つけ方
+底面を見つけて体積を求める問題では、(底面積)×(高さ)=(体積)の公式を活用する。立体を水平にスライスした際に、どの高さでも切り口が同じになるかを理解させることが重要。図の下の部分が底面だと思い込んでしまうケースがあるので注意が必要。
+
+[CHUNK]
+## 立体の体積：底面と高さの特定
+図の下の部分が底面だと思い込んでしまうケースがあるので注意が必要。つみきなどを用いて、実際に触れながら形を確認すると理解が深まる。底面となる面に色をつけさせ、その面を底面にして立体を立てて考える練習をする。
+
+[CHUNK]
+## 立体の体積：底面の確認と体積計算
+立体を立てて考える練習をする。立てたときに、どの高さで水平に切っても底面積と同じ形・大きさになるかを確認する。底面と高さを特定できれば、(底面積)×(高さ)で体積を計算できる。
+
+# 小学校6年間の図形の教え方
+
+[CHUNK]
+## 立体の理解：展開図とパターン認識
+[CHUNK]識別子
+立体把握の重要性：展開図のパターン認識、斜め立体の体積計算。身近な物を活用。
+展開図の学習：ティ���シュ箱の展開で基本を理解。切る位置で形状変化。立方体の展開図は何種類？
+6種類程度の予想に対し、実際は11種類存在することを示す。
+50トークン重複：実際は11種類存在することを示す。
+[CHUNK]
+## 立方体の展開図の種類とパターン
+[CHUNK]識別子
+立方体の展開図の種類：[1-4-1]型（6種）、[1-3-2]型（3種）、[2-2-2]型（1種）、[3-3]型（1種）。
+[1-4-1]型：1段目に1個、2段目に4個、3段目に1個。回転・反転で重複排除。
+[1-3-2]型：1個、3個、2個の順。2段目と3段目の形状固定。
+[2-2-2]型、[3-3]型：各1種類。
+50トークン重複：各1種類。[2-2-2]型、[3-3]型は各1種類。
+[CHUNK]
+## 斜め立体の体積：10円硬貨の積み重ね
+[CHUNK]識別子
+斜め立体の体積：通常の体積計算との関連性。
+問題提起：斜めになった立体の体積の求め方。
+アプローチ：10円硬貨の積み重ねによる視覚的な理解。
+50トークン重複：視覚的な理解。
+[CHUNK]
+## 円柱の体積と斜め変形
+[CHUNK]識別子
+円柱による体積計算：(底面積)×(高さ)で体積を求める。
+斜め変形：積み重ねた硬貨をずらす。高さは変わらない。
+結論：斜めになった立体の体積も(底面積)×(高さ)で計算可能。
+50トークン重複：(底面積)×(高さ)で計算可能。
+[CHUNK]
+## 具体例：円柱と斜め円柱の体積計算
+[CHUNK]識別子
+円柱の体積計算例：底面積3×3=9cm²、高さ12cm、体積9×12=108cm³。
+斜め円柱の体積計算例：底面積2×2×3.14=12.56cm²、高さ12cm、体積12.56×12=150.72cm³。
+50トークン重複：体積12.56×12=150.72cm³。
+[CHUNK]
+## 図形問題演習：まとめワーク
+[CHUNK]識別子
+まとめワーク：part2~part5の復習問題。
+図形学習の総仕上げ。
+間違えた問題は該当単元に戻って復習。
+50トークン重複：該当単元に戻って復習。
+[CHUNK]
+## 計算問題：単位換算と四則演算
+[CHUNK]識別子
+単位・図形の性質/三角形・四角形
+計算問題：単位換算を含む四則演算。kg, g, m, cm, L, dL等の単位。
+例：2kg300g+7kg800g, 3m22cm-1m85cm, 3L2dL-2L6dL, 4kg70g-2kg300g, 2m48cm+1m55cm
+50トークン重複：2m48cm+1m55cm
+[CHUNK]
+## 単位換算と水の重さ
+[CHUNK]識別子
+単位換算：kg→g, m→cm, L→dL, L→mLの換算。
+例：3kg20g = g, 6m5cm = cm, 3L7dL = dL, 4L20mL = mL, 3.7L = mL
+水の重さ：2L (kg) = ( )kg, 1630mL (g) = ( )g, 850cm³ (kg) = ( )kg, 3L4dL (g) = ( )g, 1L480mL (kg·g) = ( )kg( )g
+50トークン重複：1L480mL (kg·g) = ( )kg( )g
+[CHUNK]
+## 角の測定と図形の作図
+[CHUNK]識別子
+角の測定：分度器による角度測定。
+図形の作図：平行線、垂直線の作図。
+50トークン重複：平行線、垂直線の作図。
+[CHUNK]
+## 角の大きさの計算
+[CHUNK]識別子
+角度計算：平行線における角度計算。
+例：ア、イ、ウの角度を求める。
+50トークン重複：ア、イ、ウの角度を求める。
+[CHUNK]
+## 図形の対称性：線対称と点対称
+[CHUNK]識別子
+図形の対称性：線対称な直線、点対称な図形を見つける。
+50トークン重複：点対称な図形を見つける。
+[CHUNK]
+## 図形の拡大と縮小
+[CHUNK]識別子
+図形の拡大・縮小：三角形の2倍の拡大図、1/2の縮図。
+50トークン重複：三角形の2倍の拡大図、1/2の縮図。
+[CHUNK]
+## 対称軸と点対称性の識別
+[CHUNK]識別子
+図形の対称性：線対称の軸、点対称の中心を作図。
+50トークン重複：点対称の中心を作図。
+[CHUNK]
+## 正多角形の対称性
+[CHUNK]識別子
+正多角形の対称性：正方形、正五角形、正六角形、正七角形、正八角形について、対称軸の本数と点対称性の有無を答える。
+50トークン重複：対称軸の本数と点対称性の有無を答える。
+[CHUNK]
+## 平行四辺形の点対称性
+[CHUNK]識別子
+平行四辺形の点対称性：対称の中心を作図。点Pに対応する点を作図。
+50トークン重複：点Pに対応する点を作図。
+[CHUNK]
+## 図形の面積計算
+[CHUNK]識別子
+図形の面積：複合図形の面積計算。長方形から一部を切り取った図形、道幅のある土地の面積。
+50トークン重複：道幅のある土地の面積。
+[CHUNK]
+## 円周の長さと面積
+[CHUNK]識別子
+円：円周の長さと面積を求める。
+50トークン重複：円周の長さと面積を求める。
+[CHUNK]
+## 複合図形の円周と面積
+[CHUNK]識別子
+複合図形：円の一部を含む複合図形の円周の長さと面積を求める。
+50トークン重複：円の一部を含む複合図形の円周の長さと面積を求める。
+
+# 小学校6年間の図形の教え方
+
+[CHUNK]
+## 立体の体積：台形底面の直方体
+図のような立体の体積を求��る。台形ABCDを底面としたとき、高さは？体積は？台形ABCDを底面とすると、高さは3cm。体積は底面積x高さで求められる。底面積は台形の面積の公式(上底+下底)x高さ÷2で計算。
+
+[CHUNK]
+## 台形底面の直方体の体積計算
+高さは何cmですか。体積はいくつになりますか。底面積は(5+8)x3÷2=19.5cm²。体積は19.5cm²x3cm=58.5cm³。したがって、高さは3cm、体積は58.5cm³。
+
+[CHUNK]
+## 立体の体積：高さが24cmの直方体
+次の立体の体積を求める。高さをCK=24cmとすると、底面積は？体積は？高さをCKの24cmと考えると、底面の面積は？体積はいくつになりますか。
+
+[CHUNK]
+## 底面積と体積の計算：高さ24cmの直方体
+底面積は(6+16)x4÷2=44cm²。体積は44cm²x24cm=1056cm³。したがって、底面積は44cm²、体積は1056cm³。
+
+[CHUNK]
+## 木の板で作った直方体の入れ物：容積と水面の高さ
+厚さ1cmの木の板で直方体の入れ物を作る。容積は？42dLの水を入れた時の水面の高さは？入れ物の容積は何cmですか。また、何dLですか。水面の高さは、入れ物の外側の底から何cmですか。
+
+[CHUNK]
+## 直方体の入れ物の容積と水面の高さの計算
+入れ物の内側の寸法は、縦37-2=35cm、横22-2=20cm、高さ21-1=20cm。容積は35cmx20cmx20cm=14000cm³=14dL。水42dL=4200cm³。水面の高さは4200cm³÷700cm²=6cm。底板の厚みを足して6+1=7cm。
+
+[CHUNK]
+## 体積と単位換算
+次の□にあてはまる数を入れましょう。1L=□dL=□cm³、34000cm³=□dL=□L、0.37L=□dL=□cm³。
+
+[CHUNK]
+## L, dL, cm³の単位換算
+1L=10dL=1000cm³、34000cm³=3400dL=34L、0.37L=3.7dL=370cm³。単位換算は、1L=10dL=1000cm³の関係を利用する。
+
+[CHUNK]
+## 図形の対称の中心
+まず、対角線の交点から対称の中心を求めます。対称の中心を通って、向かい側の辺と交差するところが、対応する点です。
+
+[CHUNK]
+## 図形のまわりの長さと面積の計算
+(まわりの長さ) 37.68cm。半円を組み合わせた図形のまわりの長さは、いちばん大きな半径の円の円周と等しくなります。12×3.14=37.68。
+
+[CHUNK]
+## 半径2cmの円周の計算
+(まわりの長さ)25.12cm。半径2cmの円の円周2つ分。4×3.14×2=25.12。
+
+[CHUNK]
+## 1辺4cmの正方形の面積
+(面積)16cm²。1辺4cmの正方形と同じ面積。4×4=16。
+
+[CHUNK]
+## 図形の面積計算：円と正方形の組み合わせ
+(面積)75.36cm²。6×6×3.14÷2+4×4×3.14÷2-2×2×3.14÷2=18×3.14+8×3.14-2×3.14=(18+8-2)×3.14=24×3.14=75.36。
+
+[CHUNK]
+## 立体の体積計算：複合図形
+①472cm²。(12+16)×24-(12×6+16×8)=472。②180m²。(12-2)×(20-2)=180。
+
+[CHUNK]
+## 図形の周りの長さの計算
+① (まわりの長さ) 35.7cm。20×3.14÷4+10×2=15.7+20=35.7。
+
+[CHUNK]
+## 図形の面積の計算
+(面積)78.5cm²。10×10×3.14÷4=78.5。
+
+[CHUNK]
+## 図形の周りの長さの計算：円と線分の組み合わせ
+①24.84。6×3.14÷2+12×3.14÷4+6=3×3.14+3×3.14+6=6×3.14+6=24.84。
+
+[CHUNK]
+## 図形の周りの長さの計算：円と線分の組み合わせ
+②33.12。8×3.14+4×2=25.12+8=33.12。
+
+[CHUNK]
+## 拡大図と縮図
+2倍の拡大図、1/2の縮図。
+
+[CHUNK]
+## 立体の体積計算
+①8。(3+5)×3+2×8=8×3+2×8=96。②112。8×16-4×4=128-16=112。
+
+[CHUNK]
+## 立体の体積計算：直方体
+①14000、140。(37-2)×(22-2)×(21-1)=35×20×20=14000。
+
+[CHUNK]
+## 立体の体積計算：直方体（内側）
+②7。内のりの底面積:(37-2)×(22-2)=35×20=700cm²。容積は42dLだから、4200cm³。4200÷700=6cm。これに底の板の厚みを加えると、6+1=7。
+
+[CHUNK]
+## 単位換算：Lとcm³
+①10、1000。②340、34。③3.7、370。
+
+[CHUNK]
+## 平行な直線と垂直な直線
+(平行な直線)と、と。(垂直な直線) おとか。
+
+[CHUNK]
+## 正多角形の対称の軸
+正多角形の対称の軸は、辺(角)の数と同じだけあります。ア 4本、イ 5本、ウ 6本、エ 7本、オ 8本。
+
+[CHUNK]
+## 点対称な図形
+点対称な図形は、辺(角)の数が偶数のものです。②ア、ウ、オ。

V1.7.1/knowledge/ORIGINAL/算数/中学入試攻略 下克上算数ドリル【速さ編】.md

@@ -0,0 +1,808 @@
+# 中学入試攻略 下克上算数ドリル【速さ編】
+
+[CHUNK]
+## はじめに: 単元特化型問題集の紹介
+この本は、中学受験算数の速さに特化した問題集です。一般的な問題集と異なり、特定の単元（速さ、旅人算、流水算、列車算、時計算）に焦点を当てています。ご家族と一緒に、自分1人で問題を解く力を身につけることを目指します。
+
+[CHUNK]
+## 他の問題集との違い: 手書きメモと解法ステップ
+自分1人で問題を解く力を身につける。本書の特色は、手書きの計算メモをそのまま掲載し、先生が目の前で解説しているような安心感を提供します。計算メモをSTEP1からSTEP4で表し、解く順番を分かりやすく解説。関連する言葉や数字を同じ色で表現し、理解を促進します。
+
+[CHUNK]
+## 解説の理解度向上と本書の構成
+解く順番を分かりやすく解説。関連する言葉や数字を同じ色で表現し、理解を促進します。本書は、まず問題に挑戦し、わからなかったポイントを後半で確認する構成を採用。定着力とスピードを重視しています。対象者は、中学受験生、速さを学び直したい中学生、保護者です。
+
+[CHUNK]
+## 著者紹介と中学受験の経験
+定着力とスピードを重視しています。対象者は、中学受験生、速さを学び直したい中学生、保護者です。著者は山下晃平。中学受験に全敗した経験から、小学生向けの解説ノートを作成し、早稲田大学の附属高校に合格。現在はロジカルスクールの講師を務めています。
+
+[CHUNK]
+## 目次: 本書の構成要素
+現在はロジカルスクールの講師を務めています。本書は問題集（p4-18）、解説（p19-74）、算数が得意になるポイント（p74-86）で構成されています。基本問題に特化しており、レベルの高い問題は「さんすうがく」のサイトで無料で提供しています。
+
+[CHUNK]
+## 追加問題と問題1: 旅人算
+基本問題に特化しており、レベルの高い問題は「さんすうがく」のサイトで無料で提供しています。
+**問題1**: 8km離れたA町とB町から太郎くんと次郎くんがそれぞれ分速50m、分速100mの速さで向かい合って同時に出発。出会うのは何分後か。
+
+[CHUNK]
+## 問題2と3: 反対方向へ進む場合と追いつき問題
+**問題1**: 8km離れたA町とB町から太郎くんと次郎くんがそれぞれ分速50m、分速100mの速さで向かい合って同時に出発。出会うのは何分後か。
+**問題2**: 周囲480mの池を兄弟が反対方向に進む。兄は分速80m、弟は分速40m。何分後に出会うか。
+**問題3**: 弟が家を出て10分後、兄が自転車で追う。弟は毎分70m、兄は分速170m。兄は何分後に追いつくか。
+
+[CHUNK]
+## 問題4と5: 池の周回と追いつき問題
+**問題3**: 弟が家を出て10分後、兄が自転車で追う。弟は毎分70m、兄は分速170m。兄は何分後に追いつくか。
+**問題4**: 周囲3600mの池をA,B,Cが周回。Aは毎分120m、Bは毎分90m、Cは毎分60m。AがCと出会い引き返すとBと何分後に出会うか。
+**問題5**: 弟が毎分80mで出発後、25分後に兄が毎分180mで追う。兄は何分後に追いつくか。
+
+[CHUNK]
+## 問題6と7: 池の周回と速さの比
+**問題5**: 弟が毎分80mで出発後、25分後に兄が毎分180mで追う。兄は何分後に追いつくか。
+**問題6**: 周囲500mの池をAとBが反対/同じ方向に回る。反対方向では50秒、同じ方向では125秒で出会う。それぞれの速さは。
+**問題7**: 64km離れたP,Q間をA,Bが往復。4時間後に出会い、Aは2時間24分後にQに着く。速さの比とBの速さを求めよ。
+
+[CHUNK]
+## 問題8と9: 家からの出発と追いつき問題
+**問題7**: 64km離れたP,Q間をA,Bが往復。4時間後に出会い、Aは2時間24分後にQに着く。速さの比とBの速さを求めよ。
+**問題8**: 3.2km離れたA,Bの家。Bが7時に出発し、Aが7時2分に出発。Aは毎分50m、Bは毎分100m。何分後に出会うか。
+**問題9**: 兄は毎分75m、弟は毎分55m。弟は9時に出発、兄は9時4分に出発。兄は何分後に追いつくか。
+
+[CHUNK]
+## 問題10と11: 池の周回と出会い時間
+**問題9**: 兄は毎分75m、弟は毎分55m。弟は9時に出発、兄は9時4分に出発。兄は何分後に追いつくか。
+**問題10**: 周囲1800mの池をA,Bが周回。同じ方向に3時間後、反対方向に30分後に出会う。A,Bそれぞれの速さは。
+**問題11**: Aは30分、Bは20分で池を一周。反対方向に進むと何分後に出会うか。
+
+[CHUNK]
+## 問題12と13: ロケットと新幹線
+**問題11**: Aは30分、Bは20分で池を一周。反対方向に進むと何分後に出会うか。
+**問題12**: 秒速25.2kmのロケットが1分20秒で進む距離を、時速168kmの新幹線は何時間かかるか。
+**問題13**: 6kmの坂道、行きは毎時6km、帰りは毎時12km。往復の平均速度は。
+
+[CHUNK]
+## 問題14と15: 速さの変化と出会い
+**問題13**: 6kmの坂道、行きは毎時6km、帰りは毎時12km。往復の平均速度は。
+**問題14**: 2.1kmの道のりを、最初は毎分50m、途中から毎分70mで歩き34分。速さを変えたのは何分後か。
+**問題15**: 1km離れたA,Bを太郎は分速45m、次郎は分速80mで出発。どこで出会うか。
+
+[CHUNK]
+## 問題16と17: 追いつきと往復運動
+**問題15**: 1km離れたA,Bを太郎は分速45m、次郎は分速80mで出発。どこで出会うか。
+**問題16**: Aが分速64mで出発後、Bが分速80mで追う。何分後に追いつくか。
+**問題17**: 1.2km離れたA,B間をA君は分速70m、B君は分速50mで往復。2回目に出会うのは何分後か。
+
+[CHUNK]
+## 問題18と19: 遅れて出発と競争
+**問題17**: 1.2km離れたA,B間をA君は分速70m、B君は分速50mで往復。2回目に出会うのは何分後か。
+**問題18**: Aは分速150mで出発後、忘れ物に気づいたBが車で追う。Bが出発して9分後に出会う。Bは何分後に出発したか。
+**問題19**: 100m走で兄は18秒、妹は20秒。50m走で兄がゴール時、妹は何m後ろか。
+
+[CHUNK]
+## 問題20: 一定速度と出会い
+**問題19**: 100m走で兄は18秒、妹は20秒。50m走で兄がゴール時、妹は何m後ろか。
+**問題20**: Q,R間でA,Bが一定速度で出発。20分後に出会い、Aは16分後にRに着く。Bは出発から何分後にQに着くか。
+
+# 速さに関する問題集
+
+[CHUNK]
+## A君とB君の速さの比
+
+A君が4歩あるく間にB君は7歩あるきます。またA君が3歩であるくきょりをB君は6歩で歩きます。A君とB君の速さの比を求めなさい。A君の歩数比と距離比から速さの比を算出。A君の4歩はB君の7歩に相当し、A君の3歩の距離はB君の6歩に相当。速さの比は歩数比と距離比の積で計算。
+
+[CHUNK]
+## 水夫の川下り・川上り問題
+
+ある水夫が 35km あるところを5時間で下りました。同じところを上るのに7時間かかりました。次の問いに答えなさい。(1) 上りの速さは毎時何kmですか。(2) 下りの速さは毎時何kmですか。下りと上りの時間と距離からそれぞれの速さを計算。下りは5時間で35kmなので、速さは35km/5h。上りは7時間で35kmなので、速さは35km/7h。
+
+[CHUNK]
+## 川を往復する船の問題
+
+ある川に沿って33km はなれたP町、Q町があります。この間をA、Bの2せきの船が往復しています。Aの船は上りに11時間かかり、下りに3時間かかります。またBの船は6時間かかって上ります。(1)Aの船の上り、下りの速さはそれぞれ毎時何km ですか。(2) 川の速さは毎時何kmですか。(3)Bの船の上りの速さは、毎時何km ですか。(4)Bの船は PQ 町を下るのに何時間かかりますか。A船の上り下りの時間と距離から速さを計算し、川の速さを求める。B船の上り時間から速さを計算し、川の速さを用いて下り時間を求める。
+
+[CHUNK]
+## 水夫の川往復問題と流速の計算
+
+A、Bの2人の水夫がいます。長さが90kmの川を往復するのにAは上りに15時間かかり、下りに9時間かかりました。Bは上りに18時間かかりました。(1) この川の流速は毎時何km ですか。(2)Aの静水時の速さは毎時何kmですか。(3)Bの下りの速さは毎時何kmですか。(4) この川をBが下るには何時間かかりますか。Aの上り下りの時間と距離から、流速と静水時の速さを計算。Bの上り時間と流速から、Bの静水時の速さと下り時間を計算。
+
+[CHUNK]
+## 船の川上り・川下り問題と流速・静水時の速さの計算
+
+ある船が川を 144km 上るのに12時間かかり、下るのに8時間かかりました。以下の問いに答えなさい。(1) この川の流れの速さは毎時何kmですか。(2) 船の静水時の速さは毎時何kmですか。上りと下りの時間と距離から、それぞれの速さを計算。流速と静水時の速さを連立方程式で求める。上りの速さ=静水時の速さ-流速、下りの速さ=静水時の速さ+流速。
+
+[CHUNK]
+## 静水をこぐ人の速さと川の流れの問題
+
+静水をこぐ速さが毎時10.5kmの人が3時間で36km こぎおりました。このとき、以下の問いに答えなさい。(1) 流れの速さは、毎時何kmですか。(2) 上りの速さは、毎時何km ですか。(3)この川を5時間かけて上ると何km進みますか。下りの速さと時間から、流れの速さを計算。静水時の速さから流れの速��を引いて、上りの速さを計算。上りの速さと時間から、上る距離を計算。
+
+[CHUNK]
+## 川の流れと船の速度に関する問題
+
+流れの速さが毎時3kmの川を、60kmこぎ上るのに10時間かかりました。この川を 24km こぎ下りるのに何時間かかりますか。上りの速さと流れの速さから、静水時の速さを計算。静水時の速さと流れの速さから、下りの速さを計算。下りの速さと距離から、下る時間を計算。
+
+[CHUNK]
+## 川の流れと船の速度に関する問題2
+
+ある船が70kmの川を上るのに7時間かかり、同じところを下るのに2時間20分かかりました。以下の問いに答えなさい。(1) この船の下りの速さは毎時何kmですか。(2)この川の流速は船の静水時の速さの何倍ですか。上りと下りの時間と距離から、それぞれの速さを計算。流速と静水時の速さを求め、流速が静水時の速さの何倍かを計算。
+
+[CHUNK]
+## プールの流水問題
+
+1周280mのプールでAは流れと同じ向きに泳いで1周すると3分30秒かかり、流れと反対方向に泳いで1周すると4分40秒かかります。このときAが静水時に進む速さは毎分何mですか。流れに沿った時と逆らった時の時間から、Aの速さと流れの速さを計算。Aの静水時の速さを求める。
+
+[CHUNK]
+## 静水時の船の速さと川の流れの問題
+
+静水では毎時12km で走る船Aと、毎時16kmで走る船Bがあります。川の下流から上流まで走るとき、Aは10時間、Bは6時間40分かかります。川の流れは毎時何kmですか。AとBの上りの時間と静水時の速さから、川の流れの速さを計算。AとBの速さの差と時間の差から、川の流れを求める。
+
+[CHUNK]
+## プールでの流水とうき輪の問題
+
+一定の速さで水が流れている1周240mのプールがあります。Aはスタートの位置から水の流れに乗って泳ぎ始めます。それと同時にスタートした位置からうき輪を流したところ、ちょうどAが3周進んだときにうき輪に追いつきました。またAが流れに逆らって泳いだところ、1周泳ぐのに12分かかりました。このとき、以下の問いに答えなさい。ただしAの静水時の速さは一定であるとします。(1) プールの水の流れる速さは毎分何mですか。(2)Aが流れに乗って泳いだとき、1周するのにかかる時間は何分ですか。Aが流れに逆らって泳いだ時間から、Aの静水時の速さを計算。Aが3周泳いだ時間とうき輪が流れた時間が等しいことから、水の流れる速さを計算。Aが流れに乗って泳いだ時の速さから、1周する時間を計算。
+
+[CHUNK]
+## 川下りと上りの時間変化問題
+
+ある船が 105kmの川を下るのに7時間かかりました。元のところへもどるとき、流れの速さが2倍になったので、11時間40分かかりました。(1) この船の下りの速さは毎時何kmですか。(2) 流速が2倍になった時の上りの速さは毎時何kmですか。(3) この船の静水時のときの速さは毎時何km ですか。下りの時間と距離から、下りの速さを計算。流れの速さが2倍になった時の上りの時間から、上りの速さを計算。静水時の速さと流れの速さを求める。
+
+[CHUNK]
+## 川の上り下り問題と流水変化
+
+川に沿って 27km はなれてP町、Q町があります。ある船がQ町を出発してP町まで上るのに4時間半かかり、下る時は流水が2倍になったので1時間で下りました。この船の静水時の速さは毎時何km ですか。上りと下りの時間と距離から、上りと下りの速さを計算。流水が2倍になった時の下りの速さから、流水の速さを計算。静水時の速さを求める。
+
+[CHUNK]
+## 川の流れと船の速度変化問題
+
+ある船が川を 48km 下ったところ8時間かかりました。その後、流速が下るときの2倍になったため同じところを上るのに下った時の2倍の時間がかかりました。この船の静水時の速さは毎時何kmですか。下りの時間と距離から、下りの速さを計算。流速が2倍になった時の上りの時間から、上りの速さを計算。静水時の速さを求める。
+
+[CHUNK]
+## 川の上り下り問題と流速変化
+
+川にそって39km はなれたP町とQ町があります。ある船がQ町を出発してP町まで上るのに13時間かかり、下る時は流速が上りのときの4倍になったので3時間で下ることができました。この船の静水時の速さは毎時何kmですか。上りの時間と距離から、上りの速さを計算。流速が4倍になった時の下りの時間から、下りの速さを計算。静水時の速さを求める。
+
+[CHUNK]
+## 川の往復問���
+
+ある船が川上にあるP町とそこから 45km はなれたQ町を往復するのに、上りは9時間、下りは5時間かかりました。(1) 上りの速さは毎時何kmですか。(2) 下りの速さは毎時何kmですか。(3) 船が静水を進むときの速さは毎時何kmですか。上りと下りの時間と距離から、それぞれの速さを計算。静水時の速さを求める。
+
+[CHUNK]
+## 川の上り下り問題と静水時の速さ
+
+ある船が川上にあるA町とそこから 135km はなれたB町の間を往復するのに、上りは15時間、下りは5時間かかります。(1) 上りの速さは毎時何kmですか。(2) 下りの速さは毎時何km ですか。(3) 船の静水時のときの速さは毎時何km ですか。上りと下りの時間と距離から、それぞれの速さを計算。静水時の速さを求める。
+
+[CHUNK]
+## 船の出会い問題
+
+静水時の速さが毎時4kmの船A、毎時7kmの船Bがあります。55km はなれた川上のP町をA船が、川下のQ町をB船が向かい合って同時に進みます。A、B両船は出発してから何時間何分後に出会いますか。AとBの速さの和から、出会うまでの時間を計算。
+
+[CHUNK]
+## 船の追いつき問題
+
+A、Bの2せきの船があります。静水を進む速さはAは毎時40km、Bは毎時20kmです。今 240kmの川を同時にAは川上から、Bは下流の川下から向かい合って進みます。Bはと中で出会った後、16時間たってAの出発地点にとう着することができました。この川の流速は毎時何kmですか。AとBの速さの和から出会うまでの距離を計算。Aが出発地点に戻るまでの時間と距離から、川の流速を計算。
+
+[CHUNK]
+## 川の流れと船の速度問題
+
+流水の速さが一定の川があります。この川を静水時の速さが一定の船が往復するとき、上りの速さは毎時20km、下りの速さが28km でした。(1) この川の流れの速さは毎時何kmですか。(2) この船の静水時の速さは毎時何kmですか。上りと下りの速さから、川の流れの速さと船の静水時の速さを計算。
+
+[CHUNK]
+## 流水の速さが変化する川の問題
+
+流水の速さが一定の川があります。この川を静水時の速さが一定の船が往復するとき、上りの速さは毎時24km、下るときは川の速さが5倍になったので、速さが毎時42kmになりました。(1) この川の速さは毎時何kmですか。(2) この船の静水時の速さは、毎時何kmですか。上りと下りの速さから、川の流れの速さと船の静水時の速さを計算。
+
+[CHUNK]
+## プールでの速度問題
+
+(1) プールで毎分 75mの速さで泳ぐ人が、毎分15mの速さで流れるプールの上流に向かって120m泳ぐには、何分かかりますか。(2) 20m先のプールサイドを歩いているBくんが毎分30mで歩いているとき、Aくんが泳いでBくんに追いつくのは何秒後ですか。ただし、A君はプールと反対向きで進むとします。Aが上流に向かって泳ぐ速さから、120m泳ぐ時間を計算。AとBの速さの差から、追いつくまでの時間を計算。
+
+[CHUNK]
+## 静水時の速さが一定の船の問題
+
+ある川を静水時の速さが一定の船で80km 下るのに5時間、20km 上るのに2時間半かかりました。この川の流れの速さは毎時何kmですか。下りと上りの時間と距離から、それぞれの速さを計算。川の流れの速さを計算。
+
+[CHUNK]
+## 川下り問題
+
+ある船が105kmの川を下るのに7時間かかりました。元のところへもどるとき、流れの速さが2倍になったので、11時間40分かかりました。(1) この船の下りの速さは毎時何kmですか。(2) 流速が2倍になった時の上りの速さは毎時何kmですか。(3) この船の静水時の速さは毎時何kmですか。下りの時間と距離から、下りの速さを計算。流れの速さが2倍になった時の上りの時間から、上りの速さを計算。静水時の速さと流れの速さを求める。
+
+[CHUNK]
+## 列車のトンネル通過問題
+
+ある列車は 840mのトンネルをぬけるのに60秒かかり、466mの橋をわたるのに38秒かかります。列車の長さは何mですか。トンネル通過と橋の通過の時間差から、列車の速さを計算。列車の速さと時間から、列車の長さを計算。
+
+[CHUNK]
+## 列車の速度問題
+
+長さ450m の列車が、線路ぎわに立っている人の前を9秒で通過しました。この列車の速さは毎時何kmですか。列車の長さと時間から、列車の速さを計算。単位を変換して、毎時何kmで表す。
+
+[CHUNK]
+## 列車のトンネル通過問題2
+
+一定の速さで走る列車が長さ700mのトンネルを32秒で、電柱の前を4秒で、それぞれ通過しまし��。この列車の長さは何mですか。電柱の前を通過する時間から、列車の速さを計算。列車の速さとトンネル通過時間から、列車の長さを計算。
+
+[CHUNK]
+## 列車のトンネル通過問題3
+
+長さ120m、時速48.6kmの列車がトンネルに入ってから、列車は40秒間トンネルに完全にかくれていました。このトンネルの長さは何mですか。列車の速さを秒速に変換。トンネルにかくれている時間と列車の速さから、トンネルの長さを計算。
+
+[CHUNK]
+## 列車のすれ違い問題
+
+長さ120m、時速180kmのA列車と、長さ210m、時速216kmのB列車が、出会ってからすれちがい終わるまでに何秒かかりますか。AとBの速さの和を計算。AとBの長さの和を計算。速さと距離から、すれ違いにかかる時間を計算。
+
+[CHUNK]
+## 列車の追い越し問題
+
+時速108kmと時速72km で走る電車があります。この列車がそれぞれ反対方向に走るとすれちがうのに10秒かかります。この列車が同じ向きに走ったとき、早い方の列車がおそい方の列車を追いぬくのに何秒かかりますか。すれ違う時間と速さから、列車の長さを計算。同じ向きに走る時の速さの差から、追い抜く時間を計算。
+
+[CHUNK]
+## 列車の追い越し問題2
+
+長さ150m、時速90kmのA列車が、長さ120mのB列車に追いついてから追いこし終わるまでに30秒かかりました。B列車の速さは毎時何kmですか。AとBの長さの和を計算。AとBの速さの差を計算。速さの差と時間から、Bの速さを計算。
+
+[CHUNK]
+## 列車のトンネル通過と追い越し問題
+
+速さが19秒で長さが300mの長きょり列車A、速さ毎秒16m で長さ 360mの長きょり列車Bがあります。以下の問いに答えなさい。(1) 列車Aがトンネルを通り抜けるのに12分かかりました。トンネルの長さは何m ですか。(2) 列車Aが列車Bに追いついてから追いこすまでに何秒かかりますか。Aの速さと時間から、トンネルの長さを計算。AとBの速さの差から、追い越す時間を計算。
+
+[CHUNK]
+## 電車の通過問題
+
+長さ 500m の電車が秒速20mで走っています。以下の問いに答えなさい。(1) この電車がふみきりで待っている太郎くんの前を通過し始めてから通過し終わるまでに何秒かかりますか。(2) この電車が長さ300m の橋をわたり始めてからわたり終わるまでに何秒かかりますか。電車の長さと速さから、太郎くんの前を通過する時間を計算。電車の長さと橋の長さを足し、速さから通過時間を計算。
+
+[CHUNK]
+## 時計の角度問題
+
+7時51分のとき、時計の長針と短針がつくる小さい方の角度の大きさは何度ですか。7時51分における長針と短針の位置を計算し、角度を求める。
+
+[CHUNK]
+## 時計の重なり問題
+
+4時と5時の間で、時計の長針と短針が重なる時刻は4時何分ですか。長針と短針の速さの差から、重なる時間を計算。
+
+[CHUNK]
+## 時計の角度問題2
+
+3時と4時の間で、長針と短針の作る角度が30度になる時はそれぞれ3時何分ですか。長針と短針の速さの差から、30度になる時間を計算。
+
+[CHUNK]
+## 特殊な時計の問題
+
+ある特別な時計は長針が30秒で1周、短針が2分で1周します。今、長身と短針が反対方向をさして一直線になっています。時計の長針と短針が最初に重なるのは今から何秒後ですか。長針と短針の速さの差から、重なる時間を計算。
+
+[CHUNK]
+## 時計の直角問題
+
+10時と11時の間で、時計の長針と短針のつくる角が直角になることがあります。2回目に直角になるのは10時何分ですか。長針と短針の速さの差から、直角になる時間を計算。
+
+[CHUNK]
+## 時計の重なり問題3
+
+時計の長針と短針が2時と3時の間でちょうど重なっています。このとき、以下の問いに答えなさい。(1) このときの時間は2時何分ですか。(2) その後長針と短針が文字ばんのめもりの6をはさんで等しい角度になっている時刻は2時何分ですか。長針と短針の速さの差から、重なる時間を計算。長針と短針が反対側になる時間を計算。
+
+[CHUNK]
+## 時計の角度問題4
+
+時計の針が5時10分をさしています。このとき、以下の問いに答えなさい。(1) 長針と短針が作る角度で小さいものは何度ですか。(2) 長針が短針を追いこしてから作る角度が90度となるのは5時何分ですか。5時10分における長針と短針の位置を計算し、角度を求める。長針が短針を追い越してから90度になる時間を計算。
+
+# 速さ編ドリル
+
+[CHUNK]
+## 太郎と次郎の出会い：8kmを分速50mと100mで向かい合う
+8km離れたA町とB町から太郎と次郎がそれぞれ分速50m、100mで向かい合って出発。出会うまでの時間を求める。単位をmに統一し、8km=8100mとする。2人は1分で150m近づくため、8100m÷150m/分=54分後に出会う。面積図による解法も参照。
+
+[CHUNK]
+## 池の周回：480mの池を反対方向に進む兄弟の出会い
+周囲480mの池を兄弟が反対方向に進む。兄は分速80m、弟は分速40m。出会うまでの時間を求める。2人は1分で120m近づくため、480m÷120m/分=4分後に出会う。池を円で図示し、反対方向の矢印で示す。面積図による解法も参照。
+
+[CHUNK]
+## 弟を追う兄：10分後に自転車で出発、追いつくまでの時間
+弟が家を出て10分後、兄が自転車で追いかける。弟は分速70m、兄は分速170m。兄が出発して追いつくまでの時間を求める。弟は10分で700m進む。兄は毎分100mずつ近づくので、700m÷100m/分=7分後。線分図で距離と速さを視覚化。
+
+[CHUNK]
+## 周回池：A,B,Cが反対方向に進む、AとCが出会った後AがBに出会う時間
+周囲3600mの池をA,B,Cが周回。Aは毎分120m、Bは毎分90m、Cは毎分60m。AがCと出会い、その後AがBに出会うまでの時間を求める。AとCは20分後に出会う。AとBは20分で600m離れる。AがBに向かうと毎分210m近づくので、600m÷210m/分=20/7分後。円で図示し、各人物の速度と方向を示す。
+
+[CHUNK]
+## 兄が弟を追う：25分後に出発、追いつくまでの時間
+弟が毎分80mで出発後、25分後に兄が毎分180mで追いかける。兄が追いつくまでの時間を求める。弟は25分で2000m進む。兄は毎分100mずつ近づくので、2000m÷100m/分=20分後。線分図で距離と速さを視覚化。
+
+[CHUNK]
+## 池の周回：AとBが反対/同じ方向に進む速さを求める
+1周500mの池をAとBが周回。反対方向では50秒、同じ方向では125秒で出会う。AとBの速さを求める。反対方向ではA+B、同じ方向ではA-Bの速さで計算。A+B=10m/秒、A-B=4m/秒。A=7m/秒、B=3m/秒。円で図示し、各人物の速度と方向を示す。
+
+[CHUNK]
+## 2地点間の移動：AとBの速さの比とBの速さを求める
+64km離れたP,Q間をAとBが移動。AはPからQへ、BはQからPへ。4時間後に出会い、Aはその後2時間24分でQに到着。AとBの速さの比とBの速さを求める。A:B=5:3、B=6km/時。線分図で距離と時間を視覚化。
+
+[CHUNK]
+## 家から家へ：AとBが出発、出会うまでの時間を求める
+AとBの家は3.2km離れている。Bは7時に出発、Aは7時2分に出発。Aは毎分50m、Bは毎分100m。出会うまでの時間を求める。Bは2分で200m進む。残りは3000m。2人は毎分150m近づくので、3000m÷150m/分=20分後。線分図で距離と時間を視覚化。
+
+[CHUNK]
+## 弟を追う兄：4分後に出発、追いつくまでの時間を求める
+弟は毎分75m、兄は毎分55mで歩く。弟は9時に出発、兄は9時4分に出発。兄が出発して追いつくまでの時間を求める。弟は4分で220m進む。兄は毎分20mずつ近づくので、220m÷20m/分=11分後。線分図で距離と時間を視覚化。
+
+[CHUNK]
+## 池の周回：AとBが同じ/反対方向に進む速さを求める
+周囲1800mの池をAとBが周回。同じ方向では3時間、反対方向では30分で出会う。AとBの速さを求める。同じ方向ではA-B、反対方向ではA+Bの速さで計算。A-B=10m/分、A+B=60m/分。A=35m/分、B=25m/分。円で図示し、各人物の速度と方向を示す。
+
+# 速さ編ドリル - RAG最適化
+
+[CHUNK]
+## 池の周回：反対方向への進行と出会い
+ある池をAは30分、Bは20分で一周する。AとBが反対方向に進むとき、出会うまでの時間は？解答は12分。池の周りの長さもAとBの速さも不明なため、「仮定」を利用。池の周りを30と20の最小公倍数60と仮定。Aの速さは60÷30=2/分、Bは60÷20=3/分。反対方向なので、近づく速さは2+3=5/分。出会う時間は60÷5=12分。
+
+[CHUNK]
+## 池の周回：反対方向への進行と出会い(重複)
+解答は12分。池の周りの長さもAとBの速さも不明なため、「仮定」を利用。池の周りを30と20の最小公倍数60と仮定。Aの速さは60÷30=2/分、Bは60÷20=3/分。反対方向なので、近づく速さは2+3=5/分。出会う時間は60÷5=12分。最小公倍数で仮定すると計算が容易。
+
+[CHUNK]
+## ロケットと新幹線：時間計算
+秒速25.2kmのロケットが1分20秒で進む距離を、時速168kmの新幹線で移動するのにかかる時間は？解答は12時間。秒速25.2kmは1秒で25.2km進む速さ。1分20秒は80秒。ロケットは80秒で25.2km/秒×80秒=2016km進む。新幹線は時速168kmなの��、2016km÷168km/時=12時間。
+
+[CHUNK]
+## ロケットと新幹線：時間計算(重複)
+解答は12時間。秒速25.2kmは1秒で25.2km進む速さ。1分20秒は80秒。ロケットは80秒で25.2km/秒×80秒=2016km進む。新幹線は時速168kmなので、2016km÷168km/時=12時間。計算ミスを防ぐため単位を秒に統一。面積図で視覚的に理解。
+
+[CHUNK]
+## 坂道の往復：平均速度の計算
+6kmの坂道、行きは毎時6km、帰りは毎時12kmの速さで往復。往復の平均速度は何km/時？解答は8km/時。往復の平均速度を求めるには、合計距離と合計時間が必要。距離の合計は6km×2=12km。行きは6km÷6km/時=1時間、帰りは6km÷12km/時=0.5時間。合計時間は1+0.5=1.5時間。平均速度は12km÷1.5時間=8km/時。
+
+[CHUNK]
+## 坂道の往復：平均速度の計算(重複)
+解答は8km/時。往復の平均速度を求めるには、合計距離と合計時間が必要。距離の合計は6km×2=12km。行きは6km÷6km/時=1時間、帰りは6km÷12km/時=0.5時間。合計時間は1+0.5=1.5時間。平均速度は12km÷1.5時間=8km/時。単位を時間で統一。面積図で視覚的に理解。
+
+[CHUNK]
+## 距離と速さ：速度変化時の時間計算
+2.1kmの道のり、最初は毎分50m、途中から毎分70mで歩き、合計34分。速さを変えたのは何分後？解答は14分後。50m/分で進む時間を○分、70m/分で進む時間を□分と仮定。合計距離は2100m。緑の四角形は70m/分で34分進んだ距離=2380m。青の四角形の面積は2380m-2100m=280m。
+
+[CHUNK]
+## 距離と速さ：速度変化時の時間計算(重複)
+解答は14分後。50m/分で進む時間を○分、70m/分で進む時間を□分と仮定。合計距離は2100m。緑の四角形は70m/分で34分進んだ距離=2380m。青の四角形の面積は2380m-2100m=280m。青の四角形の縦は70m/分-50m/分=20m/分。横(時間)は280m÷20m/分=14分。
+
+[CHUNK]
+## 向かい合う移動：出会う場所の特定
+1km離れたA,B地点間を、太郎は分速45mでAから、次郎は分速80mでBから同時に出発。出会うのはAから何m？解答は360m。二人の距離と速さを線分図で示す。単位をmに統一。二人が近づく速さは45m/分+80m/分=125m/分。出会うまでの時間は1000m÷125m/分=8分。
+
+[CHUNK]
+## 向かい合う移動：出会う場所の特定(重複)
+解答は360m。二人の距離と速さを線分図で示す。単位をmに統一。二人が近づく速さは45m/分+80m/分=125m/分。出会うまでの時間は1000m÷125m/分=8分。太郎はAから45m/分×8分=360m進んだ地点で出会う。速さの単位を揃えることが重要。
+
+[CHUNK]
+## 追いかけ：追いつく時間
+Aが分速64mで出発してから8分後、Bが分速80mでAを追跡。Aは出発から何分後に追いつかれる？解答は40分後。AとBの出発時間のずれを考慮。Aが8分で進んだ距離は64m/分×8分=512m。BがAに近づく速さは80m/分-64m/分=16m/分。Bが追いつくまでの時間は512m÷16m/分=32分。
+
+[CHUNK]
+## 追いかけ：追いつく時間(重複)
+解答は40分後。Aが8分で進んだ距離は64m/分×8分=512m。BがAに近づく速さは80m/分-64m/分=16m/分。Bが追いつくまでの時間は512m÷16m/分=32分。Aが出発してから追いつかれるまでの時間は32分+8分=40分。問題文をよく読み、問われていることを正確に把握。
+
+[CHUNK]
+## 往復運動：2回目の出会い
+1.2km離れたA,B間をA君は分速70mでPから、B君は分速50mでQから向かい合って出発しPQ間を往復。2回目の出会いは何分後？解答は30分後。1.2km=1200m。1回目に出会うまでの時間は1200m÷(70m/分+50m/分)=10分。
+
+[CHUNK]
+## 往復運動：2回目の出会い(重複)
+解答は30分後。1.2km=1200m。1回目に出会うまでの時間は1200m÷(70m/分+50m/分)=10分。2回目に出会うまでに2人は合計1200m×2=2400m多く進む必要。2400m÷120m/分=20分。2回目の出会いは10分+20分=30分後。
+
+[CHUNK]
+## 自転車と車：追いつく時間
+Aは分速150mで自転車、Bは時速30kmの車でAを追う。BはAの何分後に出発？B出発9分後に追いつく。解答は21分後。速さの単位を統一。30km/時=500m/分。Bが9分で進む距離は500m/分×9分=4500m。
+
+[CHUNK]
+## 自転車と車：追いつく時間(重複)
+解答は21分後。速さの単位を統一。30km/時=500m/分。Bが9分で進む距離は500m/分×9分=4500m。Aが4500m進む時間は4500m÷150m/分=30分。BはAより30分-9分=21分遅れて出発。線分図で視覚的に理解。
+
+[CHUNK]
+## 短距離走：ゴール時の距離差
+100m走、兄18秒、妹20秒。50m走で兄がゴール時、妹は何m後方？解答は5m。距離を半分にすると時間も半分。兄は50mを9秒、妹は10秒。兄がゴール時、妹はあと1秒。妹は20秒で100m、1秒で5m。
+
+[CHUNK]
+## 短距離走：���ール時の距離差(重複)
+解答は5m。距離を半分にすると時間も半分。兄は50mを9秒、妹は10秒。兄がゴール時、妹はあと1秒。妹は20秒で100m、1秒で5m。兄ゴール時、妹は5m後方。工夫して計算量を削減。
+
+[CHUNK]
+## 向かい合う移動：出会いと到達
+Q,R間でA,Bが向かい合い出発、20分後に出会い、Aは16分後にR着。Bは出発から何分後にQ着？解答は25分後。Bが20分で進む距離=Aが16分で進む距離。Bの速さを4/分と仮定。Aの速さは(4/分*20分)/16分=5/分。
+
+[CHUNK]
+## 向かい合う移動：出会いと到達(重複)
+解答は25分後。Bが20分で進む距離=Aが16分で進む距離。Bの速さを4/分と仮定。Aの速さは(4/分*20分)/16分=5/分。Aが20分で進む距離は5/分*20分=100。BがQに着くまでの時間は100/(4/分)=25分。
+
+# 速さに関する問題集
+
+[CHUNK]
+## A君とB君の速さの比を求める問題
+A君が4歩あるく間にB君は7歩あるきます。またA君が3歩である距離をB君は6歩で歩きます。A君とB君の速さの比を求めます。A君が4歩あるく時間を28と仮定すると、A君、B君それぞれの1歩あるく時間の比は7:4。ふたりの進む距離を6として、線分図を書くとふたりの歩幅の比は、2:1。A君とB君の速さの比は7×2:4×1=14:4=7:2。
+
+[CHUNK]
+## A君とB君の速さの比
+A君とB君の速さの比は1歩あるく時間の比×歩幅の比で求める。A君が4歩あるく時間を28と仮定すると、A君、B君それぞれの1歩あるく時間の比は7:4。ふたりの進む距離を6として、線分図を書くとふたりの歩幅の比は、2:1。A君とB君の速さの比は7×2:4×1=14:4=7:2。
+
+[CHUNK]
+## 川の流れに乗る船の速さに関する問題
+ある水夫が35km あるところを5時間で下りました。同じところを上るのに7時間かかりました。上りの速さ、下りの速さ、川の速さ、船の静水時の速さを求めます。上りは7時間かかるので、35km÷7時間=5km/時。下りは5時間なので、35km÷5時間=7km/時。速さの線分図より、川の速さは1km/時、船の静水時の速さは6km/時。
+
+[CHUNK]
+## 川の流れに乗る船の速さ
+川の流れに乗る船の速さは、川の速さについても考える必要。川上に進むときはゆっくり、川下に進むときは早くなる。35kmの道のりを7時間かけて進むので、上るときの速さは35km÷7時間=5km/時。同じように川を下るときの速さを計算すると、35km÷5時間=7km/時。速さの線分図より、川の速さは1km/時、船の静水時の速さは6km/時。
+
+[CHUNK]
+## 川を往復する船の速さに関する問題
+ある川に沿って33km離れたP町、Q町があります。この間をA、Bの2隻の船が往復。Aの船は上りに11時間、下りに3時間。Bの船は6時間かかって上ります。Aの船の上り、下りの速さ、川の速さ、Bの船の上りの速さ、Bの船の下りの速さを求めます。Aの上り3km/時、下り11km/時。川の速さは4km/時。Bの上り5.5km/時、下り13.5km/時。
+
+[CHUNK]
+## 川を往復する船の速さの計算
+33kmの川を上るまでに11時間かかっているので、33km÷11時間=3km/時。下るときは3時間なので、33km÷3時間=11km/時。川を上ったり下ったりする問題では川の速さを考える。川の速さを①とすると、②=8km/時。川の速さ×2=8km/時なので、川の速さは4km/時。Bの上るときに進む速さは33km÷6時間=5.5km/時。下りの速さは、5.5km/時+8km/時=13.5km/時。
+
+[CHUNK]
+## 川を往復する水夫の速さに関する問題
+A、Bの2人の水夫がいます。長さが90kmの川を往復するのにAは上りに15時間、下りに9時間。Bは上りに18時間かかりました。川の流速、Bの静水時の速さ、Bの下りの速さ、Bが下る時間を求めます。川の流速は2km/時、Bの静水時の速さは7km/時、Bの下りの速さは9km/時、Bが下る時間は10時間。
+
+[CHUNK]
+## 川を往復する水夫の速さの計算
+90kmの川を上るまでに15時間かかっているので、90km÷15時間=6km/時。下るときは9時間なので、90km÷9時間=10km/時。川を上ったり下ったりする問題では川の速さを考える。川の速さ×2=4km/時なので、川の速さは2km/時。Bが上るときの速さは90km÷18時間=5km/時。Bの静水時の速さは5km/時+2km/時=7km/時。Bの下るときの速さは7km/時+2km/時=9km/時。Bが下る時間は90km÷9km/時=10時間。
+
+[CHUNK]
+## 川を上り下りする船の問題
+ある船が川を144km上るのに12時間かかり、下るのに8時間かかりました。川の流れの速さと船の静水時の速さを求めます。川の流れの速さは3km/時、船の静水時の速さは15km/時。
+
+[CHUNK]
+## 川を上り下りする船の速さの計算
+川の長さ、上���までの時間、下るまでの時間が分かっているので、上るときの速さと下るときの速さを求める。144km÷12時間=12km/時(上るときの速さ)、144km÷8時間=14km/時(下るときの速さ)。上るときの速さと下るときの速さが分かったら、「速さの線分図」を書く。川の速さを1として、計算する。川の速さを1と仮定すると2=4km/時を計算。よって川の速さの1は4km/時÷2=2km/時。下に進むときの速さ=静水時の速さ+川の速さなので、14km/時=静水時の速さ+2km/時。静水時の速さ=14km/時-2km/時となり、12km/時。
+
+[CHUNK]
+## 川をこぎおりる人の速さに関する問題
+静水をこぐ速さが毎時10.5kmの人が3時間で36kmこぎおりました。流れの速さ、上りの速さ、5時間かけて上ると何km進むかを求めます。流れの速さは1.5km/時、上りの速さは9km/時、5時間かけて上ると45km進む。
+
+[CHUNK]
+## 川をこぎおりる人の速さの計算
+静水時の速さが10.5km/時、3時間で36kmを下ったことが分かっているので、36km÷3時間=12km/時と下りの速さが12km/時とわかる。下に進むときの速さ=静水時の速さ+川の速さなので、下に進むときの速さ一静水時の速さ=川の速さと考えられる。よって川の速さは、12km/時-10.5km/時=1.5km/時。上に進むときの速さ=静水時の速さー川の速さなので、上に進むときの速さ=10.5km/時-1.5km/時となり、9km/時。上に進むときの速さ(9km/時)で5時間進むので進む距離は、9km/時×5時間=45km。
+
+[CHUNK]
+## 川をこぎ上る時間の問題
+流れの速さが毎時3kmの川を、60kmこぎ上るのに10時間かかりました。この川を24kmこぎ下りるのに何時間かかりますか。2時間。
+
+[CHUNK]
+## 川をこぎ上る時間の計算
+60kmの距離を10時間かけて上るので、60km÷10時間=6km/時。静水時の速さ=上るときの速さ+川の速さと考えることができるので、静水時の速さ=6km/時+3km/時で9km/時。下るときの速さ=静水時の速さ(9km/時)+川の速さ(3km/時)で12km/時と分かります。24km下るときの時間は、24km÷下るときの速さで求めることができるので、24km÷12km/時=2時間。
+
+[CHUNK]
+## 川を上る船の問題
+ある船が70kmの川を上るのに7時間かかり、同じところを下るのに2時間20分かかりました。船の下りの速さと川の流速は船の静水時の速さの何倍かを求めます。下りの速さは30km/時、川の流速は船の静水時の速さの1/2倍。
+
+[CHUNK]
+## 川を上る船の速さの計算
+70kmの道のりを2時間20分かけて下るので、70km÷7/3時間=70km×3/7時間で30km/時と計算。この船は70kmの道のりを上るのに7時間かけているので、70km÷7時間=10km/時。船が上に進むときの速さ=静水時の速さ―川の速さ、下に進むときの速さ=静水時の速さ+川の速さ。川の速さを①とすると、下に進むときの速さー上に進むときの速さ=2(川の速さ×2)となる。30km/時-10km/時=20km/時、20km/時=2(川の速さ×2)なので川の速さ=10km/時と分かります。静水時の速さは10km/時+10km/時=20km/時なので、川の速さ(10km/時)は静水時の速さ(20km/時)の1/2倍と求める。
+
+[CHUNK]
+## プールで泳ぐ速さの問題
+1周280mのプールでAは流れと同じ向きに泳いで1周すると3分30秒かかり、流れと反対方向に泳いで1周すると4分40秒かかります。Aが静水時に進む速さは毎分何mですか。70m/分。
+
+[CHUNK]
+## プールで泳ぐ速さの計算
+30秒=1/2分なので、3分30秒=3.5分となり、7/2分と書きかえる。280m÷7/2分=80m/分。40秒=2/3分となり、4分40秒=4と2/3分、14/3分と考える。280m÷14/3分=60m/分。流れと反対方向に進む速さ=静水時の速さーブールの速さ、流れと同じ方法に進む速さ=静水時の速さ+ブールの速さなので、プールの速さを1とすると、流れと同じ方法に進む速さー流れと反対方向に進む速さ=2(ブールの速さ×2)となる。80m/分-60m/分=2(ブールの速さ×2)なので2=20m/分。プールの速さは20m/分÷2=10m/分と計算。静水時の速さ=流れと反対方向に進む速さ+プールの速さで60m/分+10m/分=70m/分。
+
+[CHUNK]
+## 川を下流から上流へ走る船の問題
+静水では毎時12kmで走る船Aと、毎時16kmで走る船Bがあります。川の下流から上流まで走るとき、Aは10時間、Bは6時間40分かかります。川の流れは毎時何kmですか。4km/時。
+
+[CHUNK]
+## 川を下流から上流へ走る船の速さの計算
+40分=2/3時間と考えることができるので、上に上るときにかかる時間の比は10時間:6と2/3時間となり、10:20/3、両辺を×3して、30:20=3:2と求める。走る時間が短ければ短いほど、走る速さが���やいと考えることができる。静水時の速さが12km/時、16km/時と分かっているので、上るときの速さ=静水時の速さ―川の速さと仮定)なので、12km/時= 2+1、16km/時= 3+1と考える。3 - 2 = 1 がAとBの静水時の差の4km/時であることが分かります。16km/時(Bの静水時の速さ)-12km時の静水時の速さ)=4km/時。12km/時= 2 +1なので12km/時=8km/時+1となり、川の速さの1=4km/時。
+
+# 速さ編ドリル - 流水算
+
+[CHUNK]
+## 流水算の基本：一定速度のプールでのAと浮き輪の出会い
+一定速度で水が流れる1周240mのプールで、Aが流れに乗って泳ぎ始め、同時に浮き輪を流した。Aが3周したとき浮き輪に追いつき、流れに逆らうと1周12分かかる。プールの流速は毎分40mで、Aが流れに乗ると1周2分24秒。Aが3周進む時間とうき輪が2周する時間が同じであることに着目し、速さの比から流速を求める。
+
+[CHUNK]
+## プールの流速計算とAのラップタイム：流水算の応用
+Aが3周したとき浮き輪に追いつき、流れに逆らうと1周12分かかる。プールの流速は毎分40m。Aが流れに乗ると1周2分24秒。Aが3周進む時間とうき輪が2周する時間が同じであることに着目し、Aの静水時速さを計算。流れに乗った時の速さ(静水時+流速)で240mを割ることでラップタイムを算出。
+
+[CHUNK]
+## 川下りと上り：流速変化時の船の速さ計算
+ある船が105kmの川を下るのに7時間、元の場所に戻るのに流速が2倍になり11時間40分かかった。下りの速さは毎時15km、流速2倍時の上り速度は毎時9km、船の静水時速さは毎時13km。下りと上りの速さの差から流速を逆算し、静水時速さを求める。
+
+[CHUNK]
+## 流速変化時の船の速さ計算：上り下りの時間変化
+ある船が105kmの川を下るのに7時間かかりました。元のところへもどるとき、流れの速さが2倍になったので、11時間40分かかりました。下りの速さは毎時15km。上りの速さは毎時9km。静水時の速さは毎時13km。上りと下りの速さの差から流速の変化を捉え、静水時の速さを算出する。
+
+[CHUNK]
+## 川の上り下り：流速が変化するケース
+川に沿って27km離れたP町とQ町があり、ある船がQ町からP町へ上るのに4時間半、下る時は流速が2倍になり1時間で下った。船の静水時速さは毎時13km。上りと下りの時間からそれぞれの速さを計算し、流速の変化を考慮して静水時速さを求める。
+
+[CHUNK]
+## 流速変化時の静水時速さ：流水算の応用
+川に沿って27km離れたP町とQ町があり、ある船がQ町からP町へ上るのに4時間半、下る時は流速が2倍になり1時間で下った。船の静水時速さは毎時13km。上りと下りの速さの差から流速を計算し、静水時速さを求める。流速の変化を線分図で視覚化し、計算を簡略化。
+
+[CHUNK]
+## 川下り：流速が2倍になった場合の上り時間
+ある船が川を48km下るのに8時間、その後流速が2倍になり同じ距離を上るのに下りの2倍の時間がかかった。船の静水時速さは毎時5km。下りと上りの時間からそれぞれの速さを計算し、流速の変化を考慮して静水時速さを求める。
+
+[CHUNK]
+## 流速変化時の静水時速さ：上り下りの時間と速さ
+ある船が川を48km下るのに8時間、その後流速が2倍になり同じ距離を上るのに下りの2倍の時間がかかった。船の静水時速さは毎時5km。下りと上りの速さの差から流速を計算し、静水時速さを求める。流速の変化を線分図で視覚化し、計算を簡略化。
+
+[CHUNK]
+## 川の上り下り：流速が4倍になるケース
+川に沿って39km離れたP町とQ町があり、ある船がQ町からP町へ上るのに13時間、下る時は流速が上りの4倍になり3時間で下った。船の静水時速さは毎時5km。上りと下りの時間からそれぞれの速さを計算し、流速の変化を考慮して静水時速さを求める。
+
+[CHUNK]
+## 流速変化時の静水時速さ：流速4倍のケース
+川に沿って39km離れたP町とQ町があり、ある船がQ町からP町へ上るのに13時間、下る時は流速が上りの4倍になり3時間で下った。船の静水時速さは毎時5km。上りと下りの速さの差から流速を計算し、静水時速さを求める。流速の変化を線分図で視覚化し、計算を簡略化。
+
+[CHUNK]
+## 川の往復：上り下りの時間と速さから静水時速さを求める
+ある船が川上にあるP町とそこから45km離れたQ町を往復するのに、上りは9時間、下りは5時間かかった。上りの速さは毎時5km、下りの速さは毎時9km、船の静水時速さは毎時7km。上��と下りの時間からそれぞれの速さを計算し、静水時速さを求める。
+
+[CHUNK]
+## 上り下りの時間と速さ：静水時速さの計算
+ある船が川上にあるP町とそこから45km離れたQ町を往復するのに、上りは9時間、下りは5時間かかった。上りの速さは毎時5km、下りの速さは毎時9km、船の静水時速さは毎時7km。上りと下りの速さの差から流速を計算し、静水時速さを求める。流速の変化を線分図で視覚化し、計算を簡略化。
+
+[CHUNK]
+## 川の往復：上り下りの時間から静水時速さを算出
+ある船が川上にあるA町とそこから135km離れたB町の間を往復するのに、上りは15時間、下りは5時間かかった。上りの速さは毎時9km、下りの速さは毎時27km、船の静水時速さは毎時18km。上りと下りの時間からそれぞれの速さを計算し、静水時速さを求める。
+
+[CHUNK]
+## 上り下りの時間と速さ：静水時速さの計算と線分図
+ある船が川上にあるA町とそこから135km離れたB町の間を往復するのに、上りは15時間、下りは5時間かかった。上りの速さは毎時9km、下りの速さは毎時27km、船の静水時速さは毎時18km。上りと下りの速さの差から流速を計算し、静水時速さを求める。線分図で視覚化。
+
+[CHUNK]
+## 川での出会い：静水時速さが異なる2隻の船
+静水時速さが毎時4kmの船Aと毎時7kmの船Bが、55km離れた川上のP町と川下のQ町から向かい合って同時に進む。A、B両船は出発してから5時間後に出会う。2隻の船が近づく速さを計算し、出会うまでの時間を求める。
+
+[CHUNK]
+## 2隻の船の出会い：流水算と旅人算の融合
+静水時速さが毎時4kmの船Aと毎時7kmの船Bが、55km離れた川上のP町と川下のQ町から向かい合って同時に進む。A、B両船は出発してから5時間後に出会う。2隻の船の相対速度を計算し、出会うまでの時間を求める。川の流れを考慮した旅人算。
+
+[CHUNK]
+## 川での出会い：出会い後の時間経過
+静水時速さが毎時40kmの船Aと毎時20kmの船Bが、240kmの川を向かい合って進む。Bは出会った後、16時間たってAの出発地点に到着。川の流速は毎時8km。出会うまでの時間とBの速さから流速を計算。
+
+[CHUNK]
+## 出会い後の時間経過：流速の計算
+静水時速さが毎時40kmの船Aと毎時20kmの船Bが、240kmの川を向かい合って進む。Bは出会った後、16時間たってAの出発地点に到着。川の流速は毎時8km。出会うまでの時間とBの速さから流速を計算。線分図で視覚化。
+
+[CHUNK]
+## 流水の速さが一定の川：上り下りの速さから流速と静水時速さを求める
+流水の速さが一定の川で、静水時の速さが一定の船が往復する。上りの速さは毎時20km、下りの速さは毎時28km。川の流れの速さは毎時4km、船の静水時の速さは毎時24km。上りと下りの速さの差から流速を計算。
+
+[CHUNK]
+## 流水算：上り下りの速さから流速と静水時速さを計算
+流水の速さが一定の川で、静水時の速さが一定の船が往復する。上りの速さは毎時20km、下りの速さは毎時28km。川の流れの速さは毎時4km、船の静水時の速さは毎時24km。線分図で視覚化。
+
+# 下克上算数ドリル【速さ編】
+
+[CHUNK]
+## 流水算の基本：上りと下りの速さ
+流水算では、川の流れがある状況での船の動きを扱います。船が川を上るとき、船の速度は静水時の速度から川の流れの速度を引いたものになります。逆に、船が川を下るときは、静水時の速度に川の流れの速度を加えたものが実際の速度となります。上りと下りの速さの違いを理解することが、流水算を解く上で重要です。問題文を読み解き、上りと下りの状況を正確に把握しましょう。
+
+[CHUNK]
+## 流水の速さが変化する場合の解法
+川の流れの速さが一定でない場合、問題は複雑になります。例えば、川の流れの速さが変化する場合には、それぞれの区間における速さを個別に計算する必要があります。川の流れの速さが変化するタイミングや、それぞれの速度を正確に把握し、線分図やグラフを用いて視覚的に整理することが有効です。変化する速さを考慮して、上り下りの速さを計算しましょう。
+
+[CHUNK]
+## 流水の速さ変化と線分図の活用
+川の流れの速さが変化する問題では、線分図が非常に役立ちます。線分図を用いることで、船の速度、川の流れの速度、そしてそれらの関係性を視覚的に捉えることができます。特に、川の流れの速さが変化する場合には、��れぞれの区間ごとに線分図を作成し、変化を明確にすることが重要です。線分図を活用して、問題の状況を整理しましょう。
+
+[CHUNK]
+## 静水時の速さの計算
+流水算において、静水時の速さを求めることは基本的なスキルです。静水時の速さは、上りの速さと下りの速さの平均値として計算できます。例えば、上りの速さが毎時24km、下りの速さが毎時42kmの場合、静水時の速さは(24 + 42) / 2 = 33km/時となります。静水時の速さを正確に計算し、問題解決に役立てましょう。
+
+[CHUNK]
+## 静水時の速さ計算と応用
+静水時の速さを求める問題では、上りと下りの速さの関係を理解することが重要です。上りの速さは「静水時の速さ - 川の流れの速さ」、下りの速さは「静水時の速さ + 川の流れの速さ」で表されます。これらの関係式を用いることで、静水時の速さや川の流れの速さを求めることができます。問題文から必要な情報を抽出し、関係式を適切に適用しましょう。
+
+[CHUNK]
+## プールでの流水算：反対方向への移動
+プールでの流水算は、川での流水算と同様に考えることができます。プールの場合、流れの速さを考慮して、人が反対方向に泳ぐ場合を考えます。人が流れに逆らって泳ぐ場合、その人の速度は、静水時の速度から流れの速度を引いたものになります。反対方向への移動距離と時間を計算する際には、この速度を考慮する必要があります。
+
+[CHUNK]
+## プールでの流水算：追いつき問題
+プールでの流水算では、追いつき問題も頻出です。例えば、A君が泳いでB君に追いつく場合、A君の速度からB君の速度を引いたものが、A君がB君に近づく相対速度となります。この相対速度を用いて、追いつくまでの時間を計算します。追いつき問題では、相対速度の概念を理解し、正確に計算することが重要です。
+
+[CHUNK]
+## 列車算の基本：トンネル通過問題
+列車算では、列車がトンネルや橋を通過する問題を扱います。列車がトンネルを通過する場合、列車が完全にトンネルを通過するためには、列車の長さとトンネルの長さを合わせた距離を移動する必要があります。この距離を列車の速度で割ることで、通過にかかる時間を計算できます。図を描いて状況を整理し、正確に計算しましょう。
+
+[CHUNK]
+## 列車算：トンネル通過と橋の通過
+列車算では、トンネル通過問題と橋の通過問題を組み合わせた問題も出題されます。これらの問題を解くためには、それぞれの状況における列車の移動距離を正確に把握する必要があります。トンネル通過時には「トンネルの長さ + 列車の長さ」、橋の通過時には「橋の長さ + 列車の長さ」が移動距離となります。それぞれの距離を正確に計算し、問題解決に役立てましょう。
+
+[CHUNK]
+## 列車算：すれ違い問題
+列車算では、列車同士がすれ違う問題を扱います。列車がすれ違う場合、それぞれの列車の速度を足し合わせたものが、相対速度となります。すれ違いにかかる時間は、それぞれの列車の長さを足し合わせた距離を、相対速度で割ることで計算できます。すれ違い問題では、相対速度の概念を理解し、正確に計算することが重要です。
+
+# 中学受験算数ドリル：速さ編
+
+[CHUNK]
+## 51. 追いつき追い越し問題の解法
+長さ150m、時速90kmのA列車が、長さ120mのB列車に追いついてから追いこし終わるまでに30秒かかった。B列車の速さを求める。A列車の秒速は25m/秒。A列車がB列車を追い越すには、A列車の先頭がB列車の後尾にきてから、A列車の後尾がB列車の先頭に来るまで、つまりA列車がB列車よりも270m多く進む必要がある。A列車は30秒で270m多く進むので、A列車はB列車より9m/秒早い。B列車の秒速は25m/秒-9m/秒=16m/秒。B列車の時速は57.6km/時。
+
+[CHUNK]
+## 51. 追いつき追い越し問題の計算と単位換算
+A列車は30秒で270mだけ多くB列車よりも早く走ることが分かりますので、270m÷30秒=9m/秒でA列車はB列車よりも9m/秒早いことが計算できますね。B列車の秒速は25m/秒-9m/秒=16m/秒となります。問題で聞かれていることは時速なので、16m/秒を時速になおしましょう。1分=60秒なので、16m/秒×60秒=960m/分。1時間=60分なので、960m/分×60分=57600m/時(57.6km/時)と求められました。
+
+[CHUNK]
+## 52. トンネル通過と追いつき追い越し問題
+速さ19m/秒、長さ300mのA列車が、速さ16m/秒、長さ360mのB列車について。(1)A列車がトンネルを通り抜けるのに12分かかった。トンネルの長さは？(2)A列車がB列車に追いついてから追いこすまでの時間は？(1)13380m (2)220秒。A列車がトンネルに入るからぬけるまでに12分かかっています。12分=720秒なので列車Aは720秒で、19m/秒×720秒=13680m進む。13680mはトンネルの長さ+列車Aの長さなので、トンネルの長さは13680m-300m=13380m。
+
+[CHUNK]
+## 52. 追いつき追い越し計算と図解
+秒速19mの列車Aが16m/秒の列車Bに追いついてから追いぬくまでに、660m近づく必要がある。2つの列車は19m/秒と16m/秒なので、同じ方向に進むと1秒間で3mずつ近づきます。列車Aは追いぬくまでに、660m近づく必要があり、2つの列車は1秒間で3mずつ近づきますので、660m÷3m/秒=220秒かかることが求められました!
+
+[CHUNK]
+## 53. 電車の通過時間計算
+長さ500mの電車が秒速20mで走る。(1)踏切で待つ太郎くんの前を通過し始めてから通過し終わるまでの時間。(2)長さ300mの橋を渡り始めてから渡り終わるまでの時間。(1)25秒 (2)40秒。太郎くんの前を通り過ぎるまでにこの列車が何m進まないといけないのかを考えてきましょう。踏切を通り過ぎるまでに、この列車は500mだけ前に進む必要がある。
+
+[CHUNK]
+## 53. 通過距離と時間の計算
+踏切を通り過ぎるまで列車の先頭が踏切の前を通ってから、列車の後尾が踏切を通るまで、となります。つまり、500mを20m/秒の速さで進む必要があるので500m÷20m/秒=25秒となります。今度は300mの橋を渡るときの様子を考えてみましょう。300mの橋を渡る列車の頭が橋を通ってから列車の後ろが橋を通り過ぎるまで、となります。図を書いていくと、この列車が300m+500m=800m進んでいく必要があります。
+
+[CHUNK]
+## 53. 橋の通過時間計算
+800m÷20m/秒=40秒なので、列車が橋を通り過ぎるまでに40秒かかることが計算できました。
+
+[CHUNK]
+## 54. 時計の角度計算：7時51分
+7時51分のとき、時計の長針と短針がつくる小さい方の角度の大きさは何度ですか。解答:70.5°。時計算の問題では長針(長い針) と短針 (短い針) がそれぞれ進む速さをとらえることが大切です。まずは長針の進む速さを考えてみましょう。長針は1時間 (60分)で360° (1回転) することが分かります。よって1分間で進む角度は360°÷60分=6°/分と計算できますね。
+
+[CHUNK]
+## 54. 長針と短針の角度計算
+同じように短針の進む速さを考えてみましょう。短針は12時間(720分)で360° (1回転) しますので、1時間で進む角度は30℃。360+12時間=30/。よって1分間で進む角度は30°÷60分=0.5 /分と計算できます。7時51分のときの角度を計算する前に7時のときの長針と短針の角度を考えてみましょう。長針は12の位置にあり、ここを0°と考えると短針は30/時×7時間=210° 進んでいます。なので7時の時点では2つの針は210 はなれていることが分かります。
+
+[CHUNK]
+## 54. 時計の角度計算：7時51分の詳細
+最後に、7時51分のときをイメージしてみます。長針と短針はそれぞれ7時の場所から51分分だけ進みます。短針は0.5°/分なので、0.5°/分×51分=25.5° 進みます。長針は6°/分なので、6°/分×51分=306° 進みます。時計の図を書きながら計算していくと、306 -25.5-210 =70.5" と求めることができました。
+
+[CHUNK]
+## 55. 長針と短針が重なる時刻
+4時と5時の間で、時計の長針と短針が重なる時刻は4時何分ですか。解答:4時21分。今回は時計の長針と短針が重なる時間を求める問題でした。旅人算のようにはなれた場所にいる長針と短針が重なるときと考えてみましょう。時計の問題では2つの針のきょりは角度で表すことができます。つまり長針と短針が重なる時間=長針と短針の間が0になるということです。長針と短針がそれぞれ進む速さを計算してみます。
+
+[CHUNK]
+## 55. 長針と短針の速度と角度
+長針は1時間(60分)で360° (1回転) するので6°/分。短針は12時間(720分)で360° (1回転)しますので0.5°/分。長針との進む速さについては、1つ前の問題から解いてみるとより分かりやすいですよ!4時から5時の間で2つの針が重なる時間なので、4時の時点での長針と短針の間の角度を計算しましょう。長針は12の位置にあり、ここを0と考えると短針は30°/時×4時間=120°進んでいます。
+
+[CHUNK]
+## 55. 長針と短針が重なる時間の計算
+4時の時点で120° はなれていることが分かりま��。長針と短針が同じ方向に進むとき、2つの針は1分間で6° -0.5 =5.5° 近づきます。4時の時点で120° はなれているので、120°÷5.5°/分=21分と計算出来ました!
+
+[CHUNK]
+## 56. 長針と短針の角度が30度になる時刻
+3時と4時の間で、長針と短針の作る角度が30度になる時はそれぞれ3時何分ですか。解答:3時10分、3時21分。今回の問題、実は答えが二つあることに気づきましたか? 問題をときながら気づいてもOKですし、問題文にも「それぞれ」 何時何分ですか?と聞いているのでよく読んでいれば分かりますね。3時から4時までの間ですので、まずは3時の時点を考えましょう。このとき、長針と短針は90℃はなれています。
+
+[CHUNK]
+## 56. 長針と短針の速度と角度変化
+長針は6°/分。短針は0.5°/分の速さでしたね!この2つの針は1分間で6° -0.5 =5.5° 近づきます。線分図を書いてみて、長針と短針のはなれているきょりと速さを書きこんでみましょう。まず1回目に30° ができるときを考えてみましょう。線分図では長針と短針は90° はなれていますが、長針が短針よりも60° だけ多く進むと、2つの針の間の角度が30° になることがわかると思います。
+
+[CHUNK]
+## 56. 長針と短針の角度が30度になる時間の計算
+よって60° ÷5.5°/分=10 ・/分=10分と計算することができます。次に2回目に30°ができるときについて考えてみましょう。2回目に30°になるときは、長針と短針を追いこして、30℃先に進んだときになります。(線分図にイメージ図を書いています。)つまり、3時の時点から長針は短針よりも120° 多く進めば2回目に30°を作ることができます。よって120° +5.5°/分=21 分と求めることができました。
+
+[CHUNK]
+## 57. 特殊な時計の針の重なり
+ある特別な時計は長針が30秒で1周、短針が2分で1周する。長針と短針が反対方向をさして一直線になっている時、長針と短針が最初に重なるのは今から何秒後ですか。解答:20秒。この問題は普通の時計算と比べて、長針と短針の進む速さがちがいますので気をつけましょう!まずは問題文から長針と短針がそれぞれ進む速さを計算していきましょう。長針は30秒かけて1周しますので、30秒で360° 進むことが分かります。よって長針は360°÷30秒=12°/秒と計算できますね。
+
+[CHUNK]
+## 57. 特殊な時計の針の速度と角度
+短針は2分で1周しますので、2分で360° 進むことになります。2分=120秒なので、360°÷120秒=3秒と分かりますね。長針と短針が反対方向を指しているので、2つの針の間の角度は360°の半分の180°となります。この2つの針は時計のように動きますので、2つの針は同じ方向に進みます。長針と短針を線分図になおして、出会うまでの時間を計算しましょう。
+
+[CHUNK]
+## 57. 特殊な時計の針が重なる時間の計算
+線分図に、長針 (12°/秒) と短針 (3°/秒)そして180° を書きこみましょう。長針と短針は1秒で12° -3° 9° となりますので、9°/秒の速さで近づきます。面積図を書いて計算すると、180°÷9°/秒=20秒で20秒後に重なると分かります!
+
+[CHUNK]
+## 58. 長針と短針が直角になる時刻
+10時と11時の間で、時計の長針と短針のつくる角が直角になることがあります。2回目に直角になるのは10時何分ですか。解答:10時38分。56 を解いてからこの解説を読むとよりわかりやすいと思います!まずは10時のときの2つの長針と短針のはなれている角度を計算しましょう。10時のとき、2つの針は60℃はなれています。ここから2つの針の角度が90°になるときを計算しましょう。
+
+[CHUNK]
+## 58. 長針と短針の速度と角度変化
+長針は6°/分。短針は0.5°/分の速さになります。よって、この2つの針は1分間で6° -0.5 =5.5° 近づきます。線分図を書いてみて、長針と短針のはなれている角度と速さを書きこんでみましょう。まず1回目に90° ができるときを考えてみましょう。線分図では長針と短針は60° はなれていますが、長針が短針よりも30° だけ多く進むと、2つの針の間の角度が90° になることがわかると思います。
+
+[CHUNK]
+## 58. 長針と短針が直角になる時間の計算
+よって30° ÷5.5°/分=5分と計算することができます。次に2回目に90° ができるときについて考えてみましょう。2回目に90°になるときは、長針と短針を追いこして、90°先に進んだときになります。(線分図にイメージ図を書いています。)つまり、10時の時���から長針は短針よりも210°多く進めば2回目に90°を作ることができます。よって210° ÷5.5°/分=38 分と求めることができました。
+
+[CHUNK]
+## 59. 長針と短針が重なる時刻と等しい角度になる時刻
+時計の長針と短針が2時と3時の間でちょうど重なっている。このとき、以下の問いに答えなさい。(1) このときの時間は2時何分ですか。(2)その後長針と短針が文字ばんのめもりの6をはさんで等しい角度になっている時刻は2時何分ですか。解答:(1)2時10分 (2)2時46分。かなりむずかしい問題でした。特に (2) はよく MEMO と一緒によく読んでみてください!
+
+[CHUNK]
+## 59. 長針と短針の重なる時間の計算
+(1) 2時のときの長針と短針のはなれている角度は60°です。また長針は6/分、短針は0.5分の速さで進みますのでこれを線分図に書きこんで、針が重なる時間を計算しましょう。MEMO のように線分図を書いて、2つの針が重なる時間を計算します。2つの針は1分間で6-0.5 =5.5 近づきます。重なる=2つの針の間の角度が0になるときなので、60° +5.5°/分=10分の時間に重なることが分かりました。(ここまではいつもの問題と同じでした。)
+
+[CHUNK]
+## 59. 等しい角度になる時刻の計算
+(2) 問題文で書かれている状況について考えてみましょう。6のめもりは時計の真ん中にあるので、時計を半分にしたときに、長針と短針の2つの角度(MEMOの青と紫)が同じになる時間を求めることができればOKです。時間を求めたいので口分として計算していきます。短針の角度は2時の時点で120 でどんどん小さくなるので、120-0.5/分×口分と考えることができます。同じように長針の角度は2時の時点では0なので、6/分×分から180引いた、6/分×分~180℃になります!
+
+[CHUNK]
+## 59. 等しい角度になる時刻の計算：詳細
+短針の角度=長針の角度になる時間を知りたいので、120-0.5/分×口分=6/分×口分-180 を計算すれば答えが出せます。線分図を書いてこの式を表してみました。線分図を書いて「差」に注目してみましょう。すると、180°-0.5/分×口分=6°/分×口分-120°と式をかき変えることができます。この式を工夫して整理してみます。
+300°=6°/分×口分+0.5分×分
+180°=6°/分×口分-120° +0.5分×口分
+२
+300(6/分+0.5/分)×分
+?
+両辺に+120
+よって300÷6.5°/分=46分と計算することができました。
+
+[CHUNK]
+## 60. 長針と短針が作る角度と追い越し後の角度
+時計の針が5時10分をさしています。このとき、以下の問いに答えなさい。(1) 長針と短針が作る角度で小さいものは何度ですか。(2) 長針が短針を追いこしてから作る角度が90度となるのは5時何分ですか。解答:(1) 95° (2)5時43分。5時10分のときの長針と短針の2つの角度を求めるために、まずは5時のときの角度を計算しましょう。(長針は6/分、短針は0.5/分の速さで進みます。)
+
+[CHUNK]
+## 60. 長針と短針の角度計算
+5時のとき、長針は12の位置にいるので角度を0°と考えてみましょう。すると、短針は5の位置にあるので30°/時×5時間=150° はなれていることが分かります。5時10分の角度を求めたいので、5時から10分で長針と短針が進む角度を計算しましょう。長針は6°/分×10分=60°、短針は0.5/分×10分=5 なので、時計の図を書いて2つの針の間の角度を、150°+5 -60° =95° と解いていきましょう。
+
+[CHUNK]
+## 60. 追い越し後の角度計算
+線分図を書いて、問題文で聞かれている2つの針が90°になるときを考えてみましょう。長針は6°/分。短針は0.5/分の速さで進むので、2つの針は1分間で6° -0.5 =5.5° 近づきます。線分図を書いてみて、長針と短針のはなれている角度 (150°) と速さを書いていきます。長針が短針を追いこして90°になるとき、長針は短針よりも240° (はなれている 150°+90°) 多く進む必要があります。2つの針は1分間で5.5 近づくので、長針が短針を追いこして90°240°÷5.5°/分=43分となり、5時43分と求められることができます。
+
+# 下克上算数ドリル【速さ編】
+
+[CHUNK]
+## 面積図の活用：四角形の性質で問題を視覚的に解く
+面積図は、算数の解法の一つで、四角形の面積（たて×横）の性質を利用する。速さの問題では、縦を速さ、横を時間、面積を進んだ距離として表現する。例えば、1分で30m進む人が5分で進む距離は、30m/分×5分=150mで計算できる。面積図はケアレスミスを減らし、問題を正確に解くために有効。特に算数が苦手な場合や学習初期段階では、図を描くことで見直しが容易になり、理解が深まる。速さ、時間、距離の関係を視覚的に捉え、複雑な問題への対応力を高める。面積図の利用は、問題解決の基礎を固める上で重要。
+
+[CHUNK]
+## 面積図の種類と活用：速さ、割合、個数問題への応用
+面積図は、速さだけでなく、割合や個数に関する問題にも応用可能。速さの問題では、1分あたりの進む距離と時間を掛けて総距離を求める。例えば、1分で60m進む人が5分で進む距離は、60m/分×5分=300mとなる。割合の問題では、全体を四角形で表し、その一部を塗りつぶすことで割合を視覚化する。個数の問題では、1個あたりの価格と個数を掛けて合計金額を求める。例えば、1個200円の商品を3個購入した場合、200円/個×3個=600円となる。面積図は、問題の種類に応じて柔軟に活用できる。
+
+[CHUNK]
+## 線分図の基本：問題文の情報を整理し視覚化
+線分図は、問題文中の数値や数量関係を線で表すことで、問題を解きやすくする算数の解法。例えば、600円の商品と300円の商品を購入した場合、それぞれの金額を線で表現し、合計金額を視覚的に示す。線分図は、比の性質を理解する上でも役立ち、問題解決の糸口を見つけやすくする。面積図と並び、算数の問題で頻繁に使用される。線分図は、問題文の情報を整理し、数量関係を明確にするための強力なツール。
+
+[CHUNK]
+## 線分図の種類と活用：和差算、旅人算への応用
+線分図は、和差算や旅人算など、様々な問題に応用可能。和差算では、りんごとバナナの値段を線で表し、それぞれの値段と合計金額を比較することで、それぞれの値段を求める。旅人算では、2人が同じ方向または反対方向に進む状況を線で表し、それぞれの進む距離や速さの関係を視覚的に捉える。特に、2人が出会うまでの時間や距離を求める問題で有効。線分図は、複雑な状況を整理し、問題解決を容易にする。
+
+[CHUNK]
+## 比の基本：数量や速さの比較
+比は、2つの数量を比較するための表現方法で、○:□のように表す。例えば、2cmと4cmの長さを比較する場合、2:4と表現できる。比は、前項と後項で構成され、それぞれ比較される数量を表す。比を用いることで、異なる単位の数量を相対的に比較することが可能。比は、算数における重要な概念であり、様々な問題解決に役立つ。
+
+[CHUNK]
+## 比と線分図：視覚的な表現で理解を深める
+比は、線分図と組み合わせて使用することで、視覚的に理解を深めることができる。例えば、500円と1000円の金額を比較する場合、それぞれの金額を線分の長さで表し、比率を視覚的に示す。線分図を用いることで、比の関係を直感的に捉えることが可能。比の値を線分図上に表現する際は、実際の数量と区別するために記号を用いることが重要。比と線分図の組み合わせは、問題解決の精度を高める。
+
+[CHUNK]
+## 逆比の理解：面積一定条件下の縦横比
+逆比は、面積が一定の場合に、縦と横の長さの比が逆になる関係。例えば、面積が15の長方形において、縦の長さが3の場合、横の長さは5となる。一方、縦の長さが5の場合、横の長さは3となる。このとき、縦の長さの比が3:5であるのに対し、横の長さの比は5:3となる。このように、ある条件が一定の場合に、2つの要素の比が逆になる関係を逆比と呼ぶ。逆比の理解は、複雑な問題を解く上で重要。
+
+[CHUNK]
+## 逆比の応用：速さの問題への適用
+逆比は、速さの問題に応用できる。例えば、同じ距離を進む場合、速さの比と時間の比は逆比の関係になる。時速3kmの人が15km進むのに5時間かかるのに対し、時速5kmの人が15km進むのに3時間かかる。このとき、速さの比が3:5であるのに対し、時間の比は5:3となる。逆比の関係を理解することで、速さの問題を効率的に解くことができる。面積図を丁寧に書くことで、逆比の関係を視覚的に捉えることも可能。
+
+[CHUNK]
+## 仮定法の活用：問題解決の糸口を見つける
+仮定法は、問題を解く際に、ある条件を仮定して考える方法。例えば、「もし○○が□□だったら〜」というように、具体的な数値を仮定して問題を解き進める。AくんがBくんより3倍速く走る場合、Aくんが15分で走る距離をBくんが何分で走れるかを考える際、Aくんの速さを①/分と仮定する��、Bくんの速さは③/分となる。仮定法を用いることで、複雑な問題も簡略化し、解決の糸口を見つけやすくなる。
+
+[CHUNK]
+## 仮定法の応用：仕事算への展開
+仮定法は、仕事算にも応用できる。例えば、ある仕事量を1人が何時間で終わらせるかを考える際、1時間あたりの仕事量を①と仮定する。仮定法を用いることで、複数人が共同で仕事をする場合や、仕事の進捗状況を把握する際に役立つ。仕事算では、全体の仕事量を1と仮定し、各人の仕事量を分数で表すことが多い。仮定法は、問題解決の柔軟性を高め、様々な算数問題に対応できる。
+
+[CHUNK]
+## 流水算の基本：川の流れを考慮した速さの計算
+流水算は、川の流れがある状況下での船の速さを扱う問題。川の流れに逆らって進む場合、船の速さは静水時の速さから川の流れの速さを引いたものになる。一方、川の流れに乗って進む場合、船の速さは静水時の速さに川の流れの速さを足したものになる。流水算では、川の流れの向きと速さを考慮して、船の実際の速さを計算する必要がある。流水算は、速さの問題の中でも特に複雑で、注意が必要。
+
+[CHUNK]
+## 流水算の解法：線分図の活用
+流水算を解く上で、線分図の活用が有効。川上に向かう場合と川下に向かう場合で、船の速さが異なるため、それぞれの状況を線分図で表現する。例えば、静水時の速さが75m/分、川の速さが15m/分の場合、川上に向かう速さは60m/分、川下に向かう速さは90m/分となる。線分図を用いることで、速さの関係を視覚的に捉え、計算ミスを防ぐことができる。流水算は、線分図を丁寧に書くことが重要。
+
+[CHUNK]
+## 列車算の解法：問題文の正確な理解
+列車算は、列車が通過する時間や距離を計算する問題。問題文を注意深く読み、何が問われているかを正確に理解することが重要。列車が黄色い小人の前を通過する状況を例に、通過開始から通過終了までの時間や、列車が見えなくなってから出始めるまでの時間など、問われる内容によって計算方法が異なる。問題文の理解不足は、誤答につながるため、注意が必要。
+
+[CHUNK]
+## 列車算の応用：すれ違いと追い越しの計算
+列車算では、列車同士がすれ違う場合や追い越す場合の計算も重要。列車がすれ違う場合、それぞれの列車の長さの合計が、すれ違いに要する距離となる。一方、列車が追い越す場合、速い列車が遅い列車よりもどれだけ長く進む必要があるかを考慮する。列車算では、列車の長さや速さ、進行方向などを正確に把握し、適切な計算を行う必要がある。図を描くことで、状況を整理しやすくなる。
+
+[CHUNK]
+## 時計算の基本：長針と短針の速さの理解
+時計算は、時計の針の角度や位置関係を扱う問題。長針と短針は、それぞれ異なる速さで回転しており、長針は1時間で360度、短針は12時間で360度回転する。時計算では、長針と短針のそれぞれの速さを正確に把握し、角度や時間の計算を行う必要がある。長針と短針の速さの差を理解することが、時計算の問題を解く上で重要。
+
+[CHUNK]
+## 時計算の応用：角度と時間の計算
+時計算では、特定の時刻における長針と短針の角度や、針が重なる時刻などを計算する。例えば、4時の場合、長針は12の位置、短針は4の位置にあり、その間の角度は120度となる。長針と短針が重なる時刻を求めるには、それぞれの針の速さの差を利用する。時計算は、線分図を用いることで、針の動きを視覚的に捉え、問題を解きやすくなる。時計算は、算数の応用問題として頻出。

V1.7.1/requirements.txt

@@ -0,0 +1,18 @@
+# Web Framework
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+
+# HTTP Client
+httpx==0.28.1
+
+# Google Gemini API (新SDK: google-genai - thinking_budget対応)
+google-genai>=1.0.0
+
+# Environment Variables
+python-dotenv==1.0.1
+
+# JSON Processing
+orjson==3.10.12
+
+# Password Hashing
+bcrypt==4.2.1

V1.7.1/src/__init__.py

@@ -0,0 +1 @@
+# 超天才クイズ v3

V1.7.1/src/models/__init__.py

@@ -0,0 +1 @@
+# src/models/__init__.py

V1.7.1/src/models/gemini_schemas.py

@@ -0,0 +1,169 @@
+"""
+Gemini Structured Output Schemas
+
+Pydanticモデルを使用してGeminiのJSON出力スキーマを定義。
+response_json_schemaパラメータで使用することで、構造化出力を保証する。
+"""
+
+from typing import List, Optional, Literal, Dict, Any
+from pydantic import BaseModel, Field
+
+
+# =============================================================================
+# Helper Functions (スキーマ生成ヘルパー)
+# =============================================================================
+
+def get_list_schema(item_schema: type) -> Dict[str, Any]:
+    """
+    Pydanticモデルのリストスキーマを生成
+
+    Args:
+        item_schema: リスト要素のPydanticモデルクラス
+
+    Returns:
+        JSON Schema (配列型)
+    """
+    item_json_schema = item_schema.model_json_schema()
+    # $defsを展開してフラット化
+    defs = item_json_schema.pop("$defs", {})
+
+    return {
+        "type": "array",
+        "items": item_json_schema,
+        "$defs": defs
+    }
+
+
+# =============================================================================
+# Summary Schema (サマリー生成用)
+# =============================================================================
+
+class SummarySchema(BaseModel):
+    """問題群のサマリー生成スキーマ"""
+    keywords: List[str] = Field(
+        description="問題の具体的なキーワード（答え、題材）のリスト"
+    )
+    topics: List[str] = Field(
+        description="問題タイプ + 具体的な題材を組み合わせたトピックのリスト"
+    )
+    summary: str = Field(
+        description="問題群の概要（50文字以内）"
+    )
+
+
+# =============================================================================
+# Question Schema (問題生成用)
+# =============================================================================
+
+class QuestionSchema(BaseModel):
+    """生成される問題のスキーマ"""
+    subject: str = Field(
+        description="教科コード (jp, math, sci, soc)"
+    )
+    category: str = Field(
+        description="カテゴリコード (例: JP01, MA05)"
+    )
+    difficulty: Literal["easy", "medium", "hard"] = Field(
+        description="難易度"
+    )
+    question: str = Field(
+        description="問題文"
+    )
+    choices: List[str] = Field(
+        description="選択肢のリスト（4つ）",
+        min_length=4,
+        max_length=4
+    )
+    correct_answer: int = Field(
+        description="正解の選択肢インデックス（0-3）",
+        ge=0,
+        le=3
+    )
+    explanation: str = Field(
+        description="解説文"
+    )
+
+
+# QuestionsListSchemaはget_list_schema(QuestionSchema)で代替
+
+
+# =============================================================================
+# Evaluation Schema (評価生成用)
+# =============================================================================
+
+class SubjectEvaluationSchema(BaseModel):
+    """教科別評価スキーマ"""
+    advice: str = Field(
+        description="教科別アドバイス（2-3文）"
+    )
+    strengths: List[str] = Field(
+        description="強み・得意分野のリスト",
+        min_length=1,
+        max_length=5
+    )
+    weaknesses: List[str] = Field(
+        description="改善点・苦手分野のリスト",
+        min_length=1,
+        max_length=5
+    )
+    recommended_topics: List[str] = Field(
+        description="おすすめの学習トピックのリスト",
+        min_length=1,
+        max_length=5
+    )
+
+
+class OverallEvaluationSchema(BaseModel):
+    """全体評価スキーマ"""
+    overall_advice: str = Field(
+        description="全体的なアドバイス（2-3文）"
+    )
+    strengths: List[str] = Field(
+        description="教科横断的な強みのリスト"
+    )
+    weaknesses: List[str] = Field(
+        description="教科横断的な改善点のリスト"
+    )
+    next_steps: List[str] = Field(
+        description="次のステップのリスト"
+    )
+    balance_comment: str = Field(
+        description="教科バランスと全体的な傾向についてのコメント"
+    )
+
+
+class BatchEvaluationSchema(BaseModel):
+    """複数教科一括評価スキーマ"""
+    subject_evaluations: Dict[str, SubjectEvaluationSchema] = Field(
+        description="教科別評価 {subject_code: SubjectEvaluationSchema}"
+    )
+    overall_evaluation: OverallEvaluationSchema = Field(
+        description="全体評価"
+    )
+
+
+# =============================================================================
+# Validation Schema (検証用)
+# =============================================================================
+
+class ValidationResultSchema(BaseModel):
+    """問題検証結果スキーマ"""
+    subject: str = Field(
+        description="教科コード"
+    )
+    index: int = Field(
+        description="問題のインデックス"
+    )
+    modified: bool = Field(
+        description="修正されたかどうか"
+    )
+    modification_reason: Optional[str] = Field(
+        default=None,
+        description="修正理由（修正された場合のみ）"
+    )
+    question: QuestionSchema = Field(
+        description="検証後の問題（修正された場合は修正後）"
+    )
+
+
+# ValidationResultsListSchemaはget_list_schema(ValidationResultSchema)で代替

V1.7.1/src/prompts/__init__.py

@@ -0,0 +1 @@
+# Prompts

V1.7.1/src/prompts/evaluation_prompts.py

@@ -0,0 +1,210 @@
+"""
+評価生成プロンプト定義
+"""
+
+import json
+from typing import Dict, List
+
+SUBJECT_NAMES = {
+    "jp": "国語",
+    "math": "算数",
+    "sci": "理科",
+    "soc": "社会"
+}
+
+
+def get_evaluation_prompt(
+    subject: str,
+    results: List[Dict],
+    statistics: Dict = None
+) -> str:
+    """
+    評価生成プロンプトを構築
+
+    Args:
+        subject: 教科コード
+        results: 解答結果リスト
+        statistics: ユーザー統計
+
+    Returns:
+        完成したプロンプト
+    """
+    subject_name = SUBJECT_NAMES.get(subject, subject)
+
+    # 結果サマリー計算
+    total = len(results)
+    correct = sum(1 for r in results if r.get("is_correct", False))
+    accuracy = (correct / total * 100) if total > 0 else 0
+
+    # カテゴリ別集計
+    by_category = {}
+    for r in results:
+        cat = r.get("category", "unknown")
+        if cat not in by_category:
+            by_category[cat] = {"total": 0, "correct": 0}
+        by_category[cat]["total"] += 1
+        if r.get("is_correct", False):
+            by_category[cat]["correct"] += 1
+
+    prompt = f"""あなたは中学受験の{subject_name}指導の専門家です。
+以下の解答結果を分析し、学習アドバイスを生成してください。
+
+## 今回の結果
+- 教科: {subject_name}
+- 問題数: {total}問
+- 正解数: {correct}問
+- 正答率: {accuracy:.1f}%
+
+## カテゴリ別結果
+{json.dumps(by_category, ensure_ascii=False, indent=2)}
+
+## 解答詳細
+{json.dumps(results[:10], ensure_ascii=False, indent=2)}
+（最大10問まで表示）
+
+## 出力形式
+以下のJSON形式で出力してください。
+
+```json
+{{
+    "advice": "総合的なアドバイス（2-3文）",
+    "strengths": ["強み・得意分野1", "強み・得意分野2"],
+    "weaknesses": ["改善点・苦手分野1", "改善点・苦手分野2"],
+    "recommended_topics": ["おすすめの学習トピック1", "おすすめの学習トピック2"]
+}}
+```
+
+**注意**:
+- 具体的で建設的なアドバイスを心がけてください
+- 小学生に分かりやすい表現を使ってください
+- 励ましの言葉を含めてください
+"""
+
+    # 累積統計があれば追加
+    if statistics:
+        prompt += f"""
+
+## 累積統計（参考）
+{json.dumps(statistics, ensure_ascii=False, indent=2)}
+"""
+
+    return prompt
+
+
+def get_batch_evaluation_prompt(
+    results_by_subject: Dict[str, List[Dict]],
+    statistics: Dict = None
+) -> str:
+    """
+    複数教科の評価を一括生成するプロンプト
+
+    Args:
+        results_by_subject: {"jp": [...], "math": [...], ...} 形式の教科別結果
+        statistics: ユーザー統計情報（教科別）
+
+    Returns:
+        評価生成用プロンプト文字列
+    """
+    # 全教科のサマリーを構築
+    subject_summaries = []
+
+    for subject, results in results_by_subject.items():
+        subject_name = SUBJECT_NAMES.get(subject, subject)
+
+        # 結果サマリー計算
+        total = len(results)
+        correct = sum(1 for r in results if r.get("is_correct", False))
+        accuracy = (correct / total * 100) if total > 0 else 0
+
+        # カテゴリ別集計
+        by_category = {}
+        for r in results:
+            cat = r.get("category", "unknown")
+            if cat not in by_category:
+                by_category[cat] = {"total": 0, "correct": 0}
+            by_category[cat]["total"] += 1
+            if r.get("is_correct", False):
+                by_category[cat]["correct"] += 1
+
+        subject_summaries.append({
+            "subject": subject,
+            "subject_name": subject_name,
+            "total": total,
+            "correct": correct,
+            "accuracy": accuracy,
+            "by_category": by_category,
+            "details": results[:10]  # 最大10問まで
+        })
+
+    # プロンプト構築
+    prompt = f"""あなたは中学受験の指導専門家です。
+以下の複数教科の解答結果を分析し、**教科別評価と全体評価**を生成してください。
+
+## 受験した教科
+{", ".join([s["subject_name"] for s in subject_summaries])}
+
+## 教科別結果詳細
+"""
+
+    # 各教科の詳細を追加
+    for summary in subject_summaries:
+        prompt += f"""
+### {summary["subject_name"]}
+- 問題数: {summary["total"]}問
+- 正解数: {summary["correct"]}問
+- 正答率: {summary["accuracy"]:.1f}%
+
+#### カテゴリ別結果
+{json.dumps(summary["by_category"], ensure_ascii=False, indent=2)}
+
+#### 解答詳細（最大10問）
+{json.dumps(summary["details"], ensure_ascii=False, indent=2)}
+"""
+
+    # 累積統計があれば追加
+    if statistics:
+        prompt += f"""
+## 累積統計（参考）
+{json.dumps(statistics, ensure_ascii=False, indent=2)}
+"""
+
+    # 出力形式を指定
+    prompt += """
+## 出力形式
+以下のJSON形式で、**教科別評価**と**全体評価**を生成してください。
+
+```json
+{
+    "subject_evaluations": {
+"""
+
+    # 各教科の出力フォーマットを追加
+    for i, summary in enumerate(subject_summaries):
+        comma = "," if i < len(subject_summaries) - 1 else ""
+        prompt += f"""        "{summary['subject']}": {{
+            "advice": "<subject-specific advice in 2-3 sentences>",
+            "strengths": ["<strength1>", "<strength2>"],
+            "weaknesses": ["<weakness1>", "<weakness2>"],
+            "recommended_topics": ["<topic1>", "<topic2>"]
+        }}{comma}
+"""
+
+    prompt += """    },
+    "overall_evaluation": {
+        "overall_advice": "<comprehensive advice across all subjects in 2-3 sentences>",
+        "strengths": ["<cross-subject strength1>", "<strength2>"],
+        "weaknesses": ["<cross-subject weakness1>", "<weakness2>"],
+        "next_steps": ["<next learning step1>", "<step2>"],
+        "balance_comment": "<comment on subject balance and overall trends>"
+    }
+}
+```
+
+**注意事項**:
+- 各教科の特性を踏まえた具体的なアドバイスを生成してください
+- 小学生に分かりやすい表現を使ってください
+- 励ましと前向きな指摘を心がけてください
+- 全体評価では、教科間のバランスや全体的な学習傾向も分析してください
+"""
+
+    return prompt

V1.7.1/src/prompts/question_prompts.py

@@ -0,0 +1,292 @@
+"""
+問題生成プロンプト定義
+"""
+
+import json
+from typing import Dict, List, Optional
+
+# ジャンル定義（詳細分析用カテゴリID）
+GENRES = {
+    "jp": {
+        "JP01": "漢字・語彙（読み書き、四字熟語、慣用句、ことわざ）",
+        "JP02": "文法・言葉のきまり（品詞、敬語、文の成分、修飾関係）",
+        "JP03": "物語文読解（心情理解、場面把握、人物関係）",
+        "JP04": "説明文・論説文読解（要旨、段落構成、筆者の主張）",
+        "JP05": "随筆文読解（筆者の体験・感想の読み取り）",
+        "JP06": "詩・韻文（詩、短歌、俳句、表現技法）",
+        "JP07": "記述問題（理由説明、要約、意見記述）",
+        "JP08": "知識・文学史（作家、作品名、文学的常識）"
+    },
+    "math": {
+        "MA01": "計算",
+        "MA02": "数の性質",
+        "MA03": "割合・比",
+        "MA04": "速さ",
+        "MA05": "文章題（その他）",
+        "MA06": "平面図形",
+        "MA07": "立体図形",
+        "MA08": "場合の数・確率",
+        "MA09": "グラフ・表",
+        "MA10": "特殊算"
+    },
+    "sci": {
+        "SC01": "力・運動",
+        "SC02": "電気",
+        "SC03": "光・音・熱",
+        "SC04": "物質の性質",
+        "SC05": "水溶液",
+        "SC06": "燃焼・化学変化",
+        "SC07": "植物",
+        "SC08": "動物",
+        "SC09": "人体",
+        "SC10": "天体",
+        "SC11": "気象",
+        "SC12": "地学"
+    },
+    "soc": {
+        "SO01": "日本地理（国土・自然）",
+        "SO02": "日本地理（産業）",
+        "SO03": "世界地理",
+        "SO04": "歴史（古代〜平安）",
+        "SO05": "歴史（鎌倉〜室町）",
+        "SO06": "歴史（安土桃山〜江戸）",
+        "SO07": "歴史（明治〜現代）",
+        "SO08": "公民（政治・憲法）",
+        "SO09": "公民（経済・国際）",
+        "SO10": "時事問題"
+    }
+}
+
+SUBJECT_NAMES = {
+    "jp": "国語",
+    "math": "算数",
+    "sci": "理科",
+    "soc": "社会"
+}
+
+
+def get_genre_list(subject: str) -> str:
+    """ジャンルリストを文字列で取得"""
+    genres = GENRES.get(subject, {})
+    return "\n".join([f"- {gid}: {name}" for gid, name in genres.items()])
+
+
+def get_question_prompt(
+    subject: str,
+    knowledge_base: str,
+    statistics: Dict = None,
+    recent_questions: List = None
+) -> str:
+    """
+    問題生成プロンプトを構築
+
+    Args:
+        subject: 教科コード
+        knowledge_base: Knowledge Base内容
+        statistics: ユーザー統計
+        recent_questions: 直近の問題リスト
+
+    Returns:
+        完成したプロンプト
+    """
+    subject_name = SUBJECT_NAMES.get(subject, subject)
+    genre_list = get_genre_list(subject)
+
+    prompt = f"""あなたは中学受験対策の{subject_name}問題作成の専門家です。
+
+## タスク
+以下の教材を参考に、{subject_name}の4択問題を10問生成してください。
+
+## 教材（Knowledge Base）
+<knowledge_base>
+{knowledge_base}
+</knowledge_base>
+
+## ジャンル一覧（必ず以下のジャンルIDを使用）
+{genre_list}
+
+## 条件
+1. **教材活用**: 上記の教材に基づいた問題を出題すること
+2. **分野構成**: 上記ジャンルから幅広く出題（各1〜3問）
+3. **難易度配分**: 基本4問、標準4問、応用2問（計10問）
+   - 基本: 知識の確認、即答できるレベル（30秒以内で解答可能）
+   - 標準: 少し考えれば解ける問題（1分程度で解答可能）
+   - 応用: 知識の応用や複合的な思考が必要（1-2分で解答可能）
+4. **問題の質**: 素早く解けるが、考えさせる要素を残す
+5. **問題形式**: 問題文、4つの選択肢、正解番号（0〜3）、解説を含む
+6. **ジャンルID使用**: categoryフィールドには必ずジャンルID（{list(GENRES.get(subject, {}).keys())[0]}など）を使用すること
+7. **正解位置の分散**: correct_answerは0〜3の間で均等に分散させること（特定の位置に偏らないよう注意）
+
+## 出力形式
+JSON配列形式で出力してください。
+
+```json
+[
+  {{
+    "category": "{list(GENRES.get(subject, {}).keys())[0]}",
+    "difficulty": "基本",
+    "question": "問題文",
+    "choices": ["選択肢1", "選択肢2", "選択肢3", "選択肢4"],
+    "correct_answer": 0,
+    "explanation": "解説文"
+  }},
+  ...
+]
+```
+
+**重要**:
+- categoryには必ずジャンルID（例: {list(GENRES.get(subject, {}).keys())[0]}）を使用
+- correct_answerは0〜3の数値（選択肢の0-indexedインデックス）
+- 10問生成すること（基本4問、標準4問、応用2問）
+- 難���度フィールドには「基本」「標準」「応用」のいずれかを使用
+- 正解位置は0〜3の間で均等に分散させること
+"""
+
+    # 統計情報があれば追加
+    if statistics:
+        prompt += f"""
+
+## ユーザーの分野別正答率
+{json.dumps(statistics, ensure_ascii=False, indent=2)}
+
+正答率60%未満の分野は「基本」レベル中心、60%以上は「標準」「応用」をミックスしてください。
+"""
+
+    # 直近問題があれば追加
+    if recent_questions:
+        prompt += f"""
+
+## 直近20問の履歴（重複回避用）
+{json.dumps(recent_questions[:20], ensure_ascii=False)}
+
+上記と類似した問題は避けてください。
+"""
+
+    return prompt
+
+
+def get_batch_question_prompt(
+    subjects: List[str],
+    knowledge_bases: Dict[str, str],
+    priority_genres: Optional[Dict[str, List[str]]] = None,
+    exclude_keywords: Optional[List[str]] = None
+) -> str:
+    """複数教科の問題を一括生成するプロンプト
+
+    Args:
+        subjects: 教科コードのリスト (例: ["jp", "math", "sci", "soc"])
+        knowledge_bases: 教科別Knowledge Base {"jp": "...", "math": "...", ...}
+        priority_genres: 教科別優先ジャンル {"jp": ["JP05", "JP06"], ...}
+        exclude_keywords: 除外キーワードリスト ["いたわる", "四字熟語", ...]
+
+    Returns:
+        一括生成用プロンプト文字列
+    """
+    # システムインストラクション
+    subject_names_str = "、".join([SUBJECT_NAMES.get(s, s) for s in subjects])
+
+    prompt = f"""あなたは中学受験対策の複数教科問題作成の専門家です。
+
+## タスク
+以下の教材を参考に、{subject_names_str}の4択問題を各教科10問ずつ生成してください。
+
+"""
+
+    # 各教科のKnowledge Baseをセクション分け
+    for subject in subjects:
+        subject_name = SUBJECT_NAMES.get(subject, subject)
+        kb = knowledge_bases.get(subject, "")
+
+        prompt += f"""## {subject_name}の教材（Knowledge Base）
+<knowledge_base_{subject}>
+{kb}
+</knowledge_base_{subject}>
+
+"""
+
+    # 各教科のジャンル一覧
+    prompt += "## ジャンル一覧\n"
+    for subject in subjects:
+        subject_name = SUBJECT_NAMES.get(subject, subject)
+        genre_list = get_genre_list(subject)
+        prompt += f"""
+### {subject_name}のジャンル（必ず以下のジャンルIDを使用）
+{genre_list}
+
+"""
+
+    # 条件
+    prompt += """## 条件
+1. **教材活用**: 各教科の教材に基づいた問題を出題すること
+2. **分野構成**: 各教科のジャンルから幅広く出題（各1〜3問）
+3. **難易度配分**: 各教科ごとに基本4問、標準4問、応用2問（計10問）
+   - 基本: 知識の確認、即答できるレベル（30秒以内で解答可能）
+   - 標準: 少し考えれば解ける問題（1分程度で解答可能）
+   - 応用: 知識の応用や複合的な思考が必要（1-2分で解答可能）
+4. **問題の質**: 素早く解けるが、考えさせる要素を残す
+5. **問題形式**: 問題文、4つの選択肢、正解番号（0〜3）、解説を含む
+6. **ジャンルID使用**: categoryフィールドには必ずジャンルID（JP01, MA01など）を使用すること
+7. **正解位置の分散**: correct_answerは0〜3の間で均等に分散させること（各教科内で偏らないよう注意）
+
+## 出力形式
+JSON配列形式で、教科別に識別可能な形式で出力してください。
+
+```json
+[
+"""
+
+    # 各教科の出力例を1問ずつ示す
+    example_questions = []
+    for subject in subjects:
+        first_genre = list(GENRES.get(subject, {}).keys())[0]
+        subject_name = SUBJECT_NAMES.get(subject, subject)
+        example_questions.append(f"""  {{
+    "subject": "{subject}",
+    "category": "{first_genre}",
+    "difficulty": "基本",
+    "question": "{subject_name}の問題文（教材に基づく）",
+    "choices": ["選択肢1", "選択肢2", "選択肢3", "選択肢4"],
+    "correct_answer": 0,
+    "explanation": "解説文"
+  }}""")
+
+    prompt += ",\n".join(example_questions)
+    prompt += """,
+  ...
+]
+```
+
+**重要**:
+- **必須フィールド**: subjectフィールドは必須（教科識別のため）
+"""
+
+    # 各教科のジャンルIDリストを明示
+    for subject in subjects:
+        genre_ids = ", ".join(GENRES.get(subject, {}).keys())
+        subject_name = SUBJECT_NAMES.get(subject, subject)
+        prompt += f"- {subject_name}のcategoryには {{{genre_ids}}} のいずれかを使用\n"
+
+    prompt += """- correct_answerは0〜3の数値（選択肢の0-indexedインデックス）
+- 各教科10問生成すること（基本4問、標準4問、応用2問）
+- 難易度フィールドには「基本」「標準」「応用」のいずれかを使用
+- 教科の順序は問いません（ランダムでOK）
+- **重要**: 正解位置は0〜3の間で均等に分散させること（同じ位置に偏らないよう注意）
+"""
+
+    # 優先ジャンル指定を追加
+    if priority_genres:
+        prompt += "\n## 出題優先ジャンル\n"
+        prompt += "以下のジャンルからの出題を優先してください（出題が少ない分野）:\n"
+        for subject in subjects:
+            if subject in priority_genres and priority_genres[subject]:
+                subject_name = SUBJECT_NAMES.get(subject, subject)
+                genres = priority_genres[subject][:5]  # 上位5ジャンル
+                prompt += f"- {subject_name}: {', '.join(genres)}\n"
+
+    # 除外キーワード指定を追加
+    if exclude_keywords and len(exclude_keywords) > 0:
+        prompt += "\n## 除外キーワード\n"
+        prompt += "以下のキーワード・トピックに関する問題は避けてください（直近で出題済み）:\n"
+        prompt += f"{', '.join(exclude_keywords[:30])}\n"
+
+    return prompt

V1.7.1/src/prompts/validation_prompts.py

@@ -0,0 +1,164 @@
+"""
+問題検証プロンプト定義
+生成された問題の品質を検証し、必要に応じて修正する
+"""
+
+import json
+from typing import List, Dict
+
+SUBJECT_NAMES = {
+    "jp": "国語",
+    "math": "算数",
+    "sci": "理科",
+    "soc": "社会"
+}
+
+
+def get_validation_prompt(subject: str, questions: List[Dict]) -> str:
+    """
+    問題検証プロンプトを構築
+
+    Args:
+        subject: 教科コード
+        questions: 検証対象の問題リスト
+
+    Returns:
+        完成したプロンプト
+    """
+    subject_name = SUBJECT_NAMES.get(subject, subject)
+
+    prompt = f"""あなたは中学受験問題の品質検証専門家です。
+
+## タスク
+以下の{subject_name}の問題を検証し、問題があれば修正してください。
+
+## 検証観点
+1. **正確性**: 正解が本当に正解か（学術的・事実として正しいか）
+2. **整合性**: 問題文・選択肢・解説に矛盾がないか
+3. **明確性**: 問題文が曖昧でなく、一意に解答を特定できるか
+4. **選択肢品質**: 明らかに間違いとわかる選択肢や、紛らわしすぎる選択肢がないか
+5. **適切性**: 中学受験レベルとして適切か（小学生に理解可能か）
+6. **解説の正確性**: 解説が正解を正しく説明しているか
+7. **正解位置の分散**: correct_answerが0〜3の間で偏っていないか確認し、偏りがある場合は選択肢の順序を入れ替えてcorrect_answerを分散させること
+
+## 入力（検証対象の問題）
+```json
+{json.dumps(questions, ensure_ascii=False, indent=2)}
+```
+
+## 出力形式
+各問題について、修正が必要かどうかを判定し、以下のJSON形式で出力してください。
+
+- 問題に問題がなければ `"modified": false` でそのまま返す
+- 修正が必要な場合は `"modified": true` で修正版を返す
+
+```json
+[
+  {{
+    "index": 0,
+    "modified": false,
+    "question": {{問題をそのまま含める}}
+  }},
+  {{
+    "index": 1,
+    "modified": true,
+    "modification_reason": "正解番号が誤っていたため修正（正解は選択肢2の「...」）",
+    "question": {{修正後の問題}}
+  }}
+]
+```
+
+## 重要
+- すべての問題を検証し、結果を出力すること
+- 修正は必要最小限にとどめること（過剰な修正は避ける）
+- 修正理由は具体的に記述すること
+- 元の問題の意図やカテゴリは変更しないこと
+"""
+
+    return prompt
+
+
+def get_batch_validation_prompt(questions_by_subject: Dict[str, List[Dict]]) -> str:
+    """
+    複数教科の問題を一括検証するプロンプトを構築
+
+    Args:
+        questions_by_subject: 教科別問題辞書 {"jp": [...], "math": [...], ...}
+
+    Returns:
+        複数教科一括検証用プロンプト
+    """
+    # 全問題を教科名とインデックスで識別できる形式に整形
+    all_questions = []
+    for subject, questions in questions_by_subject.items():
+        subject_name = SUBJECT_NAMES.get(subject, subject)
+        for idx, question in enumerate(questions):
+            all_questions.append({
+                "subject": subject,
+                "subject_name": subject_name,
+                "index": idx,
+                "question": question
+            })
+
+    total_count = len(all_questions)
+    subject_summary = ", ".join([
+        f"{SUBJECT_NAMES.get(subj, subj)}{len(questions)}問"
+        for subj, questions in questions_by_subject.items()
+    ])
+
+    prompt = f"""あなたは中学受験問題の品質検証専門家です。
+
+## タスク
+複数教科の問題（合計{total_count}問）を一括で検証し、問題があれば修正してください。
+
+**対象**: {subject_summary}
+
+## 検証観点
+1. **正確性**: 正解が本当に正解か（学術的・事実として正しいか）
+2. **整合性**: 問題文・選択肢・解説に矛盾がないか
+3. **明確性**: 問題文が曖昧でなく、一意に解答を特定できるか
+4. **選択肢品質**: 明らかに間違いとわかる選択肢や、紛らわしすぎる選択肢がないか
+5. **適切性**: 中学受験レベルとして適切か（小学生に理解可能か）
+6. **解説の正確性**: 解説が正解を正しく説明しているか
+7. **正解位置の分散**: correct_answerが0〜3の間で偏っていないか確認し、偏りがある場合は選択肢の順序を入れ替えてcorrect_answerを分散させること
+
+## 入力（検証対象の問題）
+```json
+{json.dumps(all_questions, ensure_ascii=False, indent=2)}
+```
+
+## 出力形式
+各問題について、修正が必要かどうかを判定し、以下のJSON形式で出力してください。
+
+**重要**: 各問題には必ず `subject` と `index` を含め、どの教科の何番��の問題かを明示すること。
+
+- 問題に問題がなければ `"modified": false` でそのまま返す
+- 修正が必要な場合は `"modified": true` で修正版を返す
+
+```json
+[
+  {{
+    "subject": "jp",
+    "index": 0,
+    "modified": false,
+    "question": {{問題をそのまま含める}}
+  }},
+  {{
+    "subject": "math",
+    "index": 3,
+    "modified": true,
+    "modification_reason": "正解番号が誤っていたため修正（正解は選択肢2の「...」）",
+    "question": {{修正後の問題}}
+  }}
+]
+```
+
+## 重要
+- **すべての問題**（合計{total_count}問）を検証し、結果を出力すること
+- 各問題に `subject` と `index` を必ず含めること
+- 修正は必要最小限にとどめること（過剰な修正は避ける）
+- 修正理由は具体的に記述すること
+- 元の問題の意図やカテゴリは変更しないこと
+"""
+
+    return prompt

V1.7.1/src/services/__init__.py

@@ -0,0 +1 @@
+# Services

V1.7.1/src/services/auth_service.py

@@ -0,0 +1,89 @@
+"""
+認証サービス - パスワードハッシュ化・検証
+
+bcryptを使用した安全なパスワード管理機能を提供
+"""
+import bcrypt
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class AuthService:
+    """認証関連のサービス - パスワードハッシュ化と検証"""
+
+    @staticmethod
+    def hash_password(password: str) -> str:
+        """
+        パスワードをbcryptでハッシュ化
+
+        Args:
+            password: 平文パスワード
+
+        Returns:
+            str: ハッシュ化されたパスワード（UTF-8文字列）
+
+        Raises:
+            ValueError: パスワードが空文字列の場合
+        """
+        if not password or not password.strip():
+            raise ValueError("Password cannot be empty")
+
+        try:
+            # ソルト生成とハッシュ化
+            salt = bcrypt.gensalt()
+            hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
+            return hashed.decode('utf-8')
+        except Exception as e:
+            logger.error(f"Password hashing error: {e}")
+            raise
+
+    @staticmethod
+    def verify_password(password: str, hashed: str) -> bool:
+        """
+        パスワードを検証
+
+        Args:
+            password: 平文パスワード
+            hashed: ハッシュ化されたパスワード
+
+        Returns:
+            bool: パスワードが一致すればTrue、それ以外はFalse
+        """
+        if not password or not hashed:
+            logger.warning("verify_password: Empty password or hash provided")
+            return False
+
+        try:
+            return bcrypt.checkpw(
+                password.encode('utf-8'),
+                hashed.encode('utf-8')
+            )
+        except Exception as e:
+            logger.error(f"Password verification error: {e}")
+            return False
+
+    @staticmethod
+    def validate_password_strength(password: str) -> tuple[bool, Optional[str]]:
+        """
+        パスワード強度を検証（オプション）
+
+        Args:
+            password: 検証するパスワード
+
+        Returns:
+            tuple[bool, Optional[str]]: (検証結果, エラーメッセージ)
+        """
+        if not password:
+            return False, "パスワードが空です"
+
+        if len(password) < 8:
+            return False, "パスワードは8文字以上必要です"
+
+        # 追加の強度チェック（必要に応じて）
+        # has_upper = any(c.isupper() for c in password)
+        # has_lower = any(c.islower() for c in password)
+        # has_digit = any(c.isdigit() for c in password)
+
+        return True, None