#371

AGENTS.md

@@ -107,16 +107,11 @@ npm run preview
 - Prefer single quotes for strings unless interpolation or escaping makes
   double quotes better.
 - Ruby: never put a space before method-call parentheses.
-- Ruby: `render` 系メソッド呼び出しでは、keyword 引数付きでも括弧を書かない。
 - Ruby: never put a line break immediately before `)`.
 - Ruby: do not use `%w` or `%i`.
-- In Ruby, when an `if` condition is split across multiple lines and combines
-  clauses with `&&` or `||`, wrap the whole condition in parentheses.
 - Ruby hashes are not blocks; keep `}` on the same line as the final pair.
 - Ruby hashes keep the first pair on the same line as `{` unless line length
   requires a break.
-- Short Ruby hashes may stay visually compact across two lines with the first
-  pair kept on the opening line and aligned continuation pairs below it.
 - Ruby blocks use separate `{ ... }` rules from hashes, with 2-space body
   indentation.
 - For arrays, never put whitespace or a line break immediately before `]`.
@@ -130,64 +125,6 @@ npm run preview
 - TypeScript and TSX use 4-space logical indentation.
 - In TypeScript and TSX only, replace every leading run of 8 spaces with a tab.
 - Tabs are only for leading indentation, never for spaces after non-space text.
-- TypeScript and TSX imports may stay on one line if they remain within the
-  line limit; do not expand short type-only imports mechanically.
-- In TypeScript and TSX, when a function takes one destructured object
-  argument plus an inline type, prefer this shape when it fits locally:
-
-```ts
-const helper = (
-    { value, flag }: { value: string
-		       flag:  boolean },
-): Result => {
-  // ...
-}
-```
-
-- In TypeScript and TSX, put `switch` case block braces on their own lines
-  when a case needs a lexical block:
-
-```ts
-case 'yes':
-case 'no':
-  {
-    const expected = valueFor (item)
-    return expected == null || expected === answer
-  }
-```
-
-- In TypeScript and TSX, use `value == null` and `value != null` as the
-  default nullish checks. Do not use `=== null`, `=== undefined`,
-  `!== null`, or `!== undefined`.
-- If code appears to need a distinction between `null` and `undefined`, treat
-  that as a design smell and revise the logic to avoid the distinction.
-  External library APIs that explicitly require distinguishing the two are the
-  only exception.
-- In TypeScript and TSX, keep short arrays on one line when they fit under the
-  line limit; break arrays only when readability or line length requires it.
-- In TypeScript and TSX, when a ternary expression is split across multiple
-  lines, align `?` and `:` with the condition expression. Do not indent `?` and
-  `:` one extra level under the condition.
-
-```ts
-const value =
-    condition
-    ? consequent
-    : alternate
-```
-
-- In TypeScript and TSX, keep short ternary expressions on one line when they
-  fit cleanly under the line limit.
-- In TypeScript and TSX, prefer ternary expressions for simple conditional
-  value selection. Do not replace a clear ternary with `if` statements, and do
-  not introduce immediately invoked functions just to avoid or reformat a
-  ternary expression.
-- In TypeScript and TSX, do not write `let` followed by later `if` assignments
-  when the value can be expressed as a single `const` initializer. Prefer
-  `const` because it prevents accidental later reassignment.
-- When fixing formatting, change formatting only. Do not change expression
-  structure, control flow, or variable mutability unless the requested style
-  explicitly requires it.
 - Do not add production dependencies without explicit approval.
 - Do not create, modify, or run tests unless the user explicitly asks for
   test work. When the user asks for tests, keep working and rerun them until

backend/AGENTS.md

@@ -72,23 +72,17 @@ service, representation, and spec.
 - Prefer precise, minimal changes.
 - Use single quotes unless interpolation or escaping makes double quotes better.
 - Do not put a space before Ruby method-call parentheses.
-- For `render`-family method calls, omit parentheses even when passing
-  keyword arguments.
 - Never put a line break immediately before `)` in Ruby.
 - Do not use `%w` or `%i` in new Ruby code.
 - Never write a Ruby line longer than 99 characters.
 - Aim to keep Ruby lines within 79 characters where practical.
 - For small Ruby method definitions that take keyword arguments, match the
   local no-parentheses style when nearby code uses it.
-- When an `if` condition is split across multiple lines and combines clauses
-  with `&&` or `||`, wrap the whole condition in parentheses.
 - Treat Ruby hash `{ ... }` style and Ruby block `{ ... }` style as separate
   rules.
 - Do not format Ruby hashes like Ruby blocks.
 - For Ruby hashes, keep the closing `}` on the same line as the final pair.
 - Keep the first pair on the same line as `{` by default.
-- Short Ruby hashes may stay visually compact across two lines with the first
-  pair kept on the opening line and aligned continuation pairs below it.
 - If the hash would exceed the line limit, break after `{` and indent pairs
   by 4 spaces.
 - Put one logical pair per line when the expression would otherwise become

backend/app/controllers/gekanator_games_controller.rb

@@ -50,7 +50,7 @@ class GekanatorGamesController < ApplicationController
             questions,
             post_id: game.correct_post_id,
             user: current_user,
-            limit: 6)
+            limit: 2)
 
     render json: {
       questions: selected.map { |question| extra_question_json(question) }

backend/app/controllers/gekanator_posts_controller.rb

@@ -7,24 +7,13 @@ class GekanatorPostsController < ApplicationController
         .order(Arel.sql(
             'COALESCE(posts.original_created_before - INTERVAL 1 MINUTE, ' \
             'posts.original_created_from, posts.created_at) DESC, posts.id DESC'))
-        .to_a
 
-    active_tags_by_post_id =
+    render json: { posts: posts.map { |post| post_json(post) } }
-        posts.each_with_object({ }) do |post, h|
-          h[post.id] = post.tags.reject(&:deprecated?)
-        end
-
-    render json: {
-      posts: posts.map { |post|
-        post_json(post,
-                  active_tags_by_post_id:)
-      }
-    }
   end
 
   private
 
-  def post_json post, active_tags_by_post_id:
+  def post_json post
     {
       id: post.id,
       url: post.url,
@@ -33,26 +22,16 @@ class GekanatorPostsController < ApplicationController
       thumbnail_base: post.thumbnail_base,
       original_created_from: post.original_created_from,
       original_created_before: post.original_created_before,
-      post_similarity_edges: post_similarity_edges_json(
+      post_similarity_edges: post.post_similarities.map { |similarity|
-          post,
+        {
-          active_tags_by_post_id:),
+          target_post_id: similarity.target_post_id,
-      tags: active_tags_by_post_id.fetch(post.id, []).map { |tag| tag_json(tag) }
+          cos: similarity.cos.to_f
+        }
+      },
+      tags: post.tags.map { |tag| tag_json(tag) }
     }
   end
 
-  def post_similarity_edges_json post, active_tags_by_post_id:
-    post
-        .post_similarities
-        .filter_map do |similarity|
-          next unless active_tags_by_post_id.key?(similarity.target_post_id)
-
-          {
-            target_post_id: similarity.target_post_id,
-            cos: similarity.cos.to_f
-          }
-        end
-  end
-
   def tag_json tag
     {
       id: tag.id,

backend/app/controllers/gekanator_questions_controller.rb

@@ -5,16 +5,9 @@ class GekanatorQuestionsController < ApplicationController
         .accepted
         .includes(:gekanator_question_examples)
         .order(priority_weight: :desc, id: :asc)
-        .to_a
-    deprecated_tag_keys = deprecated_tag_keys_for(questions)
 
     render json: {
-      questions: questions.filter_map { |question|
+      questions: questions.map { |question| question_json(question) }
-        json = question_json(question)
-        next if hidden_question?(json[:condition], deprecated_tag_keys)
-
-        json
-      }
     }
   end
 
@@ -107,41 +100,4 @@ class GekanatorQuestionsController < ApplicationController
         .first
         &.first
   end
-
-  def deprecated_tag_keys_for questions
-    tag_keys = questions.filter_map { |question|
-      condition = condition_json(question.condition)
-      next unless condition['type'] == 'tag'
-
-      condition['key'].to_s.presence
-    }.uniq
-    return {} if tag_keys.empty?
-
-    categories = []
-    names = []
-    tag_keys.each do |key|
-      category, name = parse_tag_key(key)
-      categories << category
-      names << name
-    end
-
-    Tag
-        .joins(:tag_name)
-        .where(category: categories.uniq)
-        .where(tag_names: { name: names.uniq })
-        .where.not(deprecated_at: nil)
-        .pluck('tags.category', 'tag_names.name')
-        .each_with_object({ }) do |(category, name), h|
-          h["#{ category }:#{ name }"] = true
-        end
-  end
-
-  def hidden_question? condition, deprecated_tag_keys
-    condition[:type] == 'tag' && deprecated_tag_keys[condition[:key].to_s]
-  end
-
-  def parse_tag_key key
-    parts = key.to_s.split(':')
-    [parts.first.to_s, parts.drop(1).join(':')]
-  end
 end

backend/app/controllers/posts_controller.rb

@@ -148,10 +148,10 @@ class PostsController < ApplicationController
     ApplicationRecord.transaction do
       post.save!
 
-      tags = Tag.normalise_tags!(tag_names, deny_deprecated: true)
+      tags = Tag.normalise_tags!(tag_names)
       TagVersioning.record_tag_snapshots!(tags, created_by_user: current_user)
 
-      tags = Tag.expand_parent_tags(tags).reject(&:deprecated?)
+      tags = Tag.expand_parent_tags(tags)
       sync_post_tags!(post, tags)
 
       sync_parent_posts!(post, parent_post_ids)
@@ -165,8 +165,6 @@ class PostsController < ApplicationController
     render json: PostRepr.base(post), status: :created
   rescue Tag::NicoTagNormalisationError
     render_validation_error fields: { tags: 'ニコニコ・タグは直接指定できません．' }
-  rescue Tag::DeprecatedTagNormalisationError
-    render_unprocessable_entity '廃止済みタグは付与できません．', field: :tags
   rescue ArgumentError => e
     render_validation_error fields: { parent_post_ids: [e.message] }
   rescue ActiveRecord::RecordInvalid => e
@@ -257,8 +255,6 @@ class PostsController < ApplicationController
     render json:, status: :ok
   rescue Tag::NicoTagNormalisationError
     render_validation_error fields: { tags: ['ニコニコ・タグは直接指定できません．'] }
-  rescue Tag::DeprecatedTagNormalisationError
-    render_unprocessable_entity '廃止済みタグは付与できません．', field: :tags
   rescue ArgumentError => e
     render_validation_error fields: { parent_post_ids: [e.message] }
   rescue ActiveRecord::RecordInvalid => e
@@ -382,7 +378,7 @@ class PostsController < ApplicationController
   end
 
   def build_tag_tree_for tags
-    tags = tags.reject(&:deprecated?).to_a
+    tags = tags.to_a
     tag_ids = tags.map(&:id)
 
     implications = TagImplication.where(parent_tag_id: tag_ids, tag_id: tag_ids)
@@ -505,8 +501,7 @@ class PostsController < ApplicationController
   end
 
   def editable_tag_names_from_post post
-    post.tags.not_nico.where(deprecated_at: nil)
+    post.tags.not_nico.joins(:tag_name).order('tag_names.name').pluck('tag_names.name')
-        .joins(:tag_name).order('tag_names.name').pluck('tag_names.name')
   end
 
   def post_incoming_snapshot title:, original_created_from:, original_created_before:,
@@ -538,10 +533,9 @@ class PostsController < ApplicationController
   end
 
   def incoming_tag_names_for_snapshot raw_tag_names
-    tags = Tag.normalise_tags!(raw_tag_names, with_tagme: false,
+    tags = Tag.normalise_tags!(raw_tag_names, with_tagme: false)
-                                              deny_deprecated: true)
 
-    Tag.expand_parent_tags(tags).reject(&:deprecated?).map(&:name).uniq.sort
+    Tag.expand_parent_tags(tags).map(&:name).uniq.sort
   end
 
   def post_conflict_json post:, base_version_no:, base_snapshot:,
@@ -628,14 +622,13 @@ class PostsController < ApplicationController
                  original_created_from: snapshot[:original_created_from],
                  original_created_before: snapshot[:original_created_before])
 
-    editable_tags = Tag.normalise_tags!(snapshot[:tag_names], with_tagme: false,
+    editable_tags = Tag.normalise_tags!(snapshot[:tag_names], with_tagme: false)
-                                                               deny_deprecated: true)
     TagVersioning.record_tag_snapshots!(editable_tags, created_by_user: current_user)
 
     readonly_tags = post.tags.nico.to_a
 
     tags = readonly_tags + editable_tags
-    tags = Tag.expand_parent_tags(tags).reject(&:deprecated?)
+    tags = Tag.expand_parent_tags(tags)
 
     sync_post_tags!(post, tags)
     sync_parent_posts!(post, snapshot[:parent_post_ids])

backend/app/controllers/tag_versions_controller.rb

@@ -17,7 +17,6 @@ class TagVersionsController < ApplicationController
               AND prev.version_no = tag_versions.version_no - 1
         SQL
       .select('tag_versions.*', 'prev.name AS prev_name', 'prev.category AS prev_category',
-              'prev.deprecated_at AS prev_deprecated_at',
               'prev.aliases AS prev_aliases', 'prev.parent_tag_ids AS prev_parent_tag_ids')
     q = q.where('tag_versions.tag_id = ?', tag_id) if tag_id
 
@@ -63,8 +62,6 @@ class TagVersionsController < ApplicationController
         event_type: row.event_type,
         name: { current: row.name, prev: row.attributes['prev_name'] },
         category: { current: row.category, prev: row.attributes['prev_category'] },
-        deprecated_at: { current: row.deprecated_at&.iso8601,
-                         prev: row.attributes['prev_deprecated_at']&.iso8601 },
         aliases: build_version_values(cur_aliases, prev_aliases, key: :name),
         parent_tags:,
         created_at: row.created_at.iso8601,

backend/app/controllers/tags_controller.rb

@@ -1,6 +1,5 @@
 require 'net/http'
 require 'uri'
-require 'set'
 
 
 class TagsController < ApplicationController
@@ -15,8 +14,6 @@ class TagsController < ApplicationController
     post_count_between[1] = nil if post_count_between[1] < 0
     created_between = params[:created_from].presence, params[:created_to].presence
     updated_between = params[:updated_from].presence, params[:updated_to].presence
-    deprecated_given = params.key?(:deprecated)
-    deprecated = bool?(:deprecated)
 
     order = params[:order].to_s.split(':', 2).map(&:strip)
     unless order[0].in?(['name', 'category', 'post_count', 'created_at', 'updated_at'])
@@ -51,9 +48,6 @@ class TagsController < ApplicationController
     q = q.where('tags.created_at <= ?', created_between[1]) if created_between[1]
     q = q.where('tags.updated_at >= ?', updated_between[0]) if updated_between[0]
     q = q.where('tags.updated_at <= ?', updated_between[1]) if updated_between[1]
-    if deprecated_given
-      q = deprecated ? q.where.not(deprecated_at: nil) : q.where(deprecated_at: nil)
-    end
 
     sort_sql =
         case order[0]
@@ -83,27 +77,37 @@ class TagsController < ApplicationController
     parent_tag_id = params[:parent].to_i
     parent_tag_id = nil if parent_tag_id <= 0
 
-    graph = build_with_depth_graph
-
     tag_ids =
         if parent_tag_id
-          visible_child_tag_ids(parent_tag_id, graph)
+          TagImplication.where(parent_tag_id:).select(:tag_id)
         else
-          visible_root_tag_ids(graph)
+          Tag.where.not(id: TagImplication.select(:tag_id)).select(:id)
         end
 
     tags =
         Tag
         .joins(:tag_name)
         .includes(:tag_name, :materials, tag_name: :wiki_page)
+        .where(category: [:meme, :character, :material])
         .where(id: tag_ids)
         .order('tag_names.name')
         .distinct
         .to_a
 
+    has_children_tag_ids =
+        if tags.empty?
+          []
+        else
+          TagImplication
+              .joins(:tag)
+              .where(parent_tag_id: tags.map(&:id),
+                     tags: { category: [:meme, :character, :material] })
+              .distinct
+              .pluck(:parent_tag_id)
+        end
+
     render json: tags.map { |tag|
-      TagRepr.base(tag).merge(has_children: visible_child_tag_ids(tag.id, graph).present?,
+      TagRepr.base(tag).merge(has_children: has_children_tag_ids.include?(tag.id), children: [])
-                              children: [])
     }
   end
 
@@ -129,7 +133,6 @@ class TagsController < ApplicationController
 
     base = Tag.joins(:tag_name)
               .includes(:tag_name, :materials, tag_name: :wiki_page)
-              .where(deprecated_at: nil)
     base = base.where('tags.post_count > 0') if present_only
 
     canonical_hit =
@@ -249,24 +252,18 @@ class TagsController < ApplicationController
     category = params[:category].to_s.strip
     return render_unprocessable_entity('名前は必須です．', field: :name) if name.blank?
     return render_unprocessable_entity('カテゴリは必須です．', field: :category) if category.blank?
-    return render_unprocessable_entity '廃止状態は必須です．', field: :deprecated unless params.key?(:deprecated)
 
-    if (name != tag.name &&
+    if name != tag.name &&
-        tag.in?([Tag.tagme, Tag.bot, Tag.no_deerjikist, Tag.video, Tag.niconico]))
+        tag.in?([Tag.tagme, Tag.bot, Tag.no_deerjikist, Tag.video, Tag.niconico])
-      return render_unprocessable_entity 'システム・タグの名称は変更できません．', field: :name
+      return render_unprocessable_entity('システム・タグの名称は変更できません．', field: :name)
+    end
+
+    if tag.nico? || category == 'nico'
+      return render_unprocessable_entity('ニコタグは変更できません．', field: :category)
     end
 
     alias_names = params[:aliases].to_s.split.uniq
     parent_names = params[:parent_tags].to_s.split.uniq
-    deprecated = bool?(:deprecated)
-
-    if tag.nico? && deprecated
-      return render_unprocessable_entity 'ニコタグは廃止できません．', field: :deprecated
-    end
-
-    if tag.nico? || category == 'nico'
-      return render_unprocessable_entity 'ニコタグは変更できません．', field: :category
-    end
 
     ApplicationRecord.transaction do
       TagVersioning.ensure_snapshot!(tag, created_by_user: current_user)
@@ -275,11 +272,7 @@ class TagsController < ApplicationController
       name_changed = name != old_name
       wiki_page = tag.tag_name.wiki_page if name_changed
 
-      if tag.deprecated? == deprecated
+      tag.update!(category:)
-        tag.update!(category:)
-      else
-        tag.update!(category:, deprecated_at: deprecated ? Time.current : nil)
-      end
       tag.tag_name.update!(name:)
 
       alias_names << old_name if name_changed
@@ -307,17 +300,11 @@ class TagsController < ApplicationController
 
     name = params[:name].presence
     category = params[:category].presence
-    deprecated_given = params.key?(:deprecated)
-    deprecated = bool?(:deprecated)
 
     tag = Tag.find(params[:id])
 
-    if tag.nico? && deprecated_given && deprecated
-      return render_unprocessable_entity 'ニコタグは廃止できません．', field: :deprecated
-    end
-
     if tag.nico? || (category.present? && category == 'nico')
-      return render_unprocessable_entity 'ニコタグは変更できません．', field: :category
+      return render_unprocessable_entity('ニコタグは変更できません．', field: :category)
     end
 
     ApplicationRecord.transaction do
@@ -329,9 +316,6 @@ class TagsController < ApplicationController
 
       tag.tag_name.update!(name:) if name.present?
       tag.update!(category:) if category.present?
-      if deprecated_given && tag.deprecated? != deprecated
-        tag.update!(deprecated_at: deprecated ? Time.current : nil)
-      end
 
       tag.reload
 
@@ -348,93 +332,6 @@ class TagsController < ApplicationController
 
   private
 
-  def build_with_depth_graph
-    children_by_parent_id = Hash.new { |h, k| h[k] = [] }
-    parent_ids_by_child_id = Hash.new { |h, k| h[k] = [] }
-
-    TagImplication.pluck(:parent_tag_id, :tag_id).each do |parent_id, child_id|
-      children_by_parent_id[parent_id] << child_id
-      parent_ids_by_child_id[child_id] << parent_id
-    end
-
-    tag_ids = (children_by_parent_id.keys +
-               parent_ids_by_child_id.keys +
-               Tag.where(category: ['meme', 'character', 'material']).pluck(:id)).uniq
-
-    tags_by_id = Tag.where(id: tag_ids)
-                    .pluck(:id, :category, :deprecated_at)
-                    .each_with_object({ }) do |(id, category, deprecated_at), h|
-      h[id] = { category:, deprecated: deprecated_at.present? }
-    end
-
-    { children_by_parent_id:, parent_ids_by_child_id:, tags_by_id:,
-      visible_child_tag_ids_by_parent_id: { } }
-  end
-
-  def visible_root_tag_ids graph
-    graph[:tags_by_id].filter_map do |tag_id, attrs|
-      next unless with_depth_visible_tag?(attrs)
-      next unless visible_root_tag?(tag_id, graph)
-
-      tag_id
-    end
-  end
-
-  def visible_root_tag? tag_id, graph
-    seen = Set.new([tag_id])
-    stack = graph[:parent_ids_by_child_id][tag_id].dup
-
-    until stack.empty?
-      parent_id = stack.pop
-      next if seen.include?(parent_id)
-
-      seen << parent_id
-
-      parent = graph[:tags_by_id][parent_id]
-      next unless parent
-
-      return false unless parent[:deprecated]
-
-      stack.concat(graph[:parent_ids_by_child_id][parent_id])
-    end
-
-    true
-  end
-
-  def visible_child_tag_ids parent_tag_id, graph
-    cache = graph[:visible_child_tag_ids_by_parent_id]
-    return cache[parent_tag_id] if cache.key?(parent_tag_id)
-
-    visible_ids = Set.new
-
-    graph[:children_by_parent_id][parent_tag_id].each do |child_tag_id|
-      collect_visible_child_tag_ids(child_tag_id, graph, visible_ids, Set.new([parent_tag_id]))
-    end
-
-    cache[parent_tag_id] = visible_ids.to_a
-  end
-
-  def collect_visible_child_tag_ids tag_id, graph, visible_ids, seen
-    return if seen.include?(tag_id)
-
-    seen = seen.dup << tag_id
-    tag = graph[:tags_by_id][tag_id]
-    return unless tag
-
-    if tag[:deprecated]
-      graph[:children_by_parent_id][tag_id].each do |child_tag_id|
-        collect_visible_child_tag_ids(child_tag_id, graph, visible_ids, seen)
-      end
-      return
-    end
-
-    visible_ids << tag_id if with_depth_visible_tag?(tag)
-  end
-
-  def with_depth_visible_tag? tag
-    tag[:category].in?(['meme', 'character', 'material']) && !tag[:deprecated]
-  end
-
   def build_tag_children tag
     material = tag.materials.first
     file = nil

backend/app/controllers/wiki_pages_controller.rb

@@ -4,18 +4,17 @@ class WikiPagesController < ApplicationController
   def index
     title = params[:title].to_s.strip
     if title.blank?
-      return render json: WikiPageRepr.base(
+      return render json: WikiPageRepr.base(WikiPage.joins(:tag_name).includes(:tag_name))
-          WikiPage.joins(:tag_name).includes(tag_name: :tag))
     end
 
-    q = WikiPage.joins(:tag_name).includes(tag_name: :tag)
+    q = WikiPage.joins(:tag_name).includes(:tag_name)
         .where('tag_names.name LIKE ?', "%#{ WikiPage.sanitize_sql_like(title) }%")
     render json: WikiPageRepr.base(q.limit(20))
   end
 
   def show
     page = WikiPage.joins(:tag_name)
-                   .includes(tag_name: :tag)
+                   .includes(:tag_name)
                    .find_by(id: params[:id])
     render_wiki_page_or_404 page
   end
@@ -23,7 +22,7 @@ class WikiPagesController < ApplicationController
   def show_by_title
     title = params[:title].to_s.strip
     page = WikiPage.joins(:tag_name)
-                   .includes(tag_name: :tag)
+                   .includes(:tag_name)
                    .find_by(tag_name: { name: title })
     render_wiki_page_or_404 page
   end
@@ -52,7 +51,7 @@ class WikiPagesController < ApplicationController
     from = params[:from].presence
     to = params[:to].presence
 
-    page = WikiPage.joins(:tag_name).includes(tag_name: :tag).find(id)
+    page = WikiPage.joins(:tag_name).includes(:tag_name).find(id)
 
     from_rev = from && page.wiki_revisions.find(from)
     to_rev = to ? page.wiki_revisions.find(to) : page.current_revision
@@ -77,7 +76,6 @@ class WikiPagesController < ApplicationController
 
     render json: { wiki_page_id:      page.id,
                    title:             page.title,
-                   deprecated_at:     page.deprecated_at,
                    older_revision_id: from_rev&.id,
                    newer_revision_id: to_rev.id,
                    diff:              diff_json }
@@ -159,7 +157,7 @@ class WikiPagesController < ApplicationController
   def changes
     id = params[:id].presence
     q = WikiRevision.joins(wiki_page: :tag_name)
-                    .includes(:created_user, wiki_page: { tag_name: :tag })
+                    .includes(:created_user, wiki_page: :tag_name)
                     .order(id: :desc)
     q = q.where(wiki_page_id: id) if id
 
@@ -167,9 +165,7 @@ class WikiPagesController < ApplicationController
       { revision_id:  rev.id,
         pred:         rev.base_revision_id,
         succ:         nil,
-        wiki_page:    { id: rev.wiki_page_id,
+        wiki_page:    { id: rev.wiki_page_id, title: rev.wiki_page.title },
-                        title: rev.wiki_page.title,
-                        deprecated_at: rev.wiki_page.deprecated_at },
         user:         rev.created_user && { id: rev.created_user.id, name: rev.created_user.name },
         kind:         rev.kind,
         message:      rev.message,

backend/app/models/post.rb

@@ -7,8 +7,6 @@ class Post < ApplicationRecord
   has_many :active_post_tags, -> { kept }, class_name: 'PostTag', inverse_of: :post
   has_many :post_tags_with_discarded, -> { with_discarded }, class_name: 'PostTag'
   has_many :tags, through: :active_post_tags
-  has_many :active_tags, -> { where(tags: { deprecated_at: nil }) },
-           through: :active_post_tags, source: :tag
 
   has_many :user_post_views, dependent: :delete_all
   has_many :post_similarities, dependent: :delete_all

backend/app/models/tag.rb

@@ -8,15 +8,6 @@ class Tag < ApplicationRecord
     ;
   end
 
-  class DeprecatedTagNormalisationError < ArgumentError
-    attr_reader :tag_names
-
-    def initialize tag_names
-      @tag_names = Array(tag_names)
-      super('deprecated tags are not allowed')
-    end
-  end
-
   has_many :post_tags, inverse_of: :tag
   has_many :active_post_tags, -> { kept }, class_name: 'PostTag', inverse_of: :tag
   has_many :post_tags_with_discarded, -> { with_discarded }, class_name: 'PostTag'
@@ -67,7 +58,6 @@ class Tag < ApplicationRecord
   validate :nico_tag_name_must_start_with_nico
   validate :tag_name_must_be_canonical
   validate :category_must_be_deerjikist_with_deerjikists
-  validate :nico_tags_cannot_be_deprecated
 
   scope :nico_tags, -> { nico }
 
@@ -87,8 +77,6 @@ class Tag < ApplicationRecord
     (self.tag_name ||= build_tag_name).name = val
   end
 
-  def deprecated? = deprecated_at?
-
   def has_wiki = wiki_page.present?
 
   def material_id = materials.first&.id
@@ -104,8 +92,7 @@ class Tag < ApplicationRecord
 
   def self.normalise_tags! tag_names, with_tagme: true,
                                       with_no_deerjikist: true,
-                                      deny_nico: true,
+                                      deny_nico: true
-                                      deny_deprecated: false
     if deny_nico && tag_names.any? { |n| n.downcase.start_with?('nico:') }
       raise NicoTagNormalisationError
     end
@@ -114,10 +101,6 @@ class Tag < ApplicationRecord
       pf, cat = CATEGORY_PREFIXES.find { |p, _| name.downcase.start_with?(p) } || ['', nil]
       name = TagName.canonicalise(name.sub(/\A#{ pf }/i, '')).first
       find_or_create_by_tag_name!(name, category: (cat || :general)).tap do |tag|
-        if deny_deprecated && tag.deprecated?
-          raise DeprecatedTagNormalisationError, [tag.name]
-        end
-
         tag.update!(category: cat) if cat && tag.category != cat
       end
     end
@@ -245,10 +228,4 @@ class Tag < ApplicationRecord
       errors.add :category, 'ニジラーと紐づいてゐるタグはニジラー・カテゴリである必要があります．'
     end
   end
-
-  def nico_tags_cannot_be_deprecated
-    if nico? && deprecated_at.present?
-      errors.add :deprecated_at, 'ニコタグは廃止できません．'
-    end
-  end
 end

backend/app/models/wiki_page.rb

@@ -22,7 +22,6 @@ class WikiPage < ApplicationRecord
   validates :body, presence: true
 
   def title = tag_name.name
-  def deprecated_at = tag_name.tag&.deprecated_at
 
   def title= val
     (self.tag_name ||= build_tag_name).name = val

backend/app/representations/post_repr.rb

@@ -53,7 +53,7 @@ module PostRepr
   end
 
   def tag_json tags
-    tags.reject(&:deprecated?).map { |tag| TagRepr.inline(tag) }
+    tags.map { |tag| TagRepr.inline(tag) }
   end
 
   def thumbnail_url post

backend/app/representations/tag_repr.rb

@@ -2,7 +2,7 @@
 
 
 module TagRepr
-  BASE = { only: [:id, :category, :post_count, :created_at, :updated_at, :deprecated_at],
+  BASE = { only: [:id, :category, :post_count, :created_at, :updated_at],
            methods: [:name, :has_wiki, :material_id, :has_deerjikists] }.freeze
 
   module_function

backend/app/representations/wiki_page_repr.rb

@@ -2,7 +2,7 @@
 
 
 module WikiPageRepr
-  BASE = { methods: [:title, :deprecated_at] }.freeze
+  BASE = { methods: [:title] }.freeze
 
   module_function
 

backend/app/services/similarity/calc.rb

@@ -1,6 +1,6 @@
 module Similarity
   class Calc
-    def self.call model, tgt, scope: nil
+    def self.call model, tgt
       similarity_model = "#{ model.name }Similarity".constantize
 
       # 最大保存件数
@@ -8,8 +8,7 @@ module Similarity
 
       similarity_model.delete_all
 
-      scope ||= model.all
+      posts = model.includes(tgt).select(:id).to_a
-      posts = scope.includes(tgt).select(:id).to_a
 
       tag_ids = { }
       tag_cnts = { }

backend/app/services/tag_version_recorder.rb

@@ -16,7 +16,6 @@ class TagVersionRecorder < VersionRecorder
   def snapshot_attributes
     { name: @record.name,
       category: @record.category,
-      deprecated_at: @record.deprecated_at,
       aliases: @record.snapshot_aliases.join(' '),
       parent_tag_ids: @record.snapshot_parent_tag_ids.join(' ') }
   end

backend/db/migrate/20260621000000_add_deprecated_at_to_tags.rb

@@ -1,20 +0,0 @@
-class AddDeprecatedAtToTags < ActiveRecord::Migration[8.0]
-  def up
-    add_column :tags, :deprecated_at, :datetime, after: :category
-    add_column :tag_versions, :deprecated_at, :datetime, after: :parent_tag_ids
-
-    add_index :tags, :deprecated_at
-
-    add_check_constraint :tags, "deprecated_at IS NULL OR category <> 'nico'",
-                         name: 'chk_tags_deprecated_at_not_nico'
-  end
-
-  def down
-    remove_check_constraint :tags, name: 'chk_tags_deprecated_at_not_nico'
-
-    remove_index :tags, :deprecated_at
-
-    remove_column :tag_versions, :deprecated_at, :datetime
-    remove_column :tags, :deprecated_at
-  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_21_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
@@ -319,7 +319,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_21_000000) do
     t.string "event_type", null: false
     t.string "name", null: false
     t.string "category", null: false
-    t.datetime "deprecated_at"
     t.text "aliases", null: false
     t.text "parent_tag_ids", null: false
     t.datetime "created_at", null: false
@@ -337,13 +336,10 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_21_000000) do
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.integer "post_count", default: 0, null: false
-    t.datetime "deprecated_at"
     t.datetime "discarded_at"
     t.integer "version_no", null: false
-    t.index ["deprecated_at"], name: "index_tags_on_deprecated_at"
     t.index ["discarded_at"], name: "index_tags_on_discarded_at"
     t.index ["tag_name_id"], name: "index_tags_on_tag_name_id", unique: true
-    t.check_constraint "(`deprecated_at` is null) or (`category` <> _utf8mb4'nico')", name: "chk_tags_deprecated_at_not_nico"
     t.check_constraint "`version_no` > 0", name: "chk_tags_version_no_positive"
   end
 

backend/lib/tasks/calc_post_similarities.rake

@@ -1,6 +1,6 @@
 namespace :post_similarity do
   desc '関聯投稿テーブル作成'
   task calc: :environment do
-    Similarity::Calc.call(Post, :active_tags)
+    Similarity::Calc.call(Post, :tags)
   end
 end

backend/lib/tasks/calc_tag_similarities.rake

@@ -1,6 +1,6 @@
 namespace :tag_similarity do
   desc '関聯タグ・テーブル作成'
   task calc: :environment do
-    Similarity::Calc.call(Tag, :posts, scope: Tag.where(deprecated_at: nil))
+    Similarity::Calc.call(Tag, :posts)
   end
 end

backend/spec/models/tag_name_sanitisation_rule_spec.rb

@@ -1,10 +1,6 @@
 require 'rails_helper'
 
 RSpec.describe TagNameSanitisationRule, type: :model do
-  before do
-    described_class.unscoped.delete_all
-  end
-
   describe '.sanitise' do
     before do
       described_class.create!(priority: 10, source_pattern: '_', replacement: '')

backend/spec/models/tag_spec.rb

@@ -1,79 +1,6 @@
 require 'rails_helper'
 
 RSpec.describe Tag, type: :model do
-  describe '.normalise_tags!' do
-    it 'rejects deprecated tags when deny_deprecated is enabled' do
-      tag_name = TagName.create!(name: 'normalise deprecated tag')
-      deprecated_tag = Tag.create!(
-        tag_name:,
-        category: :general,
-        deprecated_at: 1.day.from_now
-      )
-
-      expect {
-        described_class.normalise_tags!(
-          [deprecated_tag.name],
-          deny_deprecated: true
-        )
-      }.to raise_error(Tag::DeprecatedTagNormalisationError) { |error|
-        expect(error.tag_names).to eq([deprecated_tag.name])
-      }
-    end
-  end
-
-  describe '.expand_parent_tags' do
-    it 'expands through multiple deprecated parents to an active ancestor' do
-      child = create(:tag, name: 'expand_child')
-      deprecated_parent = create(
-        :tag,
-        name: 'expand_deprecated_parent',
-        deprecated_at: Time.current
-      )
-      deprecated_grandparent = create(
-        :tag,
-        name: 'expand_deprecated_grandparent',
-        deprecated_at: Time.current
-      )
-      active_ancestor = create(:tag, name: 'expand_active_ancestor')
-      TagImplication.create!(tag: child, parent_tag: deprecated_parent)
-      TagImplication.create!(tag: deprecated_parent, parent_tag: deprecated_grandparent)
-      TagImplication.create!(tag: deprecated_grandparent, parent_tag: active_ancestor)
-
-      expanded = described_class.expand_parent_tags([child])
-
-      expect(expanded).to include(
-        child,
-        deprecated_parent,
-        deprecated_grandparent,
-        active_ancestor
-      )
-      expect(expanded.reject(&:deprecated?)).to contain_exactly(child, active_ancestor)
-    end
-
-    it 'terminates when implications contain a cycle' do
-      first = create(:tag, name: 'expand_cycle_first')
-      second = create(:tag, name: 'expand_cycle_second')
-      TagImplication.create!(tag: first, parent_tag: second)
-      TagImplication.create!(tag: second, parent_tag: first)
-
-      expect(described_class.expand_parent_tags([first])).to contain_exactly(first, second)
-    end
-  end
-
-  describe 'deprecated validation' do
-    it 'rejects deprecated nico tags' do
-      tag = build(
-        :tag,
-        name: 'nico:deprecated_validation',
-        category: :nico,
-        deprecated_at: Time.current
-      )
-
-      expect(tag).not_to be_valid
-      expect(tag.errors[:deprecated_at]).to include('ニコタグは廃止できません．')
-    end
-  end
-
   describe '.merge_tags!' do
     let!(:target_tag) { create(:tag, category: :general) }
     let!(:source_tag) { create(:tag, category: :general) }

backend/spec/requests/gekanator_learning_spec.rb

@@ -206,40 +206,6 @@ RSpec.describe 'Gekanator learning API', type: :request do
       expect(example.gekanator_game_id).to eq(json['id'])
     end
 
-    it 'learns accepted post_similarity answers from main game logs' do
-      sign_in_as admin
-
-      question = create_post_similarity_question!(text: '泣いてる?')
-
-      expect {
-        post '/gekanator/games', params: {
-          guessed_post_id: guessed_post.id,
-          correct_post_id: correct_post.id,
-          answers: [
-            {
-              question_id: "post-similarity:#{question.id}",
-              question_text: '泣いてる?',
-              answer: 'partial',
-              original_answer: 'partial'
-            }
-          ]
-        }
-      }.to change { GekanatorQuestionExample.count }.by(1)
-
-      expect(response).to have_http_status(:created)
-      expect(json['learned_example_count']).to eq(1)
-
-      example = GekanatorQuestionExample.last
-      expect(example).to have_attributes(
-        gekanator_question_id: question.id,
-        post_id: correct_post.id,
-        user_id: admin.id,
-        answer: 'partial',
-        source: 'post_game_answer'
-      )
-      expect(example.gekanator_game_id).to eq(json['id'])
-    end
-
     it 'does not learn fact questions or nico tag questions from main game logs' do
       sign_in_as admin
 
@@ -509,59 +475,28 @@ RSpec.describe 'Gekanator learning API', type: :request do
   end
 
   describe 'GET /gekanator/games/:id/extra_questions' do
-    it 'returns at most six accepted user_suggested post_similarity questions without duplicates' do
+    it 'returns at most two accepted user_suggested post_similarity questions without duplicates' do
       sign_in_as admin
 
-      lowest = create_post_similarity_question!(
-        text: 'lowest?',
-        priority_weight: 0.5
-      )
       low = create_post_similarity_question!(
         text: 'low?',
         priority_weight: 1.0
       )
-      middle = create_post_similarity_question!(
-        text: 'middle?',
-        priority_weight: 1.5
-      )
-      medium_high = create_post_similarity_question!(
-        text: 'medium high?',
-        priority_weight: 2.0
-      )
       high = create_post_similarity_question!(
         text: 'high?',
-        priority_weight: 2.5
-      )
-      higher = create_post_similarity_question!(
-        text: 'higher?',
-        priority_weight: 2.8
-      )
-      highest = create_post_similarity_question!(
-        text: 'highest?',
         priority_weight: 3.0
       )
-      overflow = create_post_similarity_question!(
+      middle = create_post_similarity_question!(
-        text: 'overflow?',
+        text: 'middle?',
-        priority_weight: 2.2
+        priority_weight: 2.0
       )
 
       get "/gekanator/games/#{game.id}/extra_questions"
 
       expect(response).to have_http_status(:ok)
-      expect(json['questions'].length).to eq(6)
+      expect(json['questions'].length).to eq(2)
-      expect(json['questions'].map { _1['id'] }.uniq.length).to eq(6)
+      expect(json['questions'].map { _1['id'] }.uniq.length).to eq(2)
-      expect(json['questions'].map { _1['id'] }).to all(
+      expect(json['questions'].map { _1['id'] }).to all(be_in([low.id, high.id, middle.id]))
-        be_in([
-          lowest.id,
-          low.id,
-          middle.id,
-          medium_high.id,
-          high.id,
-          higher.id,
-          highest.id,
-          overflow.id,
-        ])
-      )
     end
 
     it 'can return questions that already have an example for the correct post' do
@@ -584,37 +519,6 @@ RSpec.describe 'Gekanator learning API', type: :request do
       expect(json['questions'].map { _1['id'] }).to include(existing.id)
     end
 
-    it 'prioritizes questions the current user has not answered' do
-      sign_in_as admin
-
-      answered = create_post_similarity_question!(
-        text: 'already answered?',
-        priority_weight: 3.0
-      )
-      GekanatorQuestionExample.create!(
-        gekanator_question: answered,
-        post: other_post,
-        user: admin,
-        answer: 'yes',
-        source: 'post_game_extra'
-      )
-
-      unanswered =
-          6.times.map { |index|
-            create_post_similarity_question!(
-              text: "unanswered #{index}?",
-              priority_weight: 0.5
-            )
-          }
-
-      get "/gekanator/games/#{game.id}/extra_questions"
-
-      expect(response).to have_http_status(:ok)
-      expect(json['questions'].map { _1['id'] }).to match_array(
-        unanswered.map(&:id)
-      )
-    end
-
     it 'can return questions already asked in the game using snake_case question_id' do
       sign_in_as admin
 
@@ -897,37 +801,6 @@ RSpec.describe 'Gekanator learning API', type: :request do
   end
 
   describe 'GET /gekanator/questions' do
-    it 'omits questions for deprecated tags' do
-      active_tag = Tag.create!(name: 'active_question_tag', category: :general)
-      deprecated_tag = Tag.create!(
-        name: 'deprecated_question_tag',
-        category: :general,
-        deprecated_at: Time.current
-      )
-
-      [active_tag, deprecated_tag].each do |question_tag|
-        GekanatorQuestion.create!(
-          text: "#{ question_tag.name }?",
-          kind: 'tag',
-          source: 'admin_curated',
-          status: 'accepted',
-          priority_weight: 1.0,
-          condition: {
-            type: 'tag',
-            key: "#{ question_tag.category }:#{ question_tag.name }"
-          },
-          created_by: admin
-        )
-      end
-
-      get '/gekanator/questions'
-
-      expect(response).to have_http_status(:ok)
-      question_ids = json.fetch('questions').map { |question| question.fetch('id') }
-      expect(question_ids).to include('tag:general:active_question_tag')
-      expect(question_ids).not_to include('tag:general:deprecated_question_tag')
-    end
-
     it 'returns accepted questions only and includes example_answers for post_similarity questions' do
       sign_in_as admin
 

backend/spec/requests/gekanator_posts_spec.rb

@@ -1,33 +0,0 @@
-require 'rails_helper'
-
-
-RSpec.describe 'Gekanator posts API', type: :request do
-  describe 'GET /gekanator/posts' do
-    it 'omits deprecated tags and returns the stored similarity cosine' do
-      active_tag = Tag.create!(name: 'active tag', category: :general)
-      deprecated_tag = Tag.create!(
-        name: 'deprecated tag',
-        category: :general,
-        deprecated_at: Time.current
-      )
-      post_record = Post.create!(title: 'source', url: 'https://example.com/source')
-      target_post = Post.create!(title: 'target', url: 'https://example.com/target')
-
-      PostTag.create!(post: post_record, tag: active_tag)
-      PostTag.create!(post: post_record, tag: deprecated_tag)
-      PostTag.create!(post: target_post, tag: deprecated_tag)
-      PostSimilarity.create!(post: post_record, target_post:, cos: 0.375)
-
-      get '/gekanator/posts'
-
-      expect(response).to have_http_status(:ok)
-
-      post_json = json.fetch('posts').find { |post| post.fetch('id') == post_record.id }
-      expect(post_json.fetch('tags').map { |tag| tag.fetch('name') }).to eq(['active tag'])
-      expect(post_json.fetch('post_similarity_edges')).to contain_exactly(
-        'target_post_id' => target_post.id,
-        'cos' => 0.375
-      )
-    end
-  end
-end

backend/spec/requests/posts_spec.rb

@@ -517,24 +517,6 @@ RSpec.describe 'Posts API', type: :request do
         expect([true, false]).to include(json['viewed'])
       end
 
-      it 'omits deprecated tags' do
-        deprecated_tag = Tag.create!(
-          name: 'deprecated_post_tag',
-          category: :general,
-          deprecated_at: Time.current
-        )
-        PostTag.create!(post: post_record, tag: deprecated_tag)
-
-        request
-
-        expect(response).to have_http_status(:ok)
-        tag_names = json.fetch('tags').flat_map { |node|
-          [node.fetch('name')] + node.fetch('children').map { |child| child.fetch('name') }
-        }
-        expect(tag_names).to include('spec_tag')
-        expect(tag_names).not_to include('deprecated_post_tag')
-      end
-
       context 'when post has parent, child, and sibling posts' do
         let!(:parent_post) do
           create_parent_post!(
@@ -715,58 +697,6 @@ RSpec.describe 'Posts API', type: :request do
       expect(names).not_to include('manko')
     end
 
-    it 'rejects a deprecated tag specified directly' do
-      Tag.create!(
-        name: 'deprecated_direct_tag',
-        category: :general,
-        deprecated_at: Time.current
-      )
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'new post',
-        url: 'https://example.com/deprecated-direct-tag',
-        tags: 'deprecated_direct_tag',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'tags' => ['廃止済みタグは付与できません．']
-      )
-    end
-
-    it 'expands through multiple deprecated parent tags and saves active ancestors' do
-      child = Tag.create!(name: 'active_child', category: :general)
-      deprecated_parent = Tag.create!(
-        name: 'deprecated_parent',
-        category: :general,
-        deprecated_at: Time.current
-      )
-      deprecated_grandparent = Tag.create!(
-        name: 'deprecated_grandparent',
-        category: :general,
-        deprecated_at: Time.current
-      )
-      active_grandparent = Tag.create!(name: 'active_grandparent', category: :general)
-      TagImplication.create!(tag: child, parent_tag: deprecated_parent)
-      TagImplication.create!(tag: deprecated_parent, parent_tag: deprecated_grandparent)
-      TagImplication.create!(tag: deprecated_grandparent, parent_tag: active_grandparent)
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'expanded post',
-        url: 'https://example.com/expanded-deprecated-parent',
-        tags: 'active_child',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:created)
-      saved_names = Post.find(json.fetch('id')).tags.map(&:name)
-      expect(saved_names).to include('active_child', 'active_grandparent')
-      expect(saved_names).not_to include('deprecated_parent', 'deprecated_grandparent')
-    end
-
     context "when nico tag already exists in tags" do
       before do
         Tag.find_undiscard_or_create_by!(
@@ -1000,26 +930,6 @@ RSpec.describe 'Posts API', type: :request do
       expect(names).to include('spec_tag_2')
     end
 
-    it 'rejects a deprecated tag specified directly' do
-      Tag.create!(
-        name: 'deprecated_update_tag',
-        category: :general,
-        deprecated_at: Time.current
-      )
-      sign_in_as(member)
-
-      put "/posts/#{ post_record.id }", params: post_update_params(
-        post_record,
-        title: 'updated title',
-        tags: 'deprecated_update_tag'
-      )
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'tags' => ['廃止済みタグは付与できません．']
-      )
-    end
-
     context "when nico tag already exists in tags" do
       before do
         Tag.find_undiscard_or_create_by!(

backend/spec/requests/tag_versions_spec.rb

@@ -21,7 +21,6 @@ RSpec.describe 'TagVersions API', type: :request do
     event_type:,
     name:,
     category:,
-    deprecated_at: nil,
     aliases: [],
     parent_tags: [],
     created_by_user:,
@@ -34,7 +33,6 @@ RSpec.describe 'TagVersions API', type: :request do
             event_type: event_type,
             name: name,
             category: category,
-            deprecated_at: deprecated_at,
             aliases: Array(aliases).join(' '),
             parent_tag_ids: Array(parent_tags).map(&:id).join(' '),
             created_by_user: created_by_user,
@@ -67,7 +65,6 @@ RSpec.describe 'TagVersions API', type: :request do
       event_type: 'update',
       name: 'new_tag_name',
       category: 'meme',
-      deprecated_at: t_v2,
       aliases: ['alias_shared', 'alias_new'],
       parent_tags: [parent_shared, parent_new],
       created_by_user: member,
@@ -136,10 +133,6 @@ RSpec.describe 'TagVersions API', type: :request do
         'current' => 'meme',
         'prev' => 'general'
       )
-      expect(latest.fetch('deprecated_at')).to eq(
-        'current' => t_v2.iso8601,
-        'prev' => nil
-      )
       expect(latest.fetch('aliases')).to include(
         { 'name' => 'alias_shared', 'type' => 'context' },
         { 'name' => 'alias_new', 'type' => 'added' },
@@ -185,10 +178,6 @@ RSpec.describe 'TagVersions API', type: :request do
         'current' => 'general',
         'prev' => nil
       )
-      expect(first.fetch('deprecated_at')).to eq(
-        'current' => nil,
-        'prev' => nil
-      )
       expect(first.fetch('aliases')).to include(
         { 'name' => 'alias_shared', 'type' => 'added' },
         { 'name' => 'alias_old', 'type' => 'added' }

backend/spec/requests/tag_wiki_history_integrity_spec.rb

@@ -89,7 +89,6 @@ RSpec.describe 'Tag and wiki history integrity', type: :request do
           category: 'general',
           aliases: '',
           parent_tags: '',
-          deprecated: '0',
         }
       }
           .to change(TagVersion, :count).by(2)
@@ -124,7 +123,6 @@ RSpec.describe 'Tag and wiki history integrity', type: :request do
           category: 'meme',
           aliases: '',
           parent_tags: '',
-          deprecated: '0',
         }
       }
           .to change(TagVersion, :count).by(2)
@@ -151,7 +149,6 @@ RSpec.describe 'Tag and wiki history integrity', type: :request do
           category: 'general',
           aliases: 'put_tag_alias_only_alias',
           parent_tags: '',
-          deprecated: '0',
         }
       }
           .to change(TagVersion, :count).by(2)

backend/spec/requests/tags_spec.rb

@@ -76,27 +76,6 @@ RSpec.describe 'Tags API', type: :request do
       expect(response_tags.first['id']).to eq(meme.id)
     end
 
-    it 'filters tags by deprecated state' do
-      deprecated_tag = Tag.create!(
-        name: 'deprecated_filter',
-        category: :general,
-        deprecated_at: 1.day.from_now
-      )
-      active_tag = Tag.create!(name: 'active_filter', category: :general)
-
-      get '/tags', params: { name: '_filter', deprecated: '1' }
-
-      expect(response).to have_http_status(:ok)
-      expect(response_names).to include(deprecated_tag.name)
-      expect(response_names).not_to include(active_tag.name)
-
-      get '/tags', params: { name: '_filter', deprecated: '0' }
-
-      expect(response).to have_http_status(:ok)
-      expect(response_names).to include(active_tag.name)
-      expect(response_names).not_to include(deprecated_tag.name)
-    end
-
     it 'filters tags by post_count range' do
       low = Tag.create!(tag_name: TagName.create!(name: 'pc_low'), category: :general)
       mid = Tag.create!(tag_name: TagName.create!(name: 'pc_mid'), category: :general)
@@ -322,21 +301,6 @@ RSpec.describe 'Tags API', type: :request do
       expect(t['matched_alias']).to eq('unko')
       expect(json.map { |x| x['name'] }).not_to include('unknown')
     end
-
-    it 'omits deprecated tags' do
-      deprecated_tag = Tag.create!(
-        name: 'spec_deprecated',
-        category: :general,
-        deprecated_at: Time.current
-      )
-      deprecated_tag.update_columns(post_count: 1)
-
-      get '/tags/autocomplete', params: { q: 'spec_', present: '0' }
-
-      expect(response).to have_http_status(:ok)
-      expect(json.map { |item| item.fetch('name') }).to include('spec_tag')
-      expect(json.map { |item| item.fetch('name') }).not_to include('spec_deprecated')
-    end
   end
 
   describe 'GET /tags/name/:name' do
@@ -473,32 +437,6 @@ RSpec.describe 'Tags API', type: :request do
         expect(versions.second.created_by_user_id).to eq(member_user.id)
       end
 
-      it 'updates deprecated state and records it in tag versions' do
-        expect {
-          patch "/tags/#{ tag.id }", params: { deprecated: '1' }
-        }.to change(TagVersion, :count).by(2)
-
-        expect(response).to have_http_status(:ok)
-        expect(tag.reload.deprecated_at).to be_present
-
-        versions = tag.tag_versions.order(:version_no)
-        expect(versions.first.deprecated_at).to be_nil
-        expect(versions.second.deprecated_at).to eq(tag.deprecated_at)
-        expect(json.fetch('deprecated_at')).to be_present
-      end
-
-      it 'rejects deprecating a nico tag' do
-        nico_tag = Tag.create!(name: 'nico:deprecated_update', category: :nico)
-
-        patch "/tags/#{ nico_tag.id }", params: { deprecated: '1' }
-
-        expect(response).to have_http_status(:unprocessable_entity)
-        expect(nico_tag.reload.deprecated_at).to be_nil
-        expect(json.fetch('errors')).to include(
-          'deprecated' => ['ニコタグは廃止できません．']
-        )
-      end
-
       it 'returns 422 when changing normal tag category to nico' do
         expect {
           patch "/tags/#{tag.id}", params: { category: 'nico' }
@@ -647,111 +585,6 @@ RSpec.describe 'Tags API', type: :request do
       expect(row['has_children']).to eq(true)
       expect(row['children']).to eq([])
     end
-
-    it 'passes through deprecated tags when finding children' do
-      deprecated_middle = Tag.create!(
-        name: 'depth_deprecated_middle',
-        category: :character,
-        deprecated_at: Time.current
-      )
-      visible_descendant = Tag.create!(
-        name: 'depth_visible_descendant',
-        category: :material
-      )
-      TagImplication.create!(parent_tag: root_material, tag: deprecated_middle)
-      TagImplication.create!(parent_tag: deprecated_middle, tag: visible_descendant)
-
-      get '/tags/with-depth', params: { parent: root_material.id }
-
-      expect(response).to have_http_status(:ok)
-      expect(json.map { |item| item.fetch('name') }).to eq(['depth_visible_descendant'])
-      expect(json.map { |item| item.fetch('name') }).not_to include('depth_deprecated_middle')
-    end
-
-    it 'passes through multiple deprecated tags for roots and has_children' do
-      active_child = Tag.create!(
-        name: 'depth_active_child_below_deprecated',
-        category: :character
-      )
-      deprecated_parent = Tag.create!(
-        name: 'depth_deprecated_parent',
-        category: :character,
-        deprecated_at: Time.current
-      )
-      deprecated_grandparent = Tag.create!(
-        name: 'depth_deprecated_grandparent',
-        category: :material,
-        deprecated_at: Time.current
-      )
-      active_ancestor = Tag.create!(
-        name: 'depth_active_ancestor',
-        category: :meme
-      )
-      TagImplication.create!(tag: active_child, parent_tag: deprecated_parent)
-      TagImplication.create!(tag: deprecated_parent, parent_tag: deprecated_grandparent)
-      TagImplication.create!(tag: deprecated_grandparent, parent_tag: active_ancestor)
-
-      get '/tags/with-depth'
-
-      root_names = json.map { |item| item.fetch('name') }
-      expect(root_names).to include('depth_active_ancestor')
-      expect(root_names).not_to include('depth_active_child_below_deprecated')
-      ancestor_json = json.find { |item| item.fetch('id') == active_ancestor.id }
-      expect(ancestor_json.fetch('has_children')).to eq(true)
-
-      get '/tags/with-depth', params: { parent: active_ancestor.id }
-
-      expect(json.map { |item| item.fetch('name') }).to include(
-        'depth_active_child_below_deprecated'
-      )
-      expect(json.map { |item| item.fetch('name') }).not_to include(
-        'depth_deprecated_parent',
-        'depth_deprecated_grandparent'
-      )
-    end
-
-    it 'treats an active tag with only deprecated ancestors as a root' do
-      active_child = Tag.create!(
-        name: 'depth_root_below_deprecated',
-        category: :character
-      )
-      deprecated_parent = Tag.create!(
-        name: 'depth_root_deprecated_parent',
-        category: :material,
-        deprecated_at: Time.current
-      )
-      TagImplication.create!(tag: active_child, parent_tag: deprecated_parent)
-
-      get '/tags/with-depth'
-
-      expect(json.map { |item| item.fetch('name') }).to include(
-        'depth_root_below_deprecated'
-      )
-      expect(json.map { |item| item.fetch('name') }).not_to include(
-        'depth_root_deprecated_parent'
-      )
-    end
-
-    it 'terminates when deprecated implications contain a cycle' do
-      first = Tag.create!(
-        name: 'depth_cycle_first',
-        category: :character,
-        deprecated_at: Time.current
-      )
-      second = Tag.create!(
-        name: 'depth_cycle_second',
-        category: :material,
-        deprecated_at: Time.current
-      )
-      TagImplication.create!(tag: first, parent_tag: root_material)
-      TagImplication.create!(tag: second, parent_tag: first)
-      TagImplication.create!(tag: first, parent_tag: second)
-
-      get '/tags/with-depth', params: { parent: root_material.id }
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to eq([])
-    end
   end
 
   describe 'GET /tags/name/:name/materials' do
@@ -899,20 +732,6 @@ RSpec.describe 'Tags API', type: :request do
         expect(tag.category).to eq('general')
       end
 
-      it 'deprecated がなければ 422 を返す' do
-        put "/tags/#{ tag.id }", params: {
-          name: 'new',
-          category: 'general',
-          aliases: '',
-          parent_tags: '',
-        }
-
-        expect(response).to have_http_status(:unprocessable_entity)
-        expect(json.fetch('errors')).to include(
-          'deprecated' => ['廃止状態は必須です．']
-        )
-      end
-
       it 'name, category, aliases, parent tags をまとめて更新できる' do
         old_parent = Tag.create!(
           tag_name: TagName.create!(name: 'put_old_parent'),
@@ -930,7 +749,6 @@ RSpec.describe 'Tags API', type: :request do
           category: 'meme',
           aliases: 'put_alias_a put_alias_b put_alias_a',
           parent_tags: 'put_kept_parent put_new_parent',
-          deprecated: '0',
         }
 
         expect(response).to have_http_status(:ok)
@@ -975,7 +793,6 @@ RSpec.describe 'Tags API', type: :request do
           category: 'general',
           aliases: 'spec_tag put_alias_self_test',
           parent_tags: '',
-          deprecated: '0',
         }
 
         expect(response).to have_http_status(:ok)
@@ -993,7 +810,6 @@ RSpec.describe 'Tags API', type: :request do
           category: 'general',
           aliases: 'unko',
           parent_tags: 'spec_tag',
-          deprecated: '0',
         }
 
         expect(response).to have_http_status(:ok)
@@ -1009,7 +825,6 @@ RSpec.describe 'Tags API', type: :request do
             category: 'meta',
             aliases: '',
             parent_tags: '',
-            deprecated: '0',
           }
         }.to change(TagVersion, :count).by(2)
 
@@ -1045,7 +860,6 @@ RSpec.describe 'Tags API', type: :request do
           category: 'general',
           aliases: 'unko',
           parent_tags: new_parent.name,
-          deprecated: '0',
         }
 
         expect(response).to have_http_status(:ok)
@@ -1061,7 +875,6 @@ RSpec.describe 'Tags API', type: :request do
             category: 'nico',
             aliases: '',
             parent_tags: '',
-            deprecated: '0',
           }
         }.not_to change(TagVersion, :count)
 
@@ -1083,7 +896,6 @@ RSpec.describe 'Tags API', type: :request do
             category: 'nico',
             aliases: '',
             parent_tags: '',
-            deprecated: '0',
           }
         }.not_to change(NicoTagVersion, :count)
 
@@ -1104,7 +916,6 @@ RSpec.describe 'Tags API', type: :request do
             category: old_category,
             aliases: '',
             parent_tags: '',
-            deprecated: '0',
           }
         }.not_to change(TagVersion, :count)
 
@@ -1135,7 +946,6 @@ RSpec.describe 'Tags API', type: :request do
             category: 'meme',
             aliases: 'unko',
             parent_tags: '',
-            deprecated: '0',
           }
         }
             .to change(TagVersion, :count).by(2)
@@ -1171,7 +981,6 @@ RSpec.describe 'Tags API', type: :request do
             category: 'general',
             aliases: 'unko put_stolen_alias',
             parent_tags: '',
-            deprecated: '0',
           }
         }
             .to change { tag.reload.tag_versions.count }.by(2)
@@ -1206,7 +1015,6 @@ RSpec.describe 'Tags API', type: :request do
           category: 'general',
           aliases: 'unko',
           parent_tags: child.name,
-          deprecated: '0',
         }
 
         expect(response).to have_http_status(:unprocessable_entity)
@@ -1228,7 +1036,6 @@ RSpec.describe 'Tags API', type: :request do
             category: 'general',
             aliases: 'unko',
             parent_tags: '',
-            deprecated: '0',
           }
         }
             .to change(TagVersion, :count).by(2)

backend/spec/requests/wiki_spec.rb

@@ -18,13 +18,6 @@ RSpec.describe 'Wiki API', type: :request do
         created_by_user: user,
         message: 'init')
   end
-  let!(:tag) do
-    Tag.create!(
-      tag_name: tn,
-      category: :general,
-      deprecated_at: Time.zone.local(2026, 6, 1)
-    )
-  end
 
   describe 'GET /wiki' do
     it 'returns wiki pages with title' do
@@ -37,8 +30,6 @@ RSpec.describe 'Wiki API', type: :request do
 
       expect(json[0]).to have_key('title')
       expect(json.map { |p| p['title'] }).to include('spec_wiki_title')
-      wiki_json = json.find { |item| item.fetch('id') == page.id }
-      expect(wiki_json.fetch('deprecated_at')).to eq(tag.deprecated_at.iso8601(3))
     end
   end
 
@@ -57,8 +48,7 @@ RSpec.describe 'Wiki API', type: :request do
 
         expect(json).to include(
             'id' => page.id,
-            'title' => 'spec_wiki_title',
+            'title' => 'spec_wiki_title')
-            'deprecated_at' => tag.deprecated_at.iso8601(3))
       end
     end
 
@@ -419,11 +409,7 @@ RSpec.describe 'Wiki API', type: :request do
         'kind' => 'content',
         'message' => 'r2'
       )
-      expect(top['wiki_page']).to include(
+      expect(top['wiki_page']).to include('id' => page.id, 'title' => 'spec_wiki_title')
-        'id' => page.id,
-        'title' => 'spec_wiki_title',
-        'deprecated_at' => tag.deprecated_at.iso8601(3)
-      )
       expect(top['user']).to include('id' => user.id, 'name' => user.name)
       expect(top).to have_key('timestamp')
 
@@ -493,7 +479,6 @@ RSpec.describe 'Wiki API', type: :request do
       expect(json).to include(
         'wiki_page_id' => page.id,
         'title' => 'spec_wiki_title',
-        'deprecated_at' => tag.deprecated_at.iso8601(3),
         'older_revision_id' => rev_a.id,
         'newer_revision_id' => rev_b.id
       )

backend/spec/tasks/post_similarity_calc_spec.rb

@@ -4,12 +4,11 @@ require 'rails_helper'
 RSpec.describe 'post_similarity:calc' do
   include RakeTaskHelper
 
-  it 'calculates similarities from active tags only' do
+  it 'calls Similarity::Calc with Post and :tags' do
     # 必要最低限のデータ
     t1 = Tag.create!(name: "t1")
     t2 = Tag.create!(name: "t2")
     t3 = Tag.create!(name: "t3")
-    deprecated_tag = Tag.create!(name: 'deprecated', deprecated_at: Time.current)
 
     p1 = Post.create!(url: "https://example.com/1")
     p2 = Post.create!(url: "https://example.com/2")
@@ -23,8 +22,6 @@ RSpec.describe 'post_similarity:calc' do
     PostTag.create!(post: p2, tag: t3)
 
     PostTag.create!(post: p3, tag: t3)
-    PostTag.create!(post: p1, tag: deprecated_tag)
-    PostTag.create!(post: p2, tag: deprecated_tag)
 
     expect { run_rake_task("post_similarity:calc") }
       .to change { PostSimilarity.count }.from(0)
@@ -32,6 +29,6 @@ RSpec.describe 'post_similarity:calc' do
     ps = PostSimilarity.find_by!(post_id: p1.id, target_post_id: p2.id)
     ps_rev = PostSimilarity.find_by!(post_id: p2.id, target_post_id: p1.id)
     expect(ps_rev.cos).to eq(ps.cos)
-    expect(ps.cos).to be_within(0.0001).of(0.5)
   end
 end
+

backend/spec/tasks/tag_similarity_calc_spec.rb

@@ -4,12 +4,11 @@ require 'rails_helper'
 RSpec.describe 'tag_similarity:calc' do
   include RakeTaskHelper
 
-  it 'calculates similarities for active tags only' do
+  it 'calls Similarity::Calc with Tag and :posts' do
     # 必要最低限のデータ
     t1 = Tag.create!(name: "t1")
     t2 = Tag.create!(name: "t2")
     t3 = Tag.create!(name: "t3")
-    deprecated_tag = Tag.create!(name: 'deprecated', deprecated_at: Time.current)
 
     p1 = Post.create!(url: "https://example.com/1")
     p2 = Post.create!(url: "https://example.com/2")
@@ -23,7 +22,6 @@ RSpec.describe 'tag_similarity:calc' do
     PostTag.create!(post: p2, tag: t3)
 
     PostTag.create!(post: p3, tag: t3)
-    PostTag.create!(post: p1, tag: deprecated_tag)
 
     expect { run_rake_task("tag_similarity:calc") }
       .to change { TagSimilarity.count }.from(0)
@@ -31,7 +29,6 @@ RSpec.describe 'tag_similarity:calc' do
     ps = TagSimilarity.find_by!(tag_id: t1.id, target_tag_id: t2.id)
     ps_rev = TagSimilarity.find_by!(tag_id: t2.id, target_tag_id: t1.id)
     expect(ps_rev.cos).to eq(ps.cos)
-    expect(TagSimilarity.where(tag_id: deprecated_tag.id)).to be_empty
-    expect(TagSimilarity.where(target_tag_id: deprecated_tag.id)).to be_empty
   end
 end
+

frontend/src/components/TagLink.test.tsx

@@ -18,21 +18,6 @@ describe ('TagLink', () => {
     expect (screen.getByText ('4')).toBeInTheDocument ()
   })
 
-  it ('does not append deprecated state to the rendered tag name', () => {
-    renderWithProviders (
-        <TagLink
-            tag={buildTag ({
-                name:         '旧タグ',
-                deprecatedAt: '2026-06-01T00:00:00.000Z',
-            })}
-            withWiki={false}
-            withCount={false}/>,
-    )
-
-    expect (screen.getByRole ('link', { name: '旧タグ' })).toBeInTheDocument ()
-    expect (screen.queryByText ('（廃止）')).not.toBeInTheDocument ()
-  })
-
   it ('links wiki markers to the correct detail route', () => {
     renderWithProviders (
         <TagLink tag={buildTag ({ hasWiki: true, name: 'a/b' })}/>,

frontend/src/components/TagLink.tsx

@@ -128,4 +128,4 @@ const TagLink: FC<Props> = ({ tag,
       </>)
 }
 
-export default TagLink
+export default TagLink

frontend/src/lib/gekanator.test.ts

@@ -1,12 +1,9 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { apiGet, apiPost } from '@/lib/api'
+import { apiPost } from '@/lib/api'
 import {
   buildGekanatorQuestions,
   expectedAnswerForQuestion,
-  fetchGekanatorPosts,
-  fetchGekanatorQuestions,
-  learnedSemanticSideForPost,
   questionIdForCondition,
   restoreGekanatorQuestion,
   saveGekanatorExtraQuestionAnswers,
@@ -26,7 +23,6 @@ vi.mock('@/lib/api', () => ({
 }))
 
 const mockedApiPost = vi.mocked(apiPost)
-const mockedApiGet = vi.mocked(apiGet)
 
 const post = (overrides: Partial<Post> = {}): Post => ({
   id: 1,
@@ -46,24 +42,6 @@ const post = (overrides: Partial<Post> = {}): Post => ({
   ...overrides,
 })
 
-describe('Gekanator API functions', () => {
-  it('returns posts from the Gekanator posts endpoint', async () => {
-    const posts = [post()]
-    mockedApiGet.mockResolvedValueOnce({ posts })
-
-    await expect(fetchGekanatorPosts()).resolves.toEqual(posts)
-    expect(mockedApiGet).toHaveBeenCalledWith('/gekanator/posts')
-  })
-
-  it('returns questions from the Gekanator questions endpoint', async () => {
-    const questions: StoredGekanatorQuestion[] = []
-    mockedApiGet.mockResolvedValueOnce({ questions })
-
-    await expect(fetchGekanatorQuestions()).resolves.toEqual(questions)
-    expect(mockedApiGet).toHaveBeenCalledWith('/gekanator/questions')
-  })
-})
-
 describe('expectedAnswerForQuestion', () => {
   it('returns a direct example answer when present', () => {
     const question: StoredGekanatorQuestion = {
@@ -147,7 +125,6 @@ describe('expectedAnswerForQuestion', () => {
               postCount: 1,
               createdAt: '2026-06-10T00:00:00.000Z',
               updatedAt: '2026-06-10T00:00:00.000Z',
-              deprecatedAt: null,
               hasWiki: false,
               hasDeerjikists: false,
               materialId: null,
@@ -211,33 +188,6 @@ describe('expectedAnswerForQuestion', () => {
   })
 })
 
-describe('learnedSemanticSideForPost', () => {
-  it('classifies post_similarity examples as positive, negative, or unknown', () => {
-    const question: StoredGekanatorQuestion = {
-      id: 'post-similarity:10',
-      text: '喜多ちゃんが泣いてる?',
-      kind: 'post_similarity',
-      source: 'user_suggested',
-      priorityWeight: 1.2,
-      condition: {
-        type: 'post-similarity',
-        postId: 123,
-        answer: 'partial',
-        threshold: 0.65,
-      },
-      exampleAnswers: {
-        1: 'yes',
-        2: 'probably_no',
-      },
-    }
-
-    expect(learnedSemanticSideForPost(question, post({ id: 1 }))).toBe('positive')
-    expect(learnedSemanticSideForPost(question, post({ id: 2 }))).toBe('negative')
-    expect(learnedSemanticSideForPost(question, post({ id: 3 }))).toBe('unknown')
-    expect(learnedSemanticSideForPost(question, post({ id: 123 }))).toBe('positive')
-  })
-})
-
 describe('restoreGekanatorQuestion', () => {
   it('uses default source and priority weight when omitted', () => {
     const question = restoreGekanatorQuestion({
@@ -298,7 +248,7 @@ describe('restoreGekanatorQuestion', () => {
     })
 
     expect(question.test(post({ id: 1 }))).toBe(true)
-    expect(question.test(post({ id: 2 }))).toBe(true)
+    expect(question.test(post({ id: 2 }))).toBe(false)
   })
 
   it('normalizes legacy title-length-greater-than questions', () => {
@@ -422,10 +372,6 @@ describe('Gekanator API writers', () => {
           type: 'tag',
           key: 'character:喜多郁代',
         },
-        questionMode: 'normal',
-        questionPurpose: 'effective_user_suggested',
-        effectiveQuestion: true,
-        learningQuestion: false,
         answer: 'yes',
         originalAnswer: 'partial',
       },
@@ -450,10 +396,6 @@ describe('Gekanator API writers', () => {
             type: 'tag',
             key: 'character:喜多郁代',
           },
-          question_mode: 'normal',
-          question_purpose: 'effective_user_suggested',
-          effective_question: true,
-          learning_question: false,
           answer: 'yes',
           original_answer: 'partial',
         },

frontend/src/lib/gekanator.ts

@@ -9,24 +9,11 @@ export type GekanatorAnswerValue =
     | 'probably_no'
     | 'unknown'
 
-export type LearnedSemanticSide =
-    | 'positive'
-    | 'negative'
-    | 'unknown'
-
-export type GekanatorQuestionPurpose =
-    | 'effective_user_suggested'
-    | 'learning_user_suggested'
-    | 'normal'
-
 export type GekanatorAnswerLog = {
     questionId:       string
     questionText:     string
     questionCondition?:  GekanatorQuestionCondition
     questionMode?:    'normal' | 'winning_run'
-    questionPurpose?: GekanatorQuestionPurpose
-    effectiveQuestion?: boolean
-    learningQuestion?: boolean
     answer:           GekanatorAnswerValue
     originalAnswer:   GekanatorAnswerValue }
 
@@ -176,26 +163,6 @@ const directExampleAnswerFor = (
   return null
 }
 
-
-export const isLearnedSemanticQuestion = (
-    question:  StoredGekanatorQuestion | GekanatorQuestion,
-): boolean =>
-    question.kind === 'post_similarity'
-    && question.source === 'user_suggested'
-
-
-export const learnedSemanticSideForAnswer = (
-    answer:  GekanatorAnswerValue | null,
-): LearnedSemanticSide => {
-  if (answer === 'yes' || answer === 'partial')
-    return 'positive'
-
-  if (answer === 'no' || answer === 'probably_no')
-    return 'negative'
-
-  return 'unknown'
-}
-
 const countBy = <T extends string | number> (values: T[]): Map<T, number> => {
   const counts = new Map<T, number> ()
   values.forEach (value => counts.set (value, (counts.get (value) ?? 0) + 1))
@@ -318,8 +285,8 @@ const questionMatches = (
 ): boolean => {
   const directAnswer = directExampleAnswerFor (question, post)
   if (directAnswer)
-    return question.kind === 'post_similarity'
+    return question.condition.type === 'post-similarity'
-	? learnedSemanticSideForAnswer (directAnswer) === 'positive'
+	? directAnswer === question.condition.answer
 	: directAnswer === 'yes'
 
   switch (question.condition.type)
@@ -361,11 +328,6 @@ export const expectedAnswerForQuestion = (
 
   switch (question.condition.type)
   {
-  case 'post-similarity':
-    if (question.condition.postId === post.id)
-      return question.condition.answer
-
-    return null
   case 'tag':
   case 'source':
   case 'original-year':
@@ -376,17 +338,12 @@ export const expectedAnswerForQuestion = (
   case 'title-has-ascii':
   case 'title-contains':
     return questionMatches (post, question) ? 'yes' : 'no'
+  case 'post-similarity':
+    return null
   }
 }
 
 
-export const learnedSemanticSideForPost = (
-    question:  StoredGekanatorQuestion | GekanatorQuestion | undefined,
-    post:      Post | null,
-): LearnedSemanticSide =>
-    learnedSemanticSideForAnswer (expectedAnswerForQuestion (question, post))
-
-
 export const restoreGekanatorQuestion = (
     question:  StoredGekanatorQuestion,
 ): GekanatorQuestion => {
@@ -466,15 +423,15 @@ export const buildGekanatorQuestions = (
   const originalYears = countBy (
       posts
       .map (originalYearOf)
-      .filter ((year): year is number => year != null))
+      .filter ((year): year is number => year !== null))
   const originalMonths = countBy (
       posts
       .map (originalMonthOf)
-      .filter ((month): month is number => month != null))
+      .filter ((month): month is number => month !== null))
   const originalMonthDays = countBy (
       posts
       .map (originalMonthDayOf)
-      .filter ((monthDay): monthDay is string => monthDay != null))
+      .filter ((monthDay): monthDay is string => monthDay !== null))
   const titleLengthMedian = median (posts.map (post => post.title?.length ?? 0))
   const titleWordCounts =
       includeTitleContains
@@ -636,10 +593,6 @@ export const saveGekanatorGame = async ({
 	    question_id: answer.questionId,
 	    question_text: answer.questionText,
 	    question_condition: answer.questionCondition ?? null,
-	    question_mode: answer.questionMode,
-	    question_purpose: answer.questionPurpose,
-	    effective_question: answer.effectiveQuestion,
-	    learning_question: answer.learningQuestion,
 	    answer: answer.answer,
 	    original_answer: answer.originalAnswer })) })
 

frontend/src/lib/gekanatorCandidateRecovery.test.ts

@@ -11,7 +11,6 @@ import type {
     GekanatorAnswerValue,
     GekanatorQuestion,
 } from '@/lib/gekanator'
-import type { RecoveredCandidateState } from '@/lib/gekanatorCandidateRecovery'
 import type { Post } from '@/types'
 
 
@@ -79,15 +78,6 @@ const answer = (
 })
 
 
-const recoveredState = (
-    answerCountAtRecovery:  number,
-    scoreAtRecovery = 0,
-): RecoveredCandidateState => ({
-  answerCountAtRecovery,
-  scoreAtRecovery,
-})
-
-
 describe('candidatePostsFor', () => {
   it('does not hard-filter semantic post_similarity answers', () => {
     const posts = [post (1), post (2), post (3)]
@@ -109,8 +99,8 @@ describe('candidatePostsFor', () => {
 	softenedQuestionIds: new Set (),
 	rejectedPostIds: new Set (),
 	recoveredCandidatePosts: new Map ([
-	    [1, recoveredState (1)],
+	    [1, 1],
-	    [3, recoveredState (1)],
+	    [3, 1],
 	]) })
 
     expect(candidates.map (candidate => candidate.id)).toEqual ([1, 2, 3])
@@ -132,8 +122,8 @@ describe('candidatePostsFor', () => {
 	softenedQuestionIds: new Set (),
 	rejectedPostIds: new Set (),
 	recoveredCandidatePosts: new Map ([
-	    [1, recoveredState (1)],
+	    [1, 1],
-	    [3, recoveredState (1)],
+	    [3, 1],
 	]) })
 
     expect(candidates.map (candidate => candidate.id)).toEqual ([3])
@@ -152,7 +142,7 @@ describe('candidatePostsFor', () => {
 	answers: [answer (question, 'yes')],
 	softenedQuestionIds: new Set (),
 	rejectedPostIds: new Set ([1]),
-	recoveredCandidatePosts: new Map ([[1, recoveredState (1)]]) })
+	recoveredCandidatePosts: new Map ([[1, 1]]) })
 
     expect(candidates.map (candidate => candidate.id)).toEqual ([2])
   })
@@ -219,7 +209,7 @@ describe('recoverCandidatePosts', () => {
 	posts,
 	scores,
 	rejectedPostIds: new Set ([10]),
-	recoveredCandidatePosts: new Map ([[8, recoveredState (1, 8)]]),
+	recoveredCandidatePosts: new Map ([[8, 1]]),
 	eligiblePostIds: new Set ([9]),
 	answerCountAtRecovery: 2,
 	recoveryStepCount: 0,
@@ -228,10 +218,7 @@ describe('recoverCandidatePosts', () => {
     expect(recovered?.recoveryStepCount).toBe (1)
     expect([...(recovered?.recoveredCandidatePosts.keys () ?? [])])
       .toEqual ([8, 7, 6, 5, 4])
-    expect(recovered?.recoveredCandidatePosts.get (7)).toEqual ({
+    expect(recovered?.recoveredCandidatePosts.get (7)).toBe (2)
-	answerCountAtRecovery: 2,
-	scoreAtRecovery: 7,
-    })
   })
 
   it('does not add posts when recovered and eligible candidates already hit the target', () => {
@@ -243,9 +230,9 @@ describe('recoverCandidatePosts', () => {
 	scores,
 	rejectedPostIds: new Set (),
 	recoveredCandidatePosts: new Map ([
-	    [1, recoveredState (1, 1)],
+	    [1, 1],
-	    [2, recoveredState (1, 2)],
+	    [2, 1],
-	    [3, recoveredState (1, 3)],
+	    [3, 1],
 	]),
 	eligiblePostIds: new Set ([4, 5, 6]),
 	answerCountAtRecovery: 2,

frontend/src/lib/gekanatorCandidateRecovery.ts

@@ -1,49 +1,53 @@
-import { isLearnedSemanticQuestion,
+import { expectedAnswerForQuestion } from '@/lib/gekanator'
-	 learnedSemanticSideForPost } from '@/lib/gekanator'
 
-import type { GekanatorAnswerLog, GekanatorAnswerValue, GekanatorQuestion } from '@/lib/gekanator'
+import type {
+    GekanatorAnswerLog,
+    GekanatorAnswerValue,
+    GekanatorQuestion,
+} from '@/lib/gekanator'
 import type { Post } from '@/types'
 
+
 export type RecoveredCandidatePost = {
     postId:                number
-    answerCountAtRecovery: number
+    answerCountAtRecovery: number }
-    scoreAtRecovery:       number }
-
-export type RecoveredCandidateState = {
-    answerCountAtRecovery: number
-    scoreAtRecovery:       number }
 
 
-const questionSupportsAnswerBasedHardFiltering = (question:  GekanatorQuestion): boolean =>
+const questionIsFactLikeForHardFiltering = (
-    !(isLearnedSemanticQuestion (question)
+    question:  GekanatorQuestion,
-      || (question.kind === 'tag'
+): boolean =>
+    !(question.kind === 'post_similarity'
+      || (
+	  question.kind === 'tag'
 	  && question.condition.type === 'tag'
 	  && !(question.condition.key.startsWith ('nico:'))))
 
 
-export const candidatePostsFor = (
+export const candidatePostsFor = ({
-    { posts,
+    posts,
-      questions,
+    questions,
-      answers,
+    answers,
-      softenedQuestionIds,
+    softenedQuestionIds,
-      rejectedPostIds,
+    rejectedPostIds,
-      recoveredCandidatePosts }: { posts:                   Post[]
+    recoveredCandidatePosts,
-				   questions:               GekanatorQuestion[]
+}: {
-				   answers:                 GekanatorAnswerLog[]
+    posts:                   Post[]
-				   softenedQuestionIds:     Set<string>
+    questions:               GekanatorQuestion[]
-				   rejectedPostIds:         Set<number>
+    answers:                 GekanatorAnswerLog[]
-				   recoveredCandidatePosts: Map<number, RecoveredCandidateState> },
+    softenedQuestionIds:     Set<string>
-): Post[] => {
+    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 recoveredCandidate = recoveredCandidatePosts.get (post.id)
+    const answerCountAtRecovery = recoveredCandidatePosts.get (post.id)
 
     return answers.every ((answer, index) => {
-      if (recoveredCandidate != null && index < recoveredCandidate.answerCountAtRecovery)
+      if (answerCountAtRecovery !== undefined && index < answerCountAtRecovery)
 	return true
 
       if (softenedQuestionIds.has (answer.questionId))
@@ -52,19 +56,16 @@ export const candidatePostsFor = (
       const question = questionById.get (answer.questionId)
       if (!(question))
 	return true
-      if (!(questionSupportsAnswerBasedHardFiltering (question)))
+      if (!(questionIsFactLikeForHardFiltering (question)))
 	return true
 
       switch (answer.answer)
       {
       case 'yes':
-      case 'no':
+      case 'no': {
-	{
+	const expected = expectedAnswerForQuestion (question, post)
-	  const expected = learnedSemanticSideForPost (question, post)
+	return expected === null || expected === 'unknown' || expected === answer.answer
-	  return expected === 'unknown'
+      }
-	      || (answer.answer === 'yes' && expected === 'positive')
-	      || (answer.answer === 'no' && expected === 'negative')
-	}
       default:
 	return true
       }
@@ -73,27 +74,33 @@ export const candidatePostsFor = (
 }
 
 
-export const hardFilteredPostsForAnswer = (
+export const hardFilteredPostsForAnswer = ({
-    { posts, question, answer }: { posts:     Post[]
+    posts,
-				   question:  GekanatorQuestion
+    question,
-				   answer:    GekanatorAnswerValue },
+    answer,
-): Post[] => {
+}: {
-  if (!(questionSupportsAnswerBasedHardFiltering (question)))
+    posts:     Post[]
+    question:  GekanatorQuestion
+    answer:    GekanatorAnswerValue
+}): Post[] => {
+  if (!(questionIsFactLikeForHardFiltering (question)))
     return posts
 
   if (!(answer === 'yes' || answer === 'no'))
     return posts
 
   return posts.filter (post => {
-    const side = learnedSemanticSideForPost (question, post)
+    const expected = expectedAnswerForQuestion (question, post)
-    return side === 'unknown'
+    return expected === null || expected === 'unknown' || expected === answer
-	|| (answer === 'yes' && side === 'positive')
-	|| (answer === 'no' && side === 'negative')
   })
 }
 
 
-const concreteAnswerOptions: GekanatorAnswerValue[] = ['yes', 'no', 'partial', 'probably_no']
+const concreteAnswerOptions: GekanatorAnswerValue[] = [
+    'yes',
+    'no',
+    'partial',
+    'probably_no']
 
 
 export const allConcreteAnswerOptionsExhausted = (
@@ -112,48 +119,53 @@ const nextRecoveryTargetSize = (recoveryStepCount: number): number =>
     6 * (2 ** recoveryStepCount)
 
 
-export const recoverCandidatePosts = (
+export const recoverCandidatePosts = ({
-    { posts,
+    posts,
-      scores,
+    scores,
-      rejectedPostIds,
+    rejectedPostIds,
-      recoveredCandidatePosts,
+    recoveredCandidatePosts,
-      eligiblePostIds,
+    eligiblePostIds,
-      answerCountAtRecovery,
+    answerCountAtRecovery,
-      recoveryStepCount }: { posts:                   Post[]
+    recoveryStepCount,
-			     scores:                  Map<number, number>
+}: {
-			     rejectedPostIds:         Set<number>
+    posts:                   Post[]
-			     recoveredCandidatePosts: Map<number, RecoveredCandidateState>
+    scores:                  Map<number, number>
-			     eligiblePostIds:         Set<number>
+    rejectedPostIds:         Set<number>
-			     answerCountAtRecovery:   number
+    recoveredCandidatePosts: Map<number, number>
-			     recoveryStepCount:       number },
+    eligiblePostIds:         Set<number>
-): { recoveredCandidatePosts: Map<number, RecoveredCandidateState>
+    answerCountAtRecovery:   number
-     recoveryStepCount:       number } | null => {
+    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 countedPostIds = new Set ([
+      ...eligiblePostIds,
+      ...recovered.keys ()])
   const addCount = targetSize - countedPostIds.size
   if (addCount <= 0)
-    {
+    return {
-      return { recoveredCandidatePosts: recovered,
+	recoveredCandidatePosts: recovered,
-	       recoveryStepCount: recoveryStepCount + 1 }
+	recoveryStepCount: recoveryStepCount + 1 }
-    }
 
-  const candidates =
+  const candidates = posts
-      posts
+      .filter (post =>
-      .filter (post => (!(rejectedPostIds.has (post.id))
+	  !(rejectedPostIds.has (post.id))
-			&& !(eligiblePostIds.has (post.id))
+	  && !(eligiblePostIds.has (post.id))
-			&& !(recovered.has (post.id))))
+	  && !(recovered.has (post.id)))
-      .sort ((a, b) => ((scores.get (b.id) ?? Number.NEGATIVE_INFINITY)
+      .sort ((a, b) =>
-			- (scores.get (a.id) ?? Number.NEGATIVE_INFINITY)))
+	  (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, {
+  candidates.forEach (post => recovered.set (post.id, answerCountAtRecovery))
-      answerCountAtRecovery,
-      scoreAtRecovery: scores.get (post.id) ?? 0 }))
 
-  return { recoveredCandidatePosts: recovered,
+  return {
-	   recoveryStepCount: recoveryStepCount + 1 }
+      recoveredCandidatePosts: recovered,
+      recoveryStepCount: recoveryStepCount + 1 }
 }

frontend/src/lib/prefetchers.ts

@@ -17,10 +17,6 @@ const mWiki = match<{ title: string }> ('/wiki/:title')
 const mTag = match<{ id: string }> ('/tags/:id')
 
 
-const boolFromQuery = (value: string | null): boolean =>
-    ['1', 'true', 'on', 'yes', ''].includes ((value ?? '').toLowerCase ())
-
-
 const prefetchWikiPagesIndex: Prefetcher = async (qc, url) => {
   const title = url.searchParams.get ('title') ?? ''
 
@@ -160,16 +156,13 @@ const prefetchTagsIndex: Prefetcher = async (qc, url) => {
   const createdTo = url.searchParams.get ('created_to') ?? ''
   const updatedFrom = url.searchParams.get ('updated_from') ?? ''
   const updatedTo = url.searchParams.get ('updated_to') ?? ''
-  const deprecated = url.searchParams.has ('deprecated')
-      ? boolFromQuery (url.searchParams.get ('deprecated'))
-      : null
   const page = Number (url.searchParams.get ('page') || 1)
   const limit = Number (url.searchParams.get ('limit') || 20)
   const order = (url.searchParams.get ('order') ?? 'post_count:desc') as FetchTagsOrder
 
   const keys = {
       post, name, category, postCountGTE, postCountLTE, createdFrom, createdTo,
-      updatedFrom, updatedTo, deprecated, page, limit, order }
+      updatedFrom, updatedTo, page, limit, order }
 
   await qc.prefetchQuery ({
       queryKey: tagsKeys.index (keys),

frontend/src/lib/tags.test.ts

@@ -20,7 +20,6 @@ const baseParams: FetchTagsParams = {
   createdTo:    '',
   updatedFrom:  '',
   updatedTo:    '',
-  deprecated:   null,
   page:         1,
   limit:        30,
   order:        'updated_at:desc',
@@ -58,20 +57,6 @@ describe ('tags API functions', () => {
     )
   })
 
-  it.each ([
-    [true, '1'],
-    [false, '0'],
-  ] as const) ('maps deprecated=%s to %s', async (deprecated, expected) => {
-    api.apiGet.mockResolvedValueOnce ({ tags: [], count: 0 })
-
-    await fetchTags ({ ...baseParams, deprecated })
-
-    expect (api.apiGet).toHaveBeenCalledWith (
-        '/tags',
-        { params: expect.objectContaining ({ deprecated: expected }) },
-    )
-  })
-
   it ('returns null when tag fetches fail', async () => {
     api.apiGet.mockRejectedValueOnce (new Error ('missing'))
     api.apiGet.mockRejectedValueOnce (new Error ('missing'))

frontend/src/lib/tags.ts

@@ -10,8 +10,7 @@ import type { Deerjikist,
 
 export const fetchTags = async (
     { post, name, category, postCountGTE, postCountLTE, createdFrom, createdTo,
-      updatedFrom, updatedTo, deprecated,
+      updatedFrom, updatedTo, page, limit, order }: FetchTagsParams,
-      page, limit, order }: FetchTagsParams,
 ): Promise<{ tags:  Tag[]
 	     count: number }> =>
     await apiGet ('/tags', { params: {
@@ -24,7 +23,6 @@ export const fetchTags = async (
 	...(createdTo && { created_to: createdTo }),
 	...(updatedFrom && { updated_from: updatedFrom }),
 	...(updatedTo && { updated_to: updatedTo }),
-	...(deprecated != null && { deprecated: deprecated ? '1' : '0' }),
 	...(page && { page }),
 	...(limit && { limit }),
 	...(order && { order }) } })
@@ -66,6 +64,7 @@ export const fetchTagByName = async (name: string): Promise<Tag | null> => {
   }
 }
 
+
 export const fetchTagChanges = async (
     { id, page, limit }: {
 	id?:    string

frontend/src/pages/GekanatorPage.test.tsx

@@ -60,14 +60,6 @@ const gekanatorBackdropSource = gekanatorPageSource.slice (
     gekanatorPageSource.indexOf ('const GekanatorBackdrop'),
     gekanatorPageSource.indexOf ('const expectedAnswerFor'))
 
-const gekanatorChooseQuestionSource = gekanatorPageSource.slice (
-    gekanatorPageSource.indexOf ('const chooseQuestion'),
-    gekanatorPageSource.indexOf ('const winningRunPriorityFor'))
-
-const gekanatorFallbackQuestionSource = gekanatorPageSource.slice (
-    gekanatorPageSource.indexOf ('const chooseFallbackQuestion'),
-    gekanatorPageSource.indexOf ('const shouldEnterGuessPhase'))
-
 
 describe('GekanatorBackdrop regression structure', () => {
   it('keeps displayedBackdropMode as the render-time source of truth', () => {
@@ -111,30 +103,6 @@ describe('GekanatorBackdrop regression structure', () => {
 })
 
 
-describe('Gekanator question selection regression structure', () => {
-  it('prefers normal questions after user_suggested quota has been met', () => {
-    const normalFallbackIndex = gekanatorChooseQuestionSource.indexOf (
-      'else if (normalPool.length > 0)')
-    const effectiveFallbackIndex = gekanatorChooseQuestionSource.indexOf (
-      'else if (effectiveUserSuggestedPool.length > 0)')
-
-    expect(normalFallbackIndex).toBeGreaterThan(0)
-    expect(effectiveFallbackIndex).toBeGreaterThan(0)
-    expect(normalFallbackIndex).toBeLessThan(effectiveFallbackIndex)
-  })
-
-  it('does not let fallback questions bypass user_suggested purpose tracking', () => {
-    expect(gekanatorFallbackQuestionSource).toContain (
-      "question.source !== 'user_suggested'")
-  })
-
-  it('does not show a fixed extra-question count in the extra learning UI', () => {
-    expect(gekanatorPageSource).not.toContain ('追加で 2 問まで答えてください。')
-    expect(gekanatorPageSource).toContain ('追加で質問に答えてください。')
-  })
-})
-
-
 describe('isQuestionHardFilteredAfterAnswers', () => {
   it('blocks only contradictory or redundant month questions after a yes answer', () => {
     const previous: GekanatorQuestionCondition = { type: 'original-month', month: 12 }

frontend/src/pages/tags/TagDetailPage.tsx

@@ -19,12 +19,7 @@ import type { FC, FormEvent } from 'react'
 
 import type { Category, Tag } from '@/types'
 
-type TagFormField =
+type TagFormField = 'name' | 'category' | 'aliases' | 'parentTags'
-    | 'name'
-    | 'category'
-    | 'aliases'
-    | 'parentTags'
-    | 'deprecated'
 
 
 const TagDetailPage: FC = () => {
@@ -40,7 +35,6 @@ const TagDetailPage: FC = () => {
   const [category, setCategory] = useState<Category> ('general')
   const [aliases, setAliases] = useState ('')
   const [parentTags, setParentTags] = useState ('')
-  const [deprecated, setDeprecated] = useState (false)
   const [disabled, setDisabled] = useState (true)
   const { baseErrors, fieldErrors, clearValidationErrors, applyValidationError } =
       useValidationErrors<TagFormField> ()
@@ -56,7 +50,6 @@ const TagDetailPage: FC = () => {
     formData.append ('category', category)
     formData.append ('aliases', aliases)
     formData.append ('parent_tags', parentTags)
-    formData.append ('deprecated', deprecated ? '1' : '0')
 
     try
     {
@@ -66,7 +59,6 @@ const TagDetailPage: FC = () => {
       setCategory (data.category as Category)
       setAliases (data.aliases.join (' '))
       setParentTags (data.parents.map (t => t.name).join (' '))
-      setDeprecated (Boolean (data.deprecatedAt))
 
       qc.invalidateQueries ({ queryKey: postsKeys.root })
       qc.invalidateQueries ({ queryKey: tagsKeys.root })
@@ -90,7 +82,6 @@ const TagDetailPage: FC = () => {
     setCategory (tag.category as Category)
     setAliases (tag.aliases.join (' '))
     setParentTags (tag.parents.map (t => t.name).join (' '))
-    setDeprecated (Boolean (tag.deprecatedAt))
     setDisabled (tag.category === 'nico')
   }, [tag])
 
@@ -174,17 +165,6 @@ const TagDetailPage: FC = () => {
 		      </>)}
 		</FormField>
 
-		<FormField label="廃止済" messages={fieldErrors.deprecated}>
-		  {({ describedBy, invalid }) => (
-		      <input
-			  type="checkbox"
-			  disabled={disabled}
-			  checked={deprecated}
-			  onChange={e => setDeprecated (e.target.checked)}
-			  aria-describedby={describedBy}
-			  aria-invalid={invalid}/>)}
-		</FormField>
-
 		<div className="py-3">
 		  <button
 		      type="submit"

frontend/src/pages/tags/TagHistoryPage.tsx

@@ -20,28 +20,17 @@ import type { FC } from 'react'
 
 const renderDiff = (diff: { current: string | null; prev: string | null }) => (
     <>
-      {diff.prev !== diff.current
+      {(diff.prev && diff.prev !== diff.current) && (
-       ? (
 	  <>
 	    <del className="text-red-600 dark:text-red-400">
-	      {diff.prev && <>{diff.prev}<br/></>}
+	      {diff.prev}
 	    </del>
-	    <ins className="text-green-600 dark:text-green-400">
+	    {diff.current && <br/>}
-	      {diff.current}
+	  </>)}
-	    </ins>
+      {diff.current}
-	  </>)
-       : diff.current}
     </>)
 
 
-const tagStateLabel = (deprecatedAt: string | null) => deprecatedAt ? '廃止' : ''
-
-
-const renderStateDiff = (diff: { current: string | null; prev: string | null }) =>
-    renderDiff ({ current: tagStateLabel (diff.current),
-		  prev: tagStateLabel (diff.prev) })
-
-
 const TagHistoryPage: FC = () => {
   const location = useLocation ()
   const query = new URLSearchParams (location.search)
@@ -83,8 +72,6 @@ const TagHistoryPage: FC = () => {
 		    <col className="w-96"/>
 		    {/* カテゴリ */}
 		    <col className="w-96"/>
-		    {/* 状態 */}
-		    <col className="w-32"/>
 		    {/* 別名 */}
 		    <col className="w-[48rem]"/>
 		    {/* 上位タグ */}
@@ -100,7 +87,6 @@ const TagHistoryPage: FC = () => {
 		      <th className="p-2 text-left">版</th>
 		      <th className="p-2 text-left">名称</th>
 		      <th className="p-2 text-left">カテゴリ</th>
-		      <th className="p-2 text-left">状態</th>
 		      <th className="p-2 text-left">別名</th>
 		      <th className="p-2 text-left">上位タグ</th>
 		      <th className="p-2 text-left">更新日時</th>
@@ -120,9 +106,6 @@ const TagHistoryPage: FC = () => {
 				prev: (change.category.prev
 				       && CATEGORY_NAMES[change.category.prev]) })}
 			  </td>
-			  <td className="p-2 break-all">
-			    {renderStateDiff (change.deprecatedAt)}
-			  </td>
 			  <td className="p-2">
 			    {change.aliases.map ((tag, i) => (
 				tag.type === 'added'
@@ -195,7 +178,6 @@ const TagHistoryPage: FC = () => {
 					`/tags/${ change.tagId }`,
 					{ name: change.name.current,
 					  category: change.category.current,
-					  deprecated: change.deprecatedAt.current ? '1' : '0',
 					  aliases:
 					      change.aliases
 					      .filter (t => t.type !== 'removed')
@@ -229,5 +211,4 @@ const TagHistoryPage: FC = () => {
       </MainArea>)
 }
 
-
+export default TagHistoryPage
-export default TagHistoryPage

frontend/src/pages/tags/TagListPage.test.tsx

@@ -14,22 +14,13 @@ vi.mock ('@/lib/tags', () => tagsApi)
 describe ('TagListPage', () => {
   it ('loads tags from URL filters and renders the results table', async () => {
     tagsApi.fetchTags.mockResolvedValueOnce ({
-      tags: [buildTag ({
+      tags: [buildTag ({ id: 7, name: '虹夏', category: 'character', postCount: 99 })],
-        id: 7,
-        name: '虹夏',
-        category: 'character',
-        postCount: 99,
-        deprecatedAt: '2026-06-01T00:00:00.000Z',
-      })],
       count: 1,
     })
 
     renderWithProviders (
         <TagListPage/>,
-        {
+        { route: '/tags?name=%E8%99%B9&category=character&page=3&post_count_gte=5' },
-          route:
-              '/tags?name=%E8%99%B9&category=character&page=3&post_count_gte=5&deprecated=1',
-        },
     )
 
     await waitFor (() => {
@@ -39,7 +30,6 @@ describe ('TagListPage', () => {
             category:     'character',
             page:         3,
             postCountGTE: 5,
-            deprecated:   true,
           }),
       )
     })
@@ -48,8 +38,6 @@ describe ('TagListPage', () => {
         '/tags/7',
     )
     expect (screen.getAllByText ('キャラクター').length).toBeGreaterThan (0)
-    expect (screen.getAllByRole ('combobox')[1]).toHaveValue ('1')
-    expect (screen.getAllByText ('廃止')).toHaveLength (2)
   })
 
   it ('navigates to a normalized search URL on submit', async () => {
@@ -58,9 +46,7 @@ describe ('TagListPage', () => {
     renderWithProviders (<TagListPage/>, { route: '/tags' })
 
     fireEvent.change (screen.getByRole ('textbox'), { target: { value: '虹夏' } })
-    fireEvent.change (screen.getAllByRole ('combobox')[0], {
+    fireEvent.change (screen.getByRole ('combobox'), { target: { value: 'character' } })
-      target: { value: 'character' },
-    })
     fireEvent.submit (screen.getByRole ('button', { name: '検索' }).closest ('form')!)
 
     await waitFor (() => {

frontend/src/pages/tags/TagListPage.tsx

@@ -29,13 +29,6 @@ const setIf = (qs: URLSearchParams, k: string, v: string | null) => {
 }
 
 
-const boolFromQuery = (value: string | null): boolean =>
-    ['1', 'true', 'on', 'yes', ''].includes ((value ?? '').toLowerCase ())
-
-
-const tagStateLabel = (deprecatedAt: string | null) => deprecatedAt ? '廃止' : ''
-
-
 const TagListPage: FC = () => {
   const location = useLocation ()
 
@@ -55,9 +48,6 @@ const TagListPage: FC = () => {
   const qCreatedTo = query.get ('created_to') ?? ''
   const qUpdatedFrom = query.get ('updated_from') ?? ''
   const qUpdatedTo = query.get ('updated_to') ?? ''
-  const qDeprecated = query.has ('deprecated')
-      ? boolFromQuery (query.get ('deprecated'))
-      : null
   const order = (query.get ('order') || 'post_count:desc') as FetchTagsOrder
 
   const [name, setName] = useState ('')
@@ -68,7 +58,6 @@ const TagListPage: FC = () => {
   const [createdTo, setCreatedTo] = useState<string | null> (null)
   const [updatedFrom, setUpdatedFrom] = useState<string | null> (null)
   const [updatedTo, setUpdatedTo] = useState<string | null> (null)
-  const [deprecated, setDeprecated] = useState<boolean | null> (null)
 
   const keys = {
       page, limit, order,
@@ -80,8 +69,7 @@ const TagListPage: FC = () => {
       createdFrom: qCreatedFrom,
       createdTo: qCreatedTo,
       updatedFrom: qUpdatedFrom,
-      updatedTo: qUpdatedTo,
+      updatedTo: qUpdatedTo }
-      deprecated: qDeprecated }
   const { data, isLoading: loading } = useQuery ({
       queryKey: tagsKeys.index (keys),
       queryFn: () => fetchTags (keys) })
@@ -97,11 +85,10 @@ const TagListPage: FC = () => {
     setCreatedTo (qCreatedTo)
     setUpdatedFrom (qUpdatedFrom)
     setUpdatedTo (qUpdatedTo)
-    setDeprecated (qDeprecated)
 
     document.querySelector ('table')?.scrollIntoView ({ behavior: 'smooth' })
   }, [location.search, qCategory, qCreatedFrom, qCreatedTo, qName, qPostCountGTE,
-      qPostCountLTE, qUpdatedFrom, qUpdatedTo, qDeprecated])
+      qPostCountLTE, qUpdatedFrom, qUpdatedTo])
 
   const handleSearch = (e: FormEvent) => {
     e.preventDefault ()
@@ -117,8 +104,6 @@ const TagListPage: FC = () => {
     setIf (qs, 'created_to', createdTo)
     setIf (qs, 'updated_from', updatedFrom)
     setIf (qs, 'updated_to', updatedTo)
-    if (deprecated != null)
-      qs.set ('deprecated', deprecated ? '1' : '0')
     qs.set ('page', '1')
     qs.set ('order', order)
 
@@ -216,21 +201,6 @@ const TagListPage: FC = () => {
 		  </>)}
 	    </FormField>
 
-	    <FormField label="状態">
-	      {({ invalid }) => (
-		  <select
-		      value={deprecated == null ? '' : (deprecated ? '1' : '0')}
-		      onChange={e => setDeprecated (
-			  e.target.value === ''
-			  ? null
-			  : e.target.value === '1')}
-		      className={inputClass (invalid)}>
-		    <option value="">&nbsp;</option>
-		    <option value="0">有効</option>
-		    <option value="1">廃止</option>
-		  </select>)}
-	    </FormField>
-
 	    <div className="py-3">
 	      <button
 		  type="submit"
@@ -249,7 +219,6 @@ const TagListPage: FC = () => {
 		    <col className="w-72"/>
 		    <col className="w-16"/>
 		    <col className="w-48"/>
-		    <col className="w-32"/>
 		    <col className="w-72"/>
 		    <col className="w-48"/>
 		    <col className="w-56"/>
@@ -280,7 +249,6 @@ const TagListPage: FC = () => {
 			    currentOrder={order}
 			    defaultDirection={defaultDirection}/>
 		      </th>
-		      <th className="p-2 text-left whitespace-nowrap">状態</th>
 		      <th className="p-2 text-left whitespace-nowrap">別名</th>
 		      <th className="p-2 text-left whitespace-nowrap">上位タグ</th>
 		      <th className="p-2 text-left whitespace-nowrap">
@@ -312,7 +280,6 @@ const TagListPage: FC = () => {
 			  </td>
 			  <td className="p-2 text-right">{row.postCount}</td>
 			  <td className="p-2">{CATEGORY_NAMES[row.category]}</td>
-			  <td className="p-2">{tagStateLabel (row.deprecatedAt)}</td>
 			  <td className="p-2">{row.aliases.join (' ')}</td>
 			  <td className="p-2">
 			    {row.parents.map (t => (

frontend/src/pages/wiki/WikiDetailPage.test.tsx

@@ -1,54 +0,0 @@
-import { screen } from '@testing-library/react'
-import { Route, Routes } from 'react-router-dom'
-import { describe, expect, it, vi } from 'vitest'
-
-import WikiDetailPage from '@/pages/wiki/WikiDetailPage'
-import { buildTag, buildWikiPage } from '@/test/factories'
-import { renderWithProviders } from '@/test/render'
-
-const wikiApi = vi.hoisted (() => ({
-  fetchWikiPage:        vi.fn (),
-  fetchWikiPageByTitle: vi.fn (),
-}))
-
-const tagsApi = vi.hoisted (() => ({
-  fetchTagByName: vi.fn (),
-}))
-
-const postsApi = vi.hoisted (() => ({
-  fetchPosts: vi.fn (),
-}))
-
-vi.mock ('@/lib/wiki', () => wikiApi)
-vi.mock ('@/lib/tags', () => tagsApi)
-vi.mock ('@/lib/posts', () => postsApi)
-
-describe ('WikiDetailPage', () => {
-  it ('renders deprecated state outside the wiki title link', async () => {
-    wikiApi.fetchWikiPageByTitle.mockResolvedValueOnce (buildWikiPage ({
-      title:        '旧タグ',
-      deprecatedAt: '2026-06-01T00:00:00.000Z',
-    }))
-    tagsApi.fetchTagByName.mockResolvedValueOnce (buildTag ({
-      name:         '旧タグ',
-      deprecatedAt: '2026-06-01T00:00:00.000Z',
-    }))
-    postsApi.fetchPosts.mockResolvedValueOnce ({ posts: [], count: 0 })
-
-    renderWithProviders (
-        <Routes>
-          <Route path="/wiki/:title" element={<WikiDetailPage/>}/>
-        </Routes>,
-        { route: '/wiki/%E6%97%A7%E3%82%BF%E3%82%B0' },
-    )
-
-    const marker = await screen.findByText ('（廃止）')
-    const heading = marker.closest ('h1')
-    const link = screen.getByRole ('link', { name: '旧タグ' })
-
-    expect (heading).not.toBeNull ()
-    expect (heading!).toHaveTextContent ('旧タグ（廃止）')
-    expect (link).toBeInTheDocument ()
-    expect (marker.closest ('a')).toBeNull ()
-  })
-})

frontend/src/pages/wiki/WikiDetailPage.tsx

@@ -39,7 +39,6 @@ const WikiDetailPage: FC = () => {
       queryFn:  () => fetchWikiPageByTitle (title, { version }) })
 
   const effectiveTitle = wikiPage?.title ?? title
-  const deprecated = wikiPage?.deprecatedAt != null
 
   const { data: tag } = useQuery ({
       enabled:  Boolean (effectiveTitle),
@@ -89,7 +88,7 @@ const WikiDetailPage: FC = () => {
   return (
       <MainArea>
 	<Helmet>
-	  <title>{`${ effectiveTitle }${ deprecated ? '（廃止）' : '' } Wiki | ${ SITE_TITLE }`}</title>
+	  <title>{`${ title } Wiki | ${ SITE_TITLE }`}</title>
 	  {!(wikiPage?.body) && <meta name="robots" content="noindex"/>}
 	</Helmet>
 
@@ -111,13 +110,10 @@ const WikiDetailPage: FC = () => {
 
 	<article className="prose dark:prose-invert mx-auto p-4">
 	  <h1 className="prose-a:no-underline">
-	    <TagLink tag={tag ?? { ...defaultTag,
+	    <TagLink tag={tag ?? defaultTag}
-				   name: effectiveTitle,
-				   deprecatedAt: wikiPage?.deprecatedAt ?? null }}
 		     withWiki={false}
 		     withCount={false}
 		     {...(version && { to: `/wiki/${ encodeURIComponent (title) }` })}/>
-	    {deprecated && <span>（廃止）</span>}
 	  </h1>
 	  {loading ? <div>Loading...</div> : <WikiBody title={title} body={wikiPage?.body}/>}
 

frontend/src/pages/wiki/WikiDiffPage.test.tsx

@@ -16,7 +16,6 @@ describe ('WikiDiffPage', () => {
     api.apiGet.mockResolvedValueOnce ({
       wikiPageId:      3,
       title:           '差分対象',
-      deprecatedAt:    null,
       olderRevisionId: 1,
       newerRevisionId: 2,
       diff: [
@@ -44,26 +43,4 @@ describe ('WikiDiffPage', () => {
     expect (screen.getByText ('added line')).toBeInTheDocument ()
     expect (screen.getByText ('removed line')).toBeInTheDocument ()
   })
-
-  it ('appends deprecated state to the wiki title', async () => {
-    api.apiGet.mockResolvedValueOnce ({
-      wikiPageId:      3,
-      title:           '廃止 Wiki',
-      deprecatedAt:    '2026-06-01T00:00:00.000Z',
-      olderRevisionId: 1,
-      newerRevisionId: 2,
-      diff:            [],
-    })
-
-    renderWithProviders (
-        <Routes>
-          <Route path="/wiki/:id/diff" element={<WikiDiffPage/>}/>
-        </Routes>,
-        { route: '/wiki/3/diff?from=1&to=2' },
-    )
-
-    expect (await screen.findByRole ('heading', {
-      name: '廃止 Wiki（廃止）',
-    })).toBeInTheDocument ()
-  })
 })

frontend/src/pages/wiki/WikiDiffPage.tsx

@@ -23,9 +23,6 @@ const WikiDiffPage: FC = () => {
   const query = new URLSearchParams (location.search)
   const from = query.get ('from')
   const to = query.get ('to')
-  const displayTitle = diff
-      ? `${ diff.title }${ diff.deprecatedAt != null ? '（廃止）' : '' }`
-      : ''
 
   useEffect (() => {
     void (async () => {
@@ -36,9 +33,9 @@ const WikiDiffPage: FC = () => {
   return (
       <MainArea>
 	<Helmet>
-	  <title>{`Wiki 差分: ${ displayTitle } | ${ SITE_TITLE }`}</title>
+	  <title>{`Wiki 差分: ${ diff?.title } | ${ SITE_TITLE }`}</title>
 	</Helmet>
-	<PageTitle>{displayTitle}</PageTitle>
+	<PageTitle>{diff?.title}</PageTitle>
 	<div className="prose mx-auto p-4">
 	  {diff
 	   ? (

frontend/src/pages/wiki/WikiHistoryPage.test.tsx

@@ -1,38 +0,0 @@
-import { screen } from '@testing-library/react'
-import { describe, expect, it, vi } from 'vitest'
-
-import WikiHistoryPage from '@/pages/wiki/WikiHistoryPage'
-import { renderWithProviders } from '@/test/render'
-
-const api = vi.hoisted (() => ({
-  apiGet: vi.fn (),
-}))
-
-vi.mock ('@/lib/api', () => api)
-
-describe ('WikiHistoryPage', () => {
-  it ('renders deprecated state outside the wiki title link', async () => {
-    api.apiGet.mockResolvedValueOnce ([{
-      revisionId:  2,
-      pred:        1,
-      succ:        null,
-      wikiPage:    {
-	id:           3,
-	title:        '旧タグ',
-	deprecatedAt: '2026-06-01T00:00:00.000Z',
-      },
-      user:        { id: 4, name: 'tester' },
-      kind:        'content',
-      message:     'updated',
-      timestamp:   '2026-06-02T00:00:00.000Z',
-    }])
-
-    renderWithProviders (<WikiHistoryPage/>)
-
-    const link = await screen.findByRole ('link', { name: '旧タグ' })
-    const marker = screen.getByText ('（廃止）')
-
-    expect (link).toHaveAttribute ('href', '/wiki/%E6%97%A7%E3%82%BF%E3%82%B0?version=2')
-    expect (marker.closest ('a')).toBeNull ()
-  })
-})

frontend/src/pages/wiki/WikiHistoryPage.tsx

@@ -59,7 +59,6 @@ const WikiHistoryPage: FC = () => {
 			to={`/wiki/${ encodeURIComponent (change.wikiPage.title) }?version=${ change.revisionId }`}>
 		      {change.wikiPage.title}
 		    </PrefetchLink>
-		    {change.wikiPage.deprecatedAt != null && <span>（廃止）</span>}
 		  </td>
 		  <td className="p-2">
 		    {change.pred == null ? '新規' : '更新'}

frontend/src/pages/wiki/WikiSearchPage.test.tsx

@@ -42,21 +42,4 @@ describe ('WikiSearchPage', () => {
     })
     expect (await screen.findByRole ('link', { name: '検索結果' })).toBeInTheDocument ()
   })
-
-  it ('marks deprecated wiki tags in the result title', async () => {
-    api.apiGet.mockResolvedValueOnce ([
-        buildWikiPage ({
-            title:        '旧タグ',
-            deprecatedAt: '2026-06-01T00:00:00.000Z',
-        }),
-    ])
-
-    renderWithProviders (<WikiSearchPage/>)
-
-    const link = await screen.findByRole ('link', { name: '旧タグ' })
-    const marker = screen.getByText ('（廃止）')
-
-    expect (link).toBeInTheDocument ()
-    expect (marker.closest ('a')).toBeNull ()
-  })
 })

frontend/src/pages/wiki/WikiSearchPage.tsx

@@ -86,7 +86,6 @@ const WikiSearchPage: FC = () => {
 		      <PrefetchLink to={`/wiki/${ encodeURIComponent (page.title) }`}>
 			{page.title}
 		      </PrefetchLink>
-		      {page.deprecatedAt != null && <span>（廃止）</span>}
 		    </td>
 		    <td className="p-2">
 		      {dateString (page.updatedAt)}

frontend/src/test/factories.ts

@@ -13,7 +13,6 @@ export const buildTag = (overrides: Partial<Tag> = {}): Tag => ({
   id:             1,
   name:           'テストタグ',
   category:       'general',
-  deprecatedAt:   null,
   aliases:        [],
   parents:        [],
   postCount:      12,
@@ -58,7 +57,6 @@ export const buildUser = (overrides: Partial<User> = {}): User => ({
 export const buildWikiPage = (overrides: Partial<WikiPage> = {}): WikiPage => ({
   id:            1,
   title:         'テストWiki',
-  deprecatedAt:  null,
   createdUserId: 1,
   updatedUserId: 1,
   createdAt:     '2026-01-02T03:04:05.000Z',

frontend/src/types.ts

@@ -39,19 +39,18 @@ export type FetchTagsOrderField =
     | 'updated_at'
 
 export type FetchTagsParams = {
-    post:           number | null
+    post:         number | null
-    name:           string
+    name:         string
-    category:       Category | null
+    category:     Category | null
-    postCountGTE:   number
+    postCountGTE: number
-    postCountLTE:   number | null
+    postCountLTE: number | null
-    createdFrom:    string
+    createdFrom:  string
-    createdTo:      string
+    createdTo:    string
-    updatedFrom:    string
+    updatedFrom:  string
-    updatedTo:      string
+    updatedTo:    string
-    deprecated:     boolean | null
+    page:         number
-    page:           number
+    limit:        number
-    limit:          number
+    order:        FetchTagsOrder }
-    order:          FetchTagsOrder }
 
 export type FetchNicoTagsParams = {
     name:       string
@@ -197,7 +196,6 @@ export type Tag = {
     id:             number
     name:           string
     category:       Category
-    deprecatedAt:   string | null
     aliases:        string[]
     parents:        Tag[]
     postCount:      number
@@ -215,7 +213,6 @@ export type TagVersion = {
     eventType:              'create' | 'update' | 'discard' | 'restore'
     name:                   { current: string; prev: string | null }
     category:               { current: Category; prev: Category | null }
-    deprecatedAt:           { current: string | null; prev: string | null }
     aliases:                { name: string; type: 'context' | 'added' | 'removed' }[]
     parentTags:             { tag: Tag; type: 'context' | 'added' | 'removed' }[]
     createdAt:              string
@@ -299,7 +296,6 @@ export type ViewFlagBehavior = typeof ViewFlagBehavior[keyof typeof ViewFlagBeha
 export type WikiPage = {
     id:             number
     title:          string
-    deprecatedAt:   string | null
     createdUserId:  number
     updatedUserId:  number
     createdAt:      string
@@ -313,7 +309,7 @@ export type WikiPageChange = {
     revisionId: number
     pred:       number | null
     succ:       null
-    wikiPage:   Pick<WikiPage, 'id' | 'title' | 'deprecatedAt'>
+    wikiPage:   Pick<WikiPage, 'id' | 'title'>
     user:       Pick<User, 'id' | 'name'>
     kind:       'content' | 'redirect'
     message:    string | null
@@ -322,7 +318,6 @@ export type WikiPageChange = {
 export type WikiPageDiff = {
     wikiPageId:       number
     title:            string
-    deprecatedAt:     string | null
     olderRevisionId:  number | null
     newerRevisionId:  number
     diff:             WikiPageDiffDiff[] }

frontend/tsconfig.app.json

@@ -27,6 +27,5 @@
       "@/*": ["*"]
     }
   },
-  "include": ["src"],
+  "include": ["src"]
-  "exclude": ["src/**/*.test.ts", "src/**/*.test.tsx", "src/test"]
 }