Merge remote-tracking branch 'origin/main' into feature/361

Reviewed-on: #368
Co-authored-by: miteruzo <miteruzo@naver.com>
Co-committed-by: miteruzo <miteruzo@naver.com>

AGENTS.md

@@ -158,6 +158,13 @@ npm run preview
 - Keep page-level code under `frontend/src/pages` and shared UI/feature code
   under `frontend/src/components` unless existing patterns point elsewhere.
 - Match existing Tailwind, component, and import alias conventions.
+- In TypeScript and TSX, prefer direct comparison operators such as `===` and
+  `!==` over negating a comparison like `!(a === b)`.
+- In TypeScript and TSX, prefer `++i` or `--i` over `i += 1` or `i -= 1` for
+  simple unit-step counter updates.
+- For user-facing Japanese text, prefer modern kana usage and natural current
+  phrasing over historical spellings or awkward literal wording.
+- For user-facing Japanese ellipses, prefer `……` over ASCII `...`.
 
 ### Frontend TSX style
 
@@ -179,6 +186,9 @@ npm run preview
   single physical line.
 - Always add braces around `if`, `else`, or `for` bodies when the body spans
   two or more physical lines, even if it is one statement.
+- Do not use a leading semicolon for expression statements such as
+  `;([...]).forEach(...)`; rewrite the expression to avoid ASI hazards
+  explicitly, for example with `void`.
 
 Preferred:
 

backend/app/controllers/gekanator_games_controller.rb

@@ -1,6 +1,6 @@
 class GekanatorGamesController < ApplicationController
   def create
-    return head :not_found unless current_user&.admin?
+    return head :unauthorized unless current_user
 
     guessed_post_id = params.require(:guessed_post_id)
     correct_post_id = params[:correct_post_id].presence
@@ -22,39 +22,29 @@ class GekanatorGamesController < ApplicationController
   end
 
   def extra_questions
-    return head :not_found unless current_user&.admin?
+    game = find_owned_game
+    return if performed?
 
-    game = GekanatorGame.find_by(id: params[:id])
-    return head :not_found unless game
-
-    asked_ids = Array(game.answers).filter_map { |answer| answer_question_id(answer) }
-    existing_example_ids =
-        GekanatorQuestionExample.where(post_id: game.correct_post_id)
-                                .select(:gekanator_question_id)
-    # Direct examples only for now; post_similarity-based expansion is deferred.
     questions =
         GekanatorQuestion
         .accepted
+        .includes(:gekanator_question_examples)
         .where(kind: 'post_similarity', source: 'user_suggested')
-        .where.not(id: existing_example_ids)
-        .order(priority_weight: :desc, id: :asc)
+        .to_a
+
+    selected = weighted_sample_questions(
+        questions,
+        post_id: game.correct_post_id,
+        limit: 2)
 
     render json: {
-      questions: questions.filter_map { |question|
-        json = extra_question_json(question)
-        next if asked_ids.include?(json[:id].to_s)
-        next if asked_ids.include?("post-similarity:#{ json[:id] }")
-
-        json
-      }.first(2)
+      questions: selected.map { |question| extra_question_json(question) }
     }
   end
 
   def extra_question_answers
-    return head :not_found unless current_user&.admin?
-
-    game = GekanatorGame.find_by(id: params[:id])
-    return head :not_found unless game
+    game = find_owned_game
+    return if performed?
 
     answer_params = params.require(:answers)
     if !answer_params.is_a?(Array)
@@ -84,11 +74,10 @@ class GekanatorGamesController < ApplicationController
                 gekanator_question: question,
                 post: game.correct_post,
                 user: current_user)
-        example.assign_attributes(
-            gekanator_game: game,
+        example.record_answer!(
             answer: item[:answer],
             source: 'post_game_extra',
-            weight: 1.0)
+            gekanator_game: game)
         example.save!
       end
     end
@@ -107,12 +96,53 @@ class GekanatorGamesController < ApplicationController
     }
   end
 
-  def answer_question_id answer
-    value = if answer.is_a?(Hash)
-      answer['question_id'].presence || answer[:question_id].presence ||
-        answer['questionId'].presence || answer[:questionId].presence
+  def weighted_sample_questions questions, post_id:, limit:
+    remaining = questions.uniq(&:id)
+    selected = []
+
+    while selected.length < limit && remaining.any?
+      weighted =
+          remaining.map { |question|
+            [question, selection_weight_for(question, post_id: post_id)]
+          }
+      total_weight = weighted.sum { |_question, weight| weight }
+      break if total_weight <= 0
+
+      target = rand * total_weight
+      cumulative = 0.0
+      chosen =
+          weighted.find do |_question, weight|
+            cumulative += weight
+            cumulative >= target
+          end&.first || weighted.first.first
+
+      selected << chosen
+      remaining.reject! { |question| question.id == chosen.id }
     end
 
-    value&.to_s
+    selected
+  end
+
+  def selection_weight_for question, post_id:
+    sample_count =
+        question.gekanator_question_examples.sum { |example|
+          next 0 unless example.post_id == post_id
+
+          example.sample_count.presence || 1
+        }
+
+    question.priority_weight.to_f / (1.0 + sample_count * 0.15)
+  end
+
+  def find_owned_game
+    return head :unauthorized unless current_user
+
+    game = GekanatorGame.find_by(id: params[:id])
+    return head :not_found unless game
+    if !current_user.admin? && game.user_id != current_user.id
+      return head :not_found
+    end
+
+    game
   end
 end

backend/app/controllers/gekanator_posts_controller.rb

@@ -1,7 +1,5 @@
 class GekanatorPostsController < ApplicationController
   def index
-    return head :not_found unless current_user&.admin?
-
     posts =
         Post
         .preload(tags: :tag_name)

backend/app/controllers/gekanator_question_suggestions_controller.rb

@@ -1,9 +1,12 @@
 class GekanatorQuestionSuggestionsController < ApplicationController
   def create
-    return head :not_found unless current_user&.admin?
+    return head :unauthorized unless current_user
 
     game = GekanatorGame.find_by(id: params.require(:gekanator_game_id))
     return head :not_found unless game
+    if !current_user.admin? && game.user_id != current_user.id
+      return head :not_found
+    end
 
     suggestion = GekanatorQuestionSuggestion.new(
         gekanator_game: game,

backend/app/controllers/gekanator_questions_controller.rb

@@ -1,7 +1,5 @@
 class GekanatorQuestionsController < ApplicationController
   def index
-    return head :not_found unless current_user&.admin?
-
     questions =
         GekanatorQuestion
         .accepted
@@ -49,6 +47,8 @@ class GekanatorQuestionsController < ApplicationController
       "title:length-at-least:#{ condition[:length].to_i + 1 }"
     when 'title-has-ascii'
       'title:ascii'
+    when 'title-contains'
+      "title:contains:#{ condition[:text] }"
     when 'post-similarity'
       "post-similarity:#{ question.id }"
     else
@@ -77,6 +77,8 @@ class GekanatorQuestionsController < ApplicationController
     case condition[:type]
     when 'title-length-at-least'
       "タイトルは #{ condition[:length] } 文字以上?"
+    when 'title-contains'
+      "題名に「#{ condition[:text] }」が含まれる?"
     else
       question.text
     end

backend/app/models/gekanator_question_example.rb

@@ -1,5 +1,6 @@
 class GekanatorQuestionExample < ApplicationRecord
   ANSWERS = GekanatorQuestionSuggestion::ANSWERS
+  NON_UNKNOWN_ANSWERS = ANSWERS - ['unknown']
   SOURCES = ['initial_suggestion', 'post_game_extra'].freeze
 
   belongs_to :gekanator_question
@@ -8,10 +9,89 @@ class GekanatorQuestionExample < ApplicationRecord
   belongs_to :gekanator_game, optional: true
 
   validates :answer, presence: true, inclusion: { in: ANSWERS }
+  validates :answer_counts, presence: true
+  validates :sample_count,
+            presence: true,
+            numericality: {
+              only_integer: true,
+              greater_than: 0
+            }
   validates :source, presence: true, inclusion: { in: SOURCES }
   validates :weight,
             presence: true,
             numericality: {
               greater_than: 0
             }
+
+  before_validation :normalize_learning_state
+
+  def record_answer!(answer:, source:, gekanator_game: nil)
+    answer = answer.to_s
+    raise ArgumentError, 'invalid answer' unless ANSWERS.include?(answer)
+
+    counts = normalized_answer_counts
+    counts[answer] += 1
+
+    self.answer_counts = counts
+    self.sample_count = counts.values.sum
+    self.gekanator_game = gekanator_game if gekanator_game.present?
+    self.source = source if new_record?
+
+    apply_aggregated_answer!(preferred_answer: answer)
+    self
+  end
+
+  private
+
+  def normalize_learning_state
+    counts = normalized_answer_counts
+
+    if counts.values.sum.zero? && answer.present?
+      counts[answer] = 1
+    end
+
+    self.answer_counts = counts
+    self.sample_count = counts.values.sum
+
+    apply_aggregated_answer!
+  end
+
+  def apply_aggregated_answer!(preferred_answer: nil)
+    counts = normalized_answer_counts
+    known_counts = counts.slice(*NON_UNKNOWN_ANSWERS)
+    known_total = known_counts.values.sum
+
+    if known_total.zero?
+      self.answer = 'unknown'
+      self.weight = 0.1
+      return
+    else
+      max_count = known_counts.values.max
+      candidates = known_counts.select { |_answer, count| count == max_count }.keys
+      self.answer =
+          if preferred_answer.present? && candidates.include?(preferred_answer)
+            preferred_answer
+          elsif answer.present? && candidates.include?(answer)
+            answer
+          else
+            candidates.first
+          end
+    end
+
+    consensus = max_count.to_f / known_total
+    self.weight = Math.sqrt(known_total) * consensus
+  end
+
+  def normalized_answer_counts
+    base = ANSWERS.index_with(0)
+
+    answer_counts.to_h.each do |key, value|
+      answer_key = key.to_s
+      next unless ANSWERS.include?(answer_key)
+
+      base[answer_key] = value.to_i
+    end
+
+    base
+  end
 end

backend/app/services/gekanator/question_suggestion_ai_converter.rb

@@ -1,5 +1,15 @@
 module Gekanator
   class QuestionSuggestionAiConverter
+    # Temporary heuristic converter for #361.
+    # This creates pending ai_generated questions without external LLM calls;
+    # accepted questions are still distributed only after admin approval.
+    TITLE_LENGTH_RE = /\Aタイトルは\s*(\d+)\s*文字以上[？?]\z/
+    ORIGINAL_YEAR_RE = /\Aオリジナルの投稿年は\s*(\d{4})\s*年[？?]\z/
+    ORIGINAL_MONTH_RE = /\Aオリジナルの投稿月は\s*(\d{1,2})\s*月[？?]\z/
+    ORIGINAL_MONTH_DAY_RE = /\Aオリジナルの投稿日は\s*(\d{1,2})\s*月\s*(\d{1,2})\s*日[？?]\z/
+    TITLE_CONTAINS_RE = /\A題名に「(.+?)」が含まれる[？?]\z/
+    SOURCE_RE = /\A(.+?)\s+の投稿を思[ひい]浮かべて[ゐい]る[？?]\z/
+
     def self.call(...) = new(...).call
 
     def initialize suggestion:, user:
@@ -8,11 +18,151 @@ module Gekanator
     end
 
     def call
-      raise NotImplementedError, 'AI question conversion is not implemented yet.'
+      suggestion.with_lock do
+        existing = existing_generated_question
+        return existing if existing
+
+        run = suggestion.gekanator_ai_runs.create!(
+            model: 'heuristic_converter_v1',
+            status: 'running',
+            input_tokens: 0,
+            output_tokens: 0,
+            estimated_cost_jpy: 0)
+
+        question_attributes = build_question
+        question =
+            question_attributes &&
+            GekanatorQuestion.create!(
+                **question_attributes,
+                source: 'ai_generated',
+                status: 'pending',
+                gekanator_question_suggestion: suggestion,
+                created_by: user)
+
+        run.update!(status: question ? 'succeeded' : 'failed')
+        question
+      end
+    rescue => error
+      run&.update!(status: 'failed') if run&.persisted? && run.status != 'failed'
+      raise error
     end
 
     private
 
     attr_reader :suggestion, :user
+
+    def existing_generated_question
+      suggestion
+          .gekanator_questions
+          .where(source: 'ai_generated')
+          .order(id: :desc)
+          .first
+    end
+
+    def build_question
+      text = normalized_text
+      return nil if text.blank?
+
+      structured_question_for(text) || post_similarity_question_for(text)
+    end
+
+    def normalized_text
+      suggestion.question_text.to_s.gsub(/[[:space:]]+/, ' ').strip
+    end
+
+    def structured_question_for text
+      case text
+      when TITLE_LENGTH_RE
+        length = Regexp.last_match(1).to_i
+        return nil if length <= 0
+
+        {
+          text:,
+          kind: 'title',
+          condition: {
+            type: 'title-length-at-least',
+            length:
+          },
+          priority_weight: 0.95
+        }
+      when /\A題名に英数字が混じって[ゐい]る[？?]\z/
+        {
+          text: '題名に英数字が混じってゐる?',
+          kind: 'title',
+          condition: { type: 'title-has-ascii' },
+          priority_weight: 0.95
+        }
+      when ORIGINAL_YEAR_RE
+        year = Regexp.last_match(1).to_i
+        {
+          text:,
+          kind: 'original_date',
+          condition: { type: 'original-year', year: },
+          priority_weight: 0.95
+        }
+      when ORIGINAL_MONTH_RE
+        month = Regexp.last_match(1).to_i
+        return nil unless month.between?(1, 12)
+
+        {
+          text:,
+          kind: 'original_date',
+          condition: { type: 'original-month', month: },
+          priority_weight: 0.95
+        }
+      when ORIGINAL_MONTH_DAY_RE
+        month = Regexp.last_match(1).to_i
+        day = Regexp.last_match(2).to_i
+        return nil unless month.between?(1, 12) && day.between?(1, 31)
+
+        {
+          text:,
+          kind: 'original_date',
+          condition: {
+            type: 'original-month-day',
+            monthDay: "#{ month }-#{ day }"
+          },
+          priority_weight: 0.95
+        }
+      when TITLE_CONTAINS_RE
+        title_text = Regexp.last_match(1).to_s.strip
+        return nil if title_text.blank?
+
+        {
+          text: "題名に「#{ title_text }」が含まれる?",
+          kind: 'title',
+          condition: { type: 'title-contains', text: title_text },
+          priority_weight: 0.95
+        }
+      when SOURCE_RE
+        host = Regexp.last_match(1).to_s.strip
+        return nil if host.blank?
+
+        {
+          text:,
+          kind: 'source',
+          condition: { type: 'source', host: },
+          priority_weight: 0.95
+        }
+      else
+        nil
+      end
+    end
+
+    def post_similarity_question_for text
+      return nil if suggestion.answer == 'unknown'
+
+      {
+        text:,
+        kind: 'post_similarity',
+        condition: {
+          type: 'post-similarity',
+          postId: suggestion.gekanator_game.correct_post_id,
+          answer: suggestion.answer,
+          threshold: 0.65
+        },
+        priority_weight: 1.0
+      }
+    end
   end
 end

backend/app/services/gekanator/question_suggestion_promoter.rb

@@ -26,13 +26,16 @@ module Gekanator
             },
             gekanator_question_suggestion: suggestion,
             created_by: user)
-        GekanatorQuestionExample.create!(
-            gekanator_question: question,
-            post: suggestion.gekanator_game.correct_post,
-            user: user,
-            gekanator_game: suggestion.gekanator_game,
+        example =
+            GekanatorQuestionExample.new(
+                gekanator_question: question,
+                post: suggestion.gekanator_game.correct_post,
+                user: user)
+        example.record_answer!(
             answer: suggestion.answer,
-            source: 'initial_suggestion')
+            source: 'initial_suggestion',
+            gekanator_game: suggestion.gekanator_game)
+        example.save!
         suggestion.update!(processed: true)
         question
       end

backend/db/migrate/20260612000000_add_answer_statistics_to_gekanator_question_examples.rb

@@ -0,0 +1,40 @@
+class AddAnswerStatisticsToGekanatorQuestionExamples < ActiveRecord::Migration[8.0]
+  class MigrationGekanatorQuestionExample < ApplicationRecord
+    self.table_name = 'gekanator_question_examples'
+  end
+
+  def up
+    add_column :gekanator_question_examples,
+               :answer_counts,
+               :json,
+               null: true
+    add_column :gekanator_question_examples,
+               :sample_count,
+               :integer,
+               null: false,
+               default: 1
+
+    MigrationGekanatorQuestionExample.reset_column_information
+    MigrationGekanatorQuestionExample.find_each do |example|
+      counts = {
+        'yes' => 0,
+        'no' => 0,
+        'partial' => 0,
+        'probably_no' => 0,
+        'unknown' => 0
+      }
+      counts[example.answer] = 1 if counts.key?(example.answer)
+
+      example.update_columns(
+        answer_counts: counts,
+        sample_count: 1)
+    end
+
+    change_column_null :gekanator_question_examples, :answer_counts, false
+  end
+
+  def down
+    remove_column :gekanator_question_examples, :sample_count
+    remove_column :gekanator_question_examples, :answer_counts
+  end
+end

backend/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.0].define(version: 2026_06_10_000000) do
+ActiveRecord::Schema[8.0].define(version: 2026_06_12_000000) do
   create_table "active_storage_attachments", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.string "name", null: false
     t.string "record_type", null: false
@@ -85,6 +85,8 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_10_000000) do
     t.float "weight", default: 1.0, null: false
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
+    t.json "answer_counts", null: false
+    t.integer "sample_count", default: 1, null: false
     t.index ["gekanator_game_id"], name: "index_gekanator_question_examples_on_gekanator_game_id"
     t.index ["gekanator_question_id", "post_id", "user_id"], name: "idx_gekanator_question_examples_on_question_post_user", unique: true
     t.index ["gekanator_question_id"], name: "index_gekanator_question_examples_on_gekanator_question_id"

backend/spec/requests/gekanator_games_spec.rb

@@ -52,16 +52,16 @@ RSpec.describe 'Gekanator games API', type: :request do
       expect(response).to have_http_status(:unprocessable_entity)
     end
 
-    it 'returns not found without an admin user' do
+    it 'returns unauthorized without a user' do
       post '/gekanator/games', params: {
           guessed_post_id: guessed_post.id,
           correct_post_id: guessed_post.id,
           answers: [] }
 
-      expect(response).to have_http_status(:not_found)
+      expect(response).to have_http_status(:unauthorized)
     end
 
-    it 'returns not found for a non-admin user' do
+    it 'stores a game for a non-admin user' do
       sign_in_as user
 
       post '/gekanator/games', params: {
@@ -69,7 +69,8 @@ RSpec.describe 'Gekanator games API', type: :request do
           correct_post_id: guessed_post.id,
           answers: [{ question_id: 'tag:1', answer: 'yes' }] }
 
-      expect(response).to have_http_status(:not_found)
+      expect(response).to have_http_status(:created)
+      expect(GekanatorGame.find(json['id']).user).to eq(user)
     end
   end
 end

backend/spec/requests/gekanator_learning_spec.rb

@@ -129,7 +129,7 @@ RSpec.describe 'Gekanator learning API', type: :request do
       expect(response).to have_http_status(:unprocessable_entity)
     end
 
-    it 'returns not found for a non-admin user' do
+    it 'stores a game result for a non-admin user' do
       sign_in_as member
 
       post '/gekanator/games', params: {
@@ -138,7 +138,18 @@ RSpec.describe 'Gekanator learning API', type: :request do
         answers: []
       }
 
-      expect(response).to have_http_status(:not_found)
+      expect(response).to have_http_status(:created)
+      expect(GekanatorGame.find(json['id']).user).to eq(member)
+    end
+
+    it 'returns unauthorized without a user' do
+      post '/gekanator/games', params: {
+        guessed_post_id: guessed_post.id,
+        correct_post_id: correct_post.id,
+        answers: []
+      }
+
+      expect(response).to have_http_status(:unauthorized)
     end
   end
 
@@ -261,21 +272,61 @@ RSpec.describe 'Gekanator learning API', type: :request do
       expect(response).to have_http_status(:unprocessable_entity)
     end
 
-    it 'returns not found for a non-admin user' do
+    it 'allows a non-admin user to suggest a question for their own game' do
+      member_game = GekanatorGame.create!(
+        user: member,
+        guessed_post: guessed_post,
+        correct_post: correct_post,
+        won: false,
+        question_count: 1,
+        answers: [{ 'question_id' => 'tag:1', 'answer' => 'yes' }]
+      )
       sign_in_as member
 
-      post '/gekanator/question_suggestions', params: {
-        gekanator_game_id: game.id,
-        question_text: 'member question?',
-        answer: 'yes'
-      }
+      expect {
+        post '/gekanator/question_suggestions', params: {
+          gekanator_game_id: member_game.id,
+          question_text: 'member question?',
+          answer: 'yes'
+        }
+      }.to change { GekanatorQuestionSuggestion.count }.by(1)
+
+      expect(response).to have_http_status(:created)
+      expect(GekanatorQuestionSuggestion.last).to have_attributes(
+        gekanator_game_id: member_game.id,
+        user_id: member.id
+      )
+    end
+
+    it 'returns not found for another user game' do
+      sign_in_as member
+
+      expect {
+        post '/gekanator/question_suggestions', params: {
+          gekanator_game_id: game.id,
+          question_text: 'member question?',
+          answer: 'yes'
+        }
+      }.not_to change { GekanatorQuestionSuggestion.count }
 
       expect(response).to have_http_status(:not_found)
     end
+
+    it 'returns unauthorized without a user' do
+      expect {
+        post '/gekanator/question_suggestions', params: {
+          gekanator_game_id: game.id,
+          question_text: 'member question?',
+          answer: 'yes'
+        }
+      }.not_to change { GekanatorQuestionSuggestion.count }
+
+      expect(response).to have_http_status(:unauthorized)
+    end
   end
 
   describe 'GET /gekanator/games/:id/extra_questions' do
-    it 'returns at most two accepted user_suggested post_similarity questions' do
+    it 'returns at most two accepted user_suggested post_similarity questions without duplicates' do
       sign_in_as admin
 
       low = create_post_similarity_question!(
@@ -295,15 +346,14 @@ RSpec.describe 'Gekanator learning API', type: :request do
 
       expect(response).to have_http_status(:ok)
       expect(json['questions'].length).to eq(2)
-      expect(json['questions'].map { _1['id'] }).to eq([high.id, middle.id])
-      expect(json['questions'].map { _1['id'] }).not_to include(low.id)
+      expect(json['questions'].map { _1['id'] }.uniq.length).to eq(2)
+      expect(json['questions'].map { _1['id'] }).to all(be_in([low.id, high.id, middle.id]))
     end
 
-    it 'does not return questions that already have an example for the correct post' do
+    it 'can return questions that already have an example for the correct post' do
       sign_in_as admin
 
       existing = create_post_similarity_question!(text: 'already learned?')
-      fresh = create_post_similarity_question!(text: 'fresh?')
 
       GekanatorQuestionExample.create!(
         gekanator_question: existing,
@@ -317,15 +367,13 @@ RSpec.describe 'Gekanator learning API', type: :request do
       get "/gekanator/games/#{game.id}/extra_questions"
 
       expect(response).to have_http_status(:ok)
-      expect(json['questions'].map { _1['id'] }).to include(fresh.id)
-      expect(json['questions'].map { _1['id'] }).not_to include(existing.id)
+      expect(json['questions'].map { _1['id'] }).to include(existing.id)
     end
 
-    it 'does not return questions already asked in the game using snake_case question_id' do
+    it 'can return questions already asked in the game using snake_case question_id' do
       sign_in_as admin
 
       asked = create_post_similarity_question!(text: 'already asked?')
-      fresh = create_post_similarity_question!(text: 'fresh?')
       game.update!(
         answers: [
           {
@@ -338,15 +386,13 @@ RSpec.describe 'Gekanator learning API', type: :request do
       get "/gekanator/games/#{game.id}/extra_questions"
 
       expect(response).to have_http_status(:ok)
-      expect(json['questions'].map { _1['id'] }).to include(fresh.id)
-      expect(json['questions'].map { _1['id'] }).not_to include(asked.id)
+      expect(json['questions'].map { _1['id'] }).to include(asked.id)
     end
 
-    it 'does not return questions already asked in the game using camelCase questionId' do
+    it 'can return questions already asked in the game using camelCase questionId' do
       sign_in_as admin
 
       asked = create_post_similarity_question!(text: 'already asked?')
-      fresh = create_post_similarity_question!(text: 'fresh?')
       game.update!(
         answers: [
           {
@@ -359,8 +405,7 @@ RSpec.describe 'Gekanator learning API', type: :request do
       get "/gekanator/games/#{game.id}/extra_questions"
 
       expect(response).to have_http_status(:ok)
-      expect(json['questions'].map { _1['id'] }).to include(fresh.id)
-      expect(json['questions'].map { _1['id'] }).not_to include(asked.id)
+      expect(json['questions'].map { _1['id'] }).to include(asked.id)
     end
 
     it 'does not return non-accepted, non-user_suggested, or non-post_similarity questions' do
@@ -383,6 +428,38 @@ RSpec.describe 'Gekanator learning API', type: :request do
       expect(response).to have_http_status(:ok)
       expect(json['questions'].map { _1['id'] }).to contain_exactly(accepted.id)
     end
+
+    it 'allows a non-admin user to fetch extra questions for their own game' do
+      member_game = GekanatorGame.create!(
+        user: member,
+        guessed_post: guessed_post,
+        correct_post: correct_post,
+        won: false,
+        question_count: 1,
+        answers: [{ 'question_id' => 'tag:1', 'answer' => 'yes' }]
+      )
+      accepted = create_post_similarity_question!(text: 'accepted?')
+      sign_in_as member
+
+      get "/gekanator/games/#{member_game.id}/extra_questions"
+
+      expect(response).to have_http_status(:ok)
+      expect(json['questions'].map { _1['id'] }).to include(accepted.id)
+    end
+
+    it 'returns not found for another user game' do
+      sign_in_as member
+
+      get "/gekanator/games/#{game.id}/extra_questions"
+
+      expect(response).to have_http_status(:not_found)
+    end
+
+    it 'returns unauthorized without a user' do
+      get "/gekanator/games/#{game.id}/extra_questions"
+
+      expect(response).to have_http_status(:unauthorized)
+    end
   end
 
   describe 'POST /gekanator/games/:id/extra_question_answers' do
@@ -509,6 +586,69 @@ RSpec.describe 'Gekanator learning API', type: :request do
 
       expect(response).to have_http_status(:unprocessable_entity)
     end
+
+    it 'allows a non-admin user to answer extra questions for their own game' do
+      member_game = GekanatorGame.create!(
+        user: member,
+        guessed_post: guessed_post,
+        correct_post: correct_post,
+        won: false,
+        question_count: 1,
+        answers: [{ 'question_id' => 'tag:1', 'answer' => 'yes' }]
+      )
+      question = create_post_similarity_question!(text: 'extra?')
+      sign_in_as member
+
+      expect {
+        post "/gekanator/games/#{member_game.id}/extra_question_answers", params: {
+          answers: [
+            {
+              question_id: question.id,
+              answer: 'yes'
+            }
+          ]
+        }
+      }.to change { GekanatorQuestionExample.count }.by(1)
+
+      expect(response).to have_http_status(:created)
+      expect(GekanatorQuestionExample.last).to have_attributes(
+        user_id: member.id,
+        gekanator_game_id: member_game.id
+      )
+    end
+
+    it 'returns not found for another user game' do
+      question = create_post_similarity_question!(text: 'extra?')
+      sign_in_as member
+
+      expect {
+        post "/gekanator/games/#{game.id}/extra_question_answers", params: {
+          answers: [
+            {
+              question_id: question.id,
+              answer: 'yes'
+            }
+          ]
+        }
+      }.not_to change { GekanatorQuestionExample.count }
+
+      expect(response).to have_http_status(:not_found)
+    end
+
+    it 'returns unauthorized without a user' do
+      question = create_post_similarity_question!(text: 'extra?')
+
+      post "/gekanator/games/#{game.id}/extra_question_answers", params: {
+        answers: [
+          {
+            question_id: question.id,
+            answer: 'yes'
+          }
+        ]
+      }
+
+      expect(response).to have_http_status(:unauthorized)
+    end
   end
 
   describe 'GET /gekanator/questions' do
@@ -584,5 +724,63 @@ RSpec.describe 'Gekanator learning API', type: :request do
         other_post.id.to_s => 'no'
       )
     end
+
+    it 'normalizes legacy title length questions' do
+      sign_in_as admin
+
+      GekanatorQuestion.create!(
+        text: '題名が長めの投稿?',
+        kind: 'title',
+        source: 'admin_curated',
+        status: 'accepted',
+        priority_weight: 1.0,
+        condition: {
+          type: 'title-length-greater-than',
+          length: 20
+        },
+        created_by: admin
+      )
+
+      get '/gekanator/questions'
+
+      expect(response).to have_http_status(:ok)
+      question_json = json['questions'].find { _1['id'] == 'title:length-at-least:21' }
+      expect(question_json).to include(
+        'text' => 'タイトルは 21 文字以上?',
+        'kind' => 'title'
+      )
+      expect(question_json['condition']).to include(
+        'type' => 'title-length-at-least',
+        'length' => 21
+      )
+    end
+
+    it 'returns title-contains questions without authentication' do
+      GekanatorQuestion.create!(
+        text: '題名に「結束バンド」が含まれる?',
+        kind: 'title',
+        source: 'ai_generated',
+        status: 'accepted',
+        priority_weight: 0.95,
+        condition: {
+          type: 'title-contains',
+          text: '結束バンド'
+        },
+        created_by: admin
+      )
+
+      get '/gekanator/questions'
+
+      expect(response).to have_http_status(:ok)
+      question_json = json['questions'].find { _1['id'] == 'title:contains:結束バンド' }
+      expect(question_json).to include(
+        'text' => '題名に「結束バンド」が含まれる?',
+        'kind' => 'title'
+      )
+      expect(question_json['condition']).to include(
+        'type' => 'title-contains',
+        'text' => '結束バンド'
+      )
+    end
   end
 end

backend/spec/services/gekanator/question_suggestion_ai_converter_spec.rb

@@ -0,0 +1,112 @@
+require 'rails_helper'
+
+RSpec.describe Gekanator::QuestionSuggestionAiConverter do
+  let(:user) { create(:user, :member) }
+  let(:guessed_post) { Post.create!(title: 'guess', url: 'https://example.com/guess') }
+  let(:correct_post) { Post.create!(title: 'correct', url: 'https://example.com/correct') }
+  let(:game) do
+    GekanatorGame.create!(
+      user: user,
+      guessed_post: guessed_post,
+      correct_post: correct_post,
+      won: false,
+      question_count: 1,
+      answers: [{ 'question_id' => 'tag:1', 'answer' => 'yes' }]
+    )
+  end
+
+  def create_suggestion!(question_text:, answer: 'yes')
+    GekanatorQuestionSuggestion.create!(
+      gekanator_game: game,
+      user: user,
+      question_text: question_text,
+      answer: answer
+    )
+  end
+
+  it 'converts title-contains suggestions to pending ai-generated questions' do
+    suggestion = create_suggestion!(question_text: '題名に「結束バンド」が含まれる?')
+
+    expect {
+      described_class.call(suggestion: suggestion, user: user)
+    }.to change { GekanatorQuestion.count }.by(1)
+      .and change { GekanatorAiRun.count }.by(1)
+
+    question = GekanatorQuestion.last
+    expect(question).to have_attributes(
+      text: '題名に「結束バンド」が含まれる?',
+      kind: 'title',
+      source: 'ai_generated',
+      status: 'pending',
+      priority_weight: 0.95,
+      gekanator_question_suggestion_id: suggestion.id,
+      created_by_id: user.id
+    )
+    expect(question.condition).to include(
+      'type' => 'title-contains',
+      'text' => '結束バンド'
+    )
+    expect(GekanatorAiRun.last).to have_attributes(
+      gekanator_question_suggestion_id: suggestion.id,
+      model: 'heuristic_converter_v1',
+      status: 'succeeded'
+    )
+  end
+
+  it 'converts concrete non-unknown suggestions to post-similarity questions' do
+    suggestion = create_suggestion!(
+      question_text: '喜多ちゃんが泣いてる?',
+      answer: 'partial'
+    )
+
+    question = described_class.call(suggestion: suggestion, user: user)
+
+    expect(question).to have_attributes(
+      text: '喜多ちゃんが泣いてる?',
+      kind: 'post_similarity',
+      source: 'ai_generated',
+      status: 'pending',
+      priority_weight: 1.0
+    )
+    expect(question.condition).to include(
+      'type' => 'post-similarity',
+      'postId' => correct_post.id,
+      'answer' => 'partial',
+      'threshold' => 0.65
+    )
+  end
+
+  it 'records a failed run when the suggestion cannot be converted' do
+    suggestion = create_suggestion!(
+      question_text: 'よく分からない質問?',
+      answer: 'unknown'
+    )
+
+    expect {
+      expect(described_class.call(suggestion: suggestion, user: user)).to be_nil
+    }.not_to change { GekanatorQuestion.count }
+
+    expect(GekanatorAiRun.last).to have_attributes(
+      gekanator_question_suggestion_id: suggestion.id,
+      status: 'failed'
+    )
+  end
+
+  it 'returns an existing generated question without creating a duplicate run' do
+    suggestion = create_suggestion!(question_text: 'タイトルは 10 文字以上?')
+    existing = GekanatorQuestion.create!(
+      text: 'タイトルは 10 文字以上?',
+      kind: 'title',
+      source: 'ai_generated',
+      status: 'pending',
+      priority_weight: 0.95,
+      condition: { type: 'title-length-at-least', length: 10 },
+      gekanator_question_suggestion: suggestion,
+      created_by: user
+    )
+
+    expect {
+      expect(described_class.call(suggestion: suggestion, user: user)).to eq(existing)
+    }.not_to change { GekanatorAiRun.count }
+  end
+end

frontend/src/App.tsx

@@ -40,7 +40,7 @@ import WikiHistoryPage from '@/pages/wiki/WikiHistoryPage'
 import WikiNewPage from '@/pages/wiki/WikiNewPage'
 import WikiSearchPage from '@/pages/wiki/WikiSearchPage'
 
-import type { Dispatch, FC, ReactNode, SetStateAction } from 'react'
+import type { Dispatch, FC, SetStateAction } from 'react'
 
 import type { User } from '@/types'
 
@@ -81,10 +81,7 @@ const RouteTransitionWrapper = ({ user, setUser }: {
 	  <Route path="/users/settings" element={<SettingPage user={user} setUser={setUser}/>}/>
 	  <Route path="/settings" element={<Navigate to="/users/settings" replace/>}/>
 	  <Route path="/tos" element={<TOSPage/>}/>
-	  <Route path="/gekanator" element={
-	      <AdminOnly user={user}>
-		<GekanatorPage/>
-	      </AdminOnly>}/>
+	  <Route path="/gekanator" element={<GekanatorPage user={user}/>}/>
 	  <Route path="/more" element={<MorePage/>}/>
 	  <Route path="*" element={<NotFound/>}/>
 	</Routes>
@@ -92,16 +89,6 @@ const RouteTransitionWrapper = ({ user, setUser }: {
 }
 
 
-const AdminOnly = ({ user, children }: {
-    user:      User | null
-    children:  ReactNode }) => {
-  if (user?.role !== 'admin')
-    return <NotFound/>
-
-  return <>{children}</>
-}
-
-
 const PostDetailRoute = ({ user }: { user: User | null }) => {
   const location = useLocation ()
   const key = location.pathname

frontend/src/components/TopNav.tsx

@@ -66,7 +66,8 @@ export const menuOutline = ({ tag, wikiId, user, pathName }: {
 	  { name: '履歴', to: `/wiki/changes?id=${ wikiId }`, visible: wikiPageFlg },
 	  { name: '編輯', to: `/wiki/${ wikiId || wikiTitle }/edit`, visible: wikiPageFlg }] },
       { name: 'おたのしみ', visible: false, subMenu: [
-	  { name: '上映会 (β)', to: '/theatres/1' }] },
+	  { name: '上映会 (β)', to: '/theatres/1' },
+	  { name: 'グカネータ (β)', to: '/gekanator' }] },
       { name: 'ユーザ', to: '/users/settings', visible: false, subMenu: [
 	  { name: '一覧', to: '/users', visible: false },
 	  { name: 'お前', to: `/users/${ user?.id }`, visible: false },

frontend/src/lib/gekanator.test.ts

@@ -2,7 +2,9 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { apiPost } from '@/lib/api'
 import {
+  buildGekanatorQuestions,
   expectedAnswerForQuestion,
+  questionIdForCondition,
   restoreGekanatorQuestion,
   saveGekanatorExtraQuestionAnswers,
   saveGekanatorGame,
@@ -146,6 +148,44 @@ describe('expectedAnswerForQuestion', () => {
 
     expect(expectedAnswerForQuestion(question, post({ tags: [] }))).toBe('no')
   })
+
+  it('ignores example answers for direct title facts', () => {
+    const question: StoredGekanatorQuestion = {
+      id: 'title:length-at-least:20',
+      text: 'タイトルは 20 文字以上?',
+      kind: 'title',
+      condition: {
+        type: 'title-length-at-least',
+        length: 20,
+      },
+      exampleAnswers: {
+        1: 'yes',
+      },
+    }
+
+    expect(expectedAnswerForQuestion(question, post({ id: 1, title: 'short' }))).toBe('no')
+  })
+
+  it('returns yes for matching title-contains questions', () => {
+    const question: StoredGekanatorQuestion = {
+      id: 'title:contains:結束バンド',
+      text: '題名に「結束バンド」が含まれる?',
+      kind: 'title',
+      condition: {
+        type: 'title-contains',
+        text: '結束バンド',
+      },
+    }
+
+    expect(expectedAnswerForQuestion(
+      question,
+      post({ title: '結束バンドのライブ' }),
+    )).toBe('yes')
+    expect(expectedAnswerForQuestion(
+      question,
+      post({ title: '後藤ひとりの休日' }),
+    )).toBe('no')
+  })
 })
 
 describe('restoreGekanatorQuestion', () => {
@@ -187,6 +227,133 @@ describe('restoreGekanatorQuestion', () => {
     expect(question.test(post({ id: 2 }))).toBe(false)
     expect(question.test(post({ id: 3 }))).toBe(false)
   })
+
+  it('tests a post_similarity question against its configured partial answer', () => {
+    const question = restoreGekanatorQuestion({
+      id: 'post-similarity:10',
+      text: '喜多ちゃんが泣いてる?',
+      kind: 'post_similarity',
+      source: 'user_suggested',
+      priorityWeight: 1.2,
+      condition: {
+        type: 'post-similarity',
+        postId: 999,
+        answer: 'partial',
+        threshold: 0.65,
+      },
+      exampleAnswers: {
+        1: 'partial',
+        2: 'yes',
+      },
+    })
+
+    expect(question.test(post({ id: 1 }))).toBe(true)
+    expect(question.test(post({ id: 2 }))).toBe(false)
+  })
+
+  it('normalizes legacy title-length-greater-than questions', () => {
+    const question = restoreGekanatorQuestion({
+      id: 'title:length-greater-than:20',
+      text: '題名が長めの投稿?',
+      kind: 'title',
+      condition: {
+        type: 'title-length-greater-than',
+        length: 20,
+      },
+    })
+
+    expect(question.id).toBe('title:length-at-least:21')
+    expect(question.condition).toEqual({
+      type: 'title-length-at-least',
+      length: 21,
+    })
+    expect(question.test(post({ title: 'x'.repeat(20) }))).toBe(false)
+    expect(question.test(post({ title: 'x'.repeat(21) }))).toBe(true)
+  })
+
+  it('restores title-contains questions with a title matcher', () => {
+    const question = restoreGekanatorQuestion({
+      id: 'title:contains:結束バンド',
+      text: '題名に「結束バンド」が含まれる?',
+      kind: 'title',
+      condition: {
+        type: 'title-contains',
+        text: '結束バンド',
+      },
+    })
+
+    expect(question.test(post({ title: '結束バンドのライブ' }))).toBe(true)
+    expect(question.test(post({ title: '後藤ひとりの休日' }))).toBe(false)
+  })
+})
+
+describe('buildGekanatorQuestions', () => {
+  it('builds quantitative title length questions', () => {
+    const questions = buildGekanatorQuestions([
+      post({ id: 1, title: 'a' }),
+      post({ id: 2, title: 'bb' }),
+      post({ id: 3, title: 'ccc' }),
+      post({ id: 4, title: 'dddd' }),
+    ])
+    const titleQuestion = questions.find(question =>
+      question.condition.type === 'title-length-at-least')
+
+    expect(titleQuestion?.text).toMatch(/^タイトルは \d+ 文字以上\?$/)
+    expect(titleQuestion?.id).toMatch(/^title:length-at-least:\d+$/)
+  })
+
+  it('builds title-contains questions from repeated title words', () => {
+    const questions = buildGekanatorQuestions([
+      post({ id: 1, title: '結束バンド ライブ' }),
+      post({ id: 2, title: '結束バンド 新曲' }),
+      post({ id: 3, title: '後藤ひとり 練習' }),
+      post({ id: 4, title: '伊地知虹夏 練習' }),
+    ])
+
+    const titleContainsQuestion = questions.find(question =>
+      question.condition.type === 'title-contains'
+      && question.condition.text === '結束バンド')
+
+    expect(titleContainsQuestion).toMatchObject({
+      id: 'title:contains:結束バンド',
+      text: '題名に「結束バンド」が含まれる?',
+      kind: 'title',
+      source: 'default',
+      priorityWeight: .96,
+    })
+    expect(titleContainsQuestion?.test(post({ title: '結束バンドのライブ' }))).toBe(true)
+    expect(titleContainsQuestion?.test(post({ title: '廣井きくりのライブ' }))).toBe(false)
+  })
+
+  it('honors question caps and title-contains toggles', () => {
+    const posts = [
+      post({ id: 1, title: '結束バンド ライブ' }),
+      post({ id: 2, title: '結束バンド 新曲' }),
+      post({ id: 3, title: '後藤ひとり 練習' }),
+      post({ id: 4, title: '伊地知虹夏 練習' }),
+    ]
+
+    const capped = buildGekanatorQuestions(posts, {
+      titleContainsCap: 1,
+      totalQuestionCap: 1,
+    })
+    const withoutTitleContains = buildGekanatorQuestions(posts, {
+      includeTitleContains: false,
+    })
+
+    expect(capped).toHaveLength(1)
+    expect(withoutTitleContains.some(question =>
+      question.condition.type === 'title-contains')).toBe(false)
+  })
+})
+
+describe('questionIdForCondition', () => {
+  it('builds stable ids for title-contains questions', () => {
+    expect(questionIdForCondition({
+      type: 'title-contains',
+      text: '結束バンド',
+    })).toBe('title:contains:結束バンド')
+  })
 })
 
 describe('Gekanator API writers', () => {

frontend/src/lib/gekanator.ts

@@ -13,6 +13,7 @@ export type GekanatorAnswerLog = {
     questionId:       string
     questionText:     string
     questionCondition?:  GekanatorQuestionCondition
+    questionMode?:    'normal' | 'winning_run'
     answer:           GekanatorAnswerValue
     originalAnswer:   GekanatorAnswerValue }
 
@@ -29,6 +30,8 @@ export type GekanatorQuestionSource =
     | 'ai_generated'
     | 'admin_curated'
 
+export type GekanatorPerformanceMode = 'lite' | 'normal'
+
 export type GekanatorQuestionCondition =
     | { type: 'tag'; key: string }
     | { type: 'source'; host: string }
@@ -38,6 +41,7 @@ export type GekanatorQuestionCondition =
     | { type: 'title-length-at-least'; length: number }
     | { type: 'title-length-greater-than'; length: number }
     | { type: 'title-has-ascii' }
+    | { type: 'title-contains'; text: string }
     | {
 	  type: 'post-similarity'
 	  postId: number
@@ -76,6 +80,13 @@ export type GekanatorQuestion = {
     exampleAnswers?: Record<`${ number }`, GekanatorAnswerValue>
     test:            (post: Post) => boolean }
 
+export type BuildGekanatorQuestionsOptions = {
+    includeTitleContains?: boolean
+    tagQuestionCap?: number
+    titleContainsCap?: number
+    totalQuestionCap?: number
+}
+
 
 export const normalizeTitleLengthCondition = (
     condition:  GekanatorQuestionCondition,
@@ -127,6 +138,8 @@ export const questionIdForCondition = (
     return `title:length-at-least:${ titleLengthMinimumForCondition (condition) }`
   case 'title-has-ascii':
     return 'title:ascii'
+  case 'title-contains':
+    return `title:contains:${ condition.text }`
   }
 }
 
@@ -292,6 +305,8 @@ const questionMatches = (
     return (post.title?.length ?? 0) > question.condition.length
   case 'title-has-ascii':
     return /[A-Za-z0-9]/.test (post.title ?? '')
+  case 'title-contains':
+    return (post.title ?? '').includes (question.condition.text)
   case 'post-similarity':
     return false
   }
@@ -319,6 +334,7 @@ export const expectedAnswerForQuestion = (
   case 'title-length-at-least':
   case 'title-length-greater-than':
   case 'title-has-ascii':
+  case 'title-contains':
     return questionMatches (post, question) ? 'yes' : 'no'
   case 'post-similarity':
     return null
@@ -372,15 +388,26 @@ export const fetchGekanatorQuestions = async (): Promise<StoredGekanatorQuestion
 
 
 export const fetchGekanatorExtraQuestions = async (
-    gameId: number,
+    gameId:  number,
+    nonce?: string,
 ): Promise<GekanatorExtraQuestion[]> => {
   const data = await apiGet<{ questions: GekanatorExtraQuestion[] }> (
-      `/gekanator/games/${ gameId }/extra_questions`)
+      `/gekanator/games/${ gameId }/extra_questions`,
+      { params: nonce ? { nonce } : undefined })
   return data.questions
 }
 
 
-export const buildGekanatorQuestions = (posts: Post[]): GekanatorQuestion[] => {
+export const buildGekanatorQuestions = (
+    posts:    Post[],
+    options:  BuildGekanatorQuestionsOptions = { },
+): GekanatorQuestion[] => {
+  const {
+      includeTitleContains = true,
+      tagQuestionCap = 192,
+      titleContainsCap = 24,
+      totalQuestionCap = Number.POSITIVE_INFINITY,
+  } = options
   const tagCounts = countBy (posts.flatMap (post =>
       post.tags
       .filter (tag =>
@@ -402,17 +429,31 @@ export const buildGekanatorQuestions = (posts: Post[]): GekanatorQuestion[] => {
       .map (originalMonthDayOf)
       .filter ((monthDay): monthDay is string => monthDay !== null))
   const titleLengthMedian = median (posts.map (post => post.title?.length ?? 0))
+  const titleWordCounts =
+      includeTitleContains
+	? countBy (
+	    posts.flatMap (post =>
+		Array.from (
+		    new Set (
+			(post.title ?? '')
+			.match (
+			    /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}A-Za-z0-9]{2,}/gu)
+			?? []))))
+	: new Map<string, number> ()
 
-  const usefulEntries = <T extends string | number> (counts: Map<T, number>) =>
+  const usefulEntries = <T extends string | number> (
+      counts:  Map<T, number>,
+      cap:     number,
+  ) =>
       [...counts.entries ()]
       .filter (([, count]) => count > 0 && count < posts.length)
       .sort ((a, b) => Math.abs (posts.length / 2 - a[1])
 	       - Math.abs (posts.length / 2 - b[1]))
-      .slice (0, 80)
+      .slice (0, cap)
 
-  const tagQuestions = usefulEntries (tagCounts)
+  const tagQuestions = usefulEntries (tagCounts, Math.max (tagQuestionCap, 80))
       .filter (([, count]) => count >= 2 && count <= Math.max (2, posts.length * .7))
-      .slice (0, 80)
+      .slice (0, tagQuestionCap)
       .map (([key]) => {
 	const { category, name } = tagFromQuestionKey (String (key))
 	const label = category === 'nico' ? nicoTagLabel (name) : name
@@ -427,7 +468,7 @@ export const buildGekanatorQuestions = (posts: Post[]): GekanatorQuestion[] => {
 	    test: (post: Post) => questionableTag (post, String (key)) }
       })
 
-  const sourceQuestions = usefulEntries (hosts)
+  const sourceQuestions = usefulEntries (hosts, 20)
       .filter (([, count]) => count >= 2 && count <= Math.max (2, posts.length * .7))
       .slice (0, 20)
       .map (([host]) => ({
@@ -439,7 +480,7 @@ export const buildGekanatorQuestions = (posts: Post[]): GekanatorQuestion[] => {
 	  priorityWeight: 1,
 	  test: (post: Post) => hostOf (post) === host }))
 
-  const originalYearQuestions = usefulEntries (originalYears)
+  const originalYearQuestions = usefulEntries (originalYears, 20)
       .filter (([, count]) => count >= 2 && count <= Math.max (2, posts.length * .7))
       .slice (0, 20)
       .map (([year]) => ({
@@ -451,7 +492,7 @@ export const buildGekanatorQuestions = (posts: Post[]): GekanatorQuestion[] => {
 	  priorityWeight: 1,
 	  test: (post: Post) => originalYearOf (post) === year }))
 
-  const originalMonthQuestions = usefulEntries (originalMonths)
+  const originalMonthQuestions = usefulEntries (originalMonths, 20)
       .filter (([, count]) => count >= 2 && count <= Math.max (2, posts.length * .7))
       .slice (0, 20)
       .map (([month]) => ({
@@ -463,7 +504,7 @@ export const buildGekanatorQuestions = (posts: Post[]): GekanatorQuestion[] => {
 	  priorityWeight: 1,
 	  test: (post: Post) => originalMonthOf (post) === month }))
 
-  const originalMonthDayQuestions = usefulEntries (originalMonthDays)
+  const originalMonthDayQuestions = usefulEntries (originalMonthDays, 20)
       .filter (([, count]) => count >= 2 && count <= Math.max (2, posts.length * .7))
       .slice (0, 20)
       .map (([monthDay]) => {
@@ -503,6 +544,23 @@ export const buildGekanatorQuestions = (posts: Post[]): GekanatorQuestion[] => {
 	const no = posts.length - yes
 	return yes >= 2 && no >= 2 && yes <= posts.length * .7 && no <= posts.length * .7
       })
+  const titleContainsQuestions =
+      includeTitleContains
+	? usefulEntries (titleWordCounts, titleContainsCap)
+	    .filter (([word, count]) =>
+		String (word).length <= 24
+		&& count >= 2
+		&& count <= Math.max (2, posts.length * .7))
+	    .slice (0, titleContainsCap)
+	    .map (([word]) => ({
+		id:   `title:contains:${ word }`,
+		text: `題名に「${ word }」が含まれる?`,
+		kind: 'title' as const,
+		condition: { type: 'title-contains' as const, text: String (word) },
+		source: 'default' as const,
+		priorityWeight: .96,
+		test: (post: Post) => (post.title ?? '').includes (String (word)) }))
+	: []
 
   return [
       ...sourceQuestions,
@@ -510,7 +568,8 @@ export const buildGekanatorQuestions = (posts: Post[]): GekanatorQuestion[] => {
       ...originalMonthQuestions,
       ...originalMonthDayQuestions,
       ...titleQuestions,
-      ...tagQuestions]
+      ...titleContainsQuestions,
+      ...tagQuestions].slice (0, totalQuestionCap)
 }
 
 

frontend/src/lib/gekanatorCandidateRecovery.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+    candidatePostsFor,
+    hardFilteredPostsForAnswer,
+    recoverCandidatePosts,
+} from '@/lib/gekanatorCandidateRecovery'
+
+import type {
+    GekanatorAnswerLog,
+    GekanatorAnswerValue,
+    GekanatorQuestion,
+} from '@/lib/gekanator'
+import type { Post } from '@/types'
+
+
+const post = (id: number): Post => ({
+  id,
+  versionNo: 1,
+  url: `https://example.com/posts/${ id }`,
+  title: `post ${ id }`,
+  thumbnail: null,
+  thumbnailBase: null,
+  tags: [],
+  viewed: false,
+  related: [],
+  originalCreatedFrom: null,
+  originalCreatedBefore: null,
+  createdAt: '2026-06-10T00:00:00.000Z',
+  updatedAt: '2026-06-10T00:00:00.000Z',
+  uploadedUser: null,
+})
+
+
+const postSimilarityQuestion = (
+    id:       string,
+    answers:  Record<`${ number }`, GekanatorAnswerValue>,
+): GekanatorQuestion => ({
+  id,
+  text: `${ id }?`,
+  kind: 'post_similarity',
+  condition: {
+      type: 'post-similarity',
+      postId: 9999,
+      answer: 'yes',
+      threshold: 0.65 },
+  source: 'user_suggested',
+  priorityWeight: 1,
+  exampleAnswers: answers,
+  test: candidate => answers[String (candidate.id) as `${ number }`] === 'yes',
+})
+
+
+const answer = (
+    question:  GekanatorQuestion,
+    value:     GekanatorAnswerValue,
+): GekanatorAnswerLog => ({
+  questionId: question.id,
+  questionText: question.text,
+  questionCondition: question.condition,
+  answer: value,
+  originalAnswer: value,
+})
+
+
+describe('candidatePostsFor', () => {
+  it('lets recovered candidates ignore old answers but not later answers', () => {
+    const posts = [post (1), post (2), post (3)]
+    const oldQuestion = postSimilarityQuestion ('old', {
+	1: 'no',
+	2: 'yes',
+	3: 'yes',
+    })
+    const laterQuestion = postSimilarityQuestion ('later', {
+	1: 'no',
+	2: 'no',
+	3: 'yes',
+    })
+
+    const candidates = candidatePostsFor ({
+	posts,
+	questions: [oldQuestion, laterQuestion],
+	answers: [answer (oldQuestion, 'yes'), answer (laterQuestion, 'yes')],
+	softenedQuestionIds: new Set (),
+	rejectedPostIds: new Set (),
+	recoveredCandidatePosts: new Map ([
+	    [1, 1],
+	    [3, 1],
+	]) })
+
+    expect(candidates.map (candidate => candidate.id)).toEqual ([3])
+  })
+
+  it('does not let recovered candidates bypass explicit rejected posts', () => {
+    const posts = [post (1), post (2)]
+    const question = postSimilarityQuestion ('question', {
+	1: 'yes',
+	2: 'yes',
+    })
+
+    const candidates = candidatePostsFor ({
+	posts,
+	questions: [question],
+	answers: [answer (question, 'yes')],
+	softenedQuestionIds: new Set (),
+	rejectedPostIds: new Set ([1]),
+	recoveredCandidatePosts: new Map ([[1, 1]]) })
+
+    expect(candidates.map (candidate => candidate.id)).toEqual ([2])
+  })
+})
+
+
+describe('hardFilteredPostsForAnswer', () => {
+  it('returns zero candidates without falling back to the original pool', () => {
+    const posts = [post (1), post (2)]
+    const question = postSimilarityQuestion ('question', {
+	1: 'yes',
+	2: 'yes',
+    })
+
+    expect(hardFilteredPostsForAnswer ({
+	posts,
+	question,
+	answer: 'no',
+    })).toEqual ([])
+  })
+})
+
+
+describe('recoverCandidatePosts', () => {
+  it('recovers high-score non-rejected, non-eligible candidates in staged batches', () => {
+    const posts = Array.from ({ length: 10 }, (_value, index) => post (index + 1))
+    const scores = new Map (posts.map (candidate => [candidate.id, candidate.id]))
+
+    const recovered = recoverCandidatePosts ({
+	posts,
+	scores,
+	rejectedPostIds: new Set ([10]),
+	recoveredCandidatePosts: new Map ([[8, 1]]),
+	eligiblePostIds: new Set ([9]),
+	answerCountAtRecovery: 2,
+	recoveryStepCount: 0,
+    })
+
+    expect(recovered?.recoveryStepCount).toBe (1)
+    expect([...(recovered?.recoveredCandidatePosts.keys () ?? [])])
+      .toEqual ([8, 7, 6, 5, 4])
+    expect(recovered?.recoveredCandidatePosts.get (7)).toBe (2)
+  })
+
+  it('does not add posts when recovered and eligible candidates already hit the target', () => {
+    const posts = Array.from ({ length: 10 }, (_value, index) => post (index + 1))
+    const scores = new Map (posts.map (candidate => [candidate.id, candidate.id]))
+
+    const recovered = recoverCandidatePosts ({
+	posts,
+	scores,
+	rejectedPostIds: new Set (),
+	recoveredCandidatePosts: new Map ([
+	    [1, 1],
+	    [2, 1],
+	    [3, 1],
+	]),
+	eligiblePostIds: new Set ([4, 5, 6]),
+	answerCountAtRecovery: 2,
+	recoveryStepCount: 0,
+    })
+
+    expect(recovered?.recoveryStepCount).toBe (1)
+    expect([...(recovered?.recoveredCandidatePosts.keys () ?? [])])
+      .toEqual ([1, 2, 3])
+  })
+})

frontend/src/lib/gekanatorCandidateRecovery.ts

@@ -0,0 +1,156 @@
+import { expectedAnswerForQuestion } from '@/lib/gekanator'
+
+import type {
+    GekanatorAnswerLog,
+    GekanatorAnswerValue,
+    GekanatorQuestion,
+} from '@/lib/gekanator'
+import type { Post } from '@/types'
+
+
+export type RecoveredCandidatePost = {
+    postId:                number
+    answerCountAtRecovery: number }
+
+
+export const candidatePostsFor = ({
+    posts,
+    questions,
+    answers,
+    softenedQuestionIds,
+    rejectedPostIds,
+    recoveredCandidatePosts,
+}: {
+    posts:                   Post[]
+    questions:               GekanatorQuestion[]
+    answers:                 GekanatorAnswerLog[]
+    softenedQuestionIds:     Set<string>
+    rejectedPostIds:         Set<number>
+    recoveredCandidatePosts: Map<number, number>
+}): Post[] => {
+  const questionById = new Map (questions.map (question => [question.id, question]))
+
+  return posts.filter (post => {
+    if (rejectedPostIds.has (post.id))
+      return false
+
+    const answerCountAtRecovery = recoveredCandidatePosts.get (post.id)
+
+    return answers.every ((answer, index) => {
+      if (answerCountAtRecovery !== undefined && index < answerCountAtRecovery)
+	return true
+
+      if (softenedQuestionIds.has (answer.questionId))
+	return true
+
+      const question = questionById.get (answer.questionId)
+      if (!(question))
+	return true
+
+      switch (answer.answer)
+      {
+      case 'yes':
+      case 'no': {
+	const expected = expectedAnswerForQuestion (question, post)
+	return expected === null || expected === 'unknown' || expected === answer.answer
+      }
+      default:
+	return true
+      }
+    })
+  })
+}
+
+
+export const hardFilteredPostsForAnswer = ({
+    posts,
+    question,
+    answer,
+}: {
+    posts:     Post[]
+    question:  GekanatorQuestion
+    answer:    GekanatorAnswerValue
+}): Post[] => {
+  if (answer === 'unknown')
+    return posts
+
+  return posts.filter (post => {
+    const expected = expectedAnswerForQuestion (question, post)
+    return expected === null || expected === 'unknown' || expected === answer
+  })
+}
+
+
+const concreteAnswerOptions: GekanatorAnswerValue[] = [
+    'yes',
+    'no',
+    'partial',
+    'probably_no']
+
+
+export const allConcreteAnswerOptionsExhausted = (
+    posts:      Post[],
+    question:   GekanatorQuestion | null,
+): boolean => {
+  if (!(question))
+    return false
+
+  return concreteAnswerOptions.every (answer =>
+      hardFilteredPostsForAnswer ({ posts, question, answer }).length === 0)
+}
+
+
+const nextRecoveryTargetSize = (recoveryStepCount: number): number =>
+    6 * (2 ** recoveryStepCount)
+
+
+export const recoverCandidatePosts = ({
+    posts,
+    scores,
+    rejectedPostIds,
+    recoveredCandidatePosts,
+    eligiblePostIds,
+    answerCountAtRecovery,
+    recoveryStepCount,
+}: {
+    posts:                   Post[]
+    scores:                  Map<number, number>
+    rejectedPostIds:         Set<number>
+    recoveredCandidatePosts: Map<number, number>
+    eligiblePostIds:         Set<number>
+    answerCountAtRecovery:   number
+    recoveryStepCount:       number
+}): {
+    recoveredCandidatePosts: Map<number, number>
+    recoveryStepCount:       number
+} | null => {
+  const recovered = new Map (recoveredCandidatePosts)
+  const targetSize = nextRecoveryTargetSize (recoveryStepCount)
+  const countedPostIds = new Set ([
+      ...eligiblePostIds,
+      ...recovered.keys ()])
+  const addCount = targetSize - countedPostIds.size
+  if (addCount <= 0)
+    return {
+	recoveredCandidatePosts: recovered,
+	recoveryStepCount: recoveryStepCount + 1 }
+
+  const candidates = posts
+      .filter (post =>
+	  !(rejectedPostIds.has (post.id))
+	  && !(eligiblePostIds.has (post.id))
+	  && !(recovered.has (post.id)))
+      .sort ((a, b) =>
+	  (scores.get (b.id) ?? Number.NEGATIVE_INFINITY)
+	      - (scores.get (a.id) ?? Number.NEGATIVE_INFINITY))
+      .slice (0, addCount)
+
+  if (candidates.length === 0)
+    return null
+
+  candidates.forEach (post => recovered.set (post.id, answerCountAtRecovery))
+
+  return {
+      recoveredCandidatePosts: recovered,
+      recoveryStepCount: recoveryStepCount + 1 }
+}

frontend/src/lib/gekanatorQuestionFilters.ts

@@ -0,0 +1,167 @@
+import { titleLengthMinimumForCondition } from '@/lib/gekanator'
+
+import type {
+    GekanatorAnswerLog,
+    GekanatorAnswerValue,
+    GekanatorQuestion,
+} from '@/lib/gekanator'
+
+
+export const monthForCondition = (
+    condition:  GekanatorQuestion['condition'],
+): number | null => {
+  if (condition.type === 'original-month')
+    return condition.month
+
+  if (condition.type !== 'original-month-day')
+    return null
+
+  const month = Number (condition.monthDay.split ('-')[0])
+  return Number.isInteger (month) ? month : null
+}
+
+
+const isTitleLengthContradiction = (
+    candidate:  GekanatorQuestion['condition'],
+    previous:   GekanatorQuestion['condition'],
+    answer:     GekanatorAnswerValue,
+): boolean => {
+  const candidateLength = titleLengthMinimumForCondition (candidate)
+  const previousLength = titleLengthMinimumForCondition (previous)
+  if (candidateLength === null || previousLength === null)
+    return false
+
+  switch (answer)
+  {
+  case 'yes':
+    return candidateLength <= previousLength
+  case 'no':
+    return candidateLength >= previousLength
+  default:
+    return false
+  }
+}
+
+
+const isQuestionRedundantAfterAnswers = (
+    question:  GekanatorQuestion,
+    answers:   GekanatorAnswerLog[],
+): boolean => answers.some (answer => {
+  const previous = answer.questionCondition
+  return previous !== undefined
+      && isTitleLengthContradiction (question.condition, previous, answer.answer)
+})
+
+
+const isSourceFactBlocked = (
+    candidate:  GekanatorQuestion['condition'],
+    previous:   GekanatorQuestion['condition'],
+    answer:     GekanatorAnswerValue,
+): boolean => {
+  if (candidate.type !== 'source' || previous.type !== 'source')
+    return false
+
+  switch (answer)
+  {
+  case 'yes':
+    return true
+  case 'no':
+    return candidate.host === previous.host
+  default:
+    return false
+  }
+}
+
+
+const isOriginalYearFactBlocked = (
+    candidate:  GekanatorQuestion['condition'],
+    previous:   GekanatorQuestion['condition'],
+    answer:     GekanatorAnswerValue,
+): boolean => {
+  if (candidate.type !== 'original-year' || previous.type !== 'original-year')
+    return false
+
+  switch (answer)
+  {
+  case 'yes':
+    return true
+  case 'no':
+    return candidate.year === previous.year
+  default:
+    return false
+  }
+}
+
+
+const isOriginalMonthFactBlocked = (
+    candidate:  GekanatorQuestion['condition'],
+    previous:   GekanatorQuestion['condition'],
+    answer:     GekanatorAnswerValue,
+): boolean => {
+  switch (answer)
+  {
+  case 'yes':
+    if (previous.type === 'original-month')
+      {
+	if (candidate.type === 'original-month')
+	  return true
+
+	if (candidate.type === 'original-month-day')
+	  return monthForCondition (candidate) !== previous.month
+
+	return false
+      }
+
+    if (previous.type === 'original-month-day')
+      return candidate.type === 'original-month'
+	  || candidate.type === 'original-month-day'
+
+    return false
+  case 'no':
+    if (previous.type === 'original-month')
+      {
+	if (candidate.type === 'original-month')
+	  return candidate.month === previous.month
+
+	if (candidate.type === 'original-month-day')
+	  return monthForCondition (candidate) === previous.month
+
+	return false
+      }
+
+    if (previous.type === 'original-month-day')
+      return candidate.type === 'original-month-day'
+	  && candidate.monthDay === previous.monthDay
+
+    return false
+  default:
+    return false
+  }
+}
+
+
+const isFactQuestionBlocked = (
+    candidate:  GekanatorQuestion['condition'],
+    previous:   GekanatorQuestion['condition'],
+    answer:     GekanatorAnswerValue,
+): boolean => {
+  if (!(answer === 'yes' || answer === 'no'))
+    return false
+
+  return isSourceFactBlocked (candidate, previous, answer)
+      || isOriginalYearFactBlocked (candidate, previous, answer)
+      || isOriginalMonthFactBlocked (candidate, previous, answer)
+}
+
+
+export const isQuestionHardFilteredAfterAnswers = (
+    question:  GekanatorQuestion,
+    answers:   GekanatorAnswerLog[],
+): boolean => answers.some (answer => {
+  const previous = answer.questionCondition
+  if (previous === undefined)
+    return false
+
+  return isQuestionRedundantAfterAnswers (question, [answer])
+      || isFactQuestionBlocked (question.condition, previous, answer.answer)
+})

frontend/src/lib/queryKeys.ts

@@ -12,8 +12,8 @@ export const gekanatorKeys = {
     root:      ['gekanator'] as const,
     posts:     () => ['gekanator', 'posts'] as const,
     questions: () => ['gekanator', 'questions'] as const,
-    extraQuestions: (gameId: number) =>
-		       ['gekanator', 'games', gameId, 'extra-questions'] as const }
+    extraQuestions: (gameId: number, nonce: string) =>
+		       ['gekanator', 'games', gameId, 'extra-questions', nonce] as const }
 
 export const tagsKeys = {
     root:         ['tags'] as const,

frontend/src/pages/GekanatorPage.test.tsx

@@ -0,0 +1,154 @@
+import { describe, expect, it } from 'vitest'
+
+import { isQuestionHardFilteredAfterAnswers } from '@/lib/gekanatorQuestionFilters'
+
+import type {
+    GekanatorAnswerLog,
+    GekanatorAnswerValue,
+    GekanatorQuestion,
+    GekanatorQuestionCondition,
+} from '@/lib/gekanator'
+
+
+const question = (
+    condition:  GekanatorQuestionCondition,
+): GekanatorQuestion => ({
+  id: `${ condition.type }:candidate`,
+  text: 'candidate?',
+  kind: condition.type === 'source'
+      ? 'source'
+      : condition.type.startsWith ('original-')
+	? 'original_date'
+	: condition.type.startsWith ('title-')
+	  ? 'title'
+	  : 'tag',
+  condition,
+  source: 'default',
+  priorityWeight: 1,
+  test: () => false,
+})
+
+
+const answer = (
+    condition:  GekanatorQuestionCondition,
+    value:      GekanatorAnswerValue,
+): GekanatorAnswerLog => ({
+  questionId: 'previous',
+  questionText: 'previous?',
+  questionCondition: condition,
+  answer: value,
+  originalAnswer: value,
+})
+
+
+const blocked = (
+    candidate:  GekanatorQuestionCondition,
+    previous:   GekanatorQuestionCondition,
+    value:      GekanatorAnswerValue,
+): boolean =>
+    isQuestionHardFilteredAfterAnswers (question (candidate), [answer (previous, value)])
+
+
+describe('isQuestionHardFilteredAfterAnswers', () => {
+  it('blocks only contradictory or redundant month questions after a yes answer', () => {
+    const previous: GekanatorQuestionCondition = { type: 'original-month', month: 12 }
+
+    expect(blocked ({ type: 'original-month', month: 12 }, previous, 'yes')).toBe(true)
+    expect(blocked ({ type: 'original-month', month: 2 }, previous, 'yes')).toBe(true)
+    expect(blocked ({ type: 'original-month-day', monthDay: '2-14' }, previous, 'yes'))
+      .toBe(true)
+    expect(blocked ({ type: 'original-month-day', monthDay: '12-25' }, previous, 'yes'))
+      .toBe(false)
+    expect(blocked ({ type: 'original-year', year: 2024 }, previous, 'yes')).toBe(false)
+    expect(blocked ({ type: 'source', host: 'example.com' }, previous, 'yes')).toBe(false)
+    expect(blocked ({ type: 'tag', key: 'character:喜多郁代' }, previous, 'yes')).toBe(false)
+  })
+
+  it('blocks same-month facts after a no answer', () => {
+    const previous: GekanatorQuestionCondition = { type: 'original-month', month: 12 }
+
+    expect(blocked ({ type: 'original-month', month: 12 }, previous, 'no')).toBe(true)
+    expect(blocked ({ type: 'original-month', month: 2 }, previous, 'no')).toBe(false)
+    expect(blocked ({ type: 'original-month-day', monthDay: '12-25' }, previous, 'no'))
+      .toBe(true)
+    expect(blocked ({ type: 'original-month-day', monthDay: '2-14' }, previous, 'no'))
+      .toBe(false)
+  })
+
+  it('blocks all month and month-day questions after a month-day yes answer', () => {
+    const previous: GekanatorQuestionCondition = {
+      type: 'original-month-day',
+      monthDay: '12-25',
+    }
+
+    expect(blocked ({ type: 'original-month', month: 12 }, previous, 'yes')).toBe(true)
+    expect(blocked ({ type: 'original-month', month: 2 }, previous, 'yes')).toBe(true)
+    expect(blocked ({ type: 'original-month-day', monthDay: '12-25' }, previous, 'yes'))
+      .toBe(true)
+    expect(blocked ({ type: 'original-month-day', monthDay: '12-26' }, previous, 'yes'))
+      .toBe(true)
+  })
+
+  it('blocks the same month-day only after a month-day no answer', () => {
+    const previous: GekanatorQuestionCondition = {
+      type: 'original-month-day',
+      monthDay: '12-25',
+    }
+
+    expect(blocked ({ type: 'original-month-day', monthDay: '12-25' }, previous, 'no'))
+      .toBe(true)
+    expect(blocked ({ type: 'original-month-day', monthDay: '12-26' }, previous, 'no'))
+      .toBe(false)
+    expect(blocked ({ type: 'original-month', month: 12 }, previous, 'no')).toBe(false)
+  })
+
+  it('blocks year and source as single-value facts', () => {
+    expect(blocked (
+      { type: 'original-year', year: 2025 },
+      { type: 'original-year', year: 2024 },
+      'yes',
+    )).toBe(true)
+    expect(blocked (
+      { type: 'original-year', year: 2024 },
+      { type: 'original-year', year: 2024 },
+      'no',
+    )).toBe(true)
+    expect(blocked (
+      { type: 'source', host: 'b.example' },
+      { type: 'source', host: 'a.example' },
+      'yes',
+    )).toBe(true)
+    expect(blocked (
+      { type: 'source', host: 'b.example' },
+      { type: 'source', host: 'a.example' },
+      'no',
+    )).toBe(false)
+  })
+
+  it('does not hard-filter partial, probably_no, or unknown fact answers', () => {
+    const previous: GekanatorQuestionCondition = { type: 'original-month', month: 12 }
+    const candidate: GekanatorQuestionCondition = { type: 'original-month', month: 2 }
+
+    expect(blocked (candidate, previous, 'partial')).toBe(false)
+    expect(blocked (candidate, previous, 'probably_no')).toBe(false)
+    expect(blocked (candidate, previous, 'unknown')).toBe(false)
+  })
+
+  it('keeps title-length hard redundancy for yes and no only', () => {
+    const previous: GekanatorQuestionCondition = {
+      type: 'title-length-at-least',
+      length: 30,
+    }
+
+    expect(blocked ({ type: 'title-length-at-least', length: 20 }, previous, 'yes'))
+      .toBe(true)
+    expect(blocked ({ type: 'title-length-at-least', length: 40 }, previous, 'yes'))
+      .toBe(false)
+    expect(blocked ({ type: 'title-length-at-least', length: 40 }, previous, 'no'))
+      .toBe(true)
+    expect(blocked ({ type: 'title-length-at-least', length: 20 }, previous, 'no'))
+      .toBe(false)
+    expect(blocked ({ type: 'title-length-at-least', length: 20 }, previous, 'partial'))
+      .toBe(false)
+  })
+})