collavre 0.23.0 → 0.24.0

data/app/javascript/modules/creative_row_editor_helpers.js

@@ -0,0 +1,76 @@
+// Pure, closure-independent helpers extracted from creative_row_editor.js.
+//
+// Every function here depends only on its arguments (and the module-local
+// layout constants below) — none captures editor closure state. Keeping them in
+// a separate module shrinks the main editor module and makes these units
+// individually testable. Behavior is identical to the original inline versions.
+
+const BULLET_STARTING_LEVEL = 3;
+const HEADING_INDENT_STEP_EM = 0.4;
+const BULLET_INDENT_STEP_PX = 30;
+
+export function treeRowElement(node) {
+  return node && node.closest ? node.closest('creative-tree-row') : null;
+}
+
+export function hasDatasetValue(element, key) {
+  if (!element || !element.dataset) return false;
+  return Object.prototype.hasOwnProperty.call(element.dataset, key);
+}
+
+export function setRowDatasetValue(row, key, value) {
+  if (!row || !row.dataset) return;
+  if (value === undefined || value === null) {
+    delete row.dataset[key];
+  } else {
+    row.dataset[key] = String(value);
+  }
+}
+
+export function isMarkdownEmpty(md) {
+  return !md || md.trim().length === 0;
+}
+
+export function buildChildrenLoadUrl(parentId, childLevel, selectMode) {
+  const params = new URLSearchParams();
+  params.set('level', String(childLevel));
+  params.set('select_mode', selectMode ? '1' : '0');
+  return `/creatives/${parentId}/children?${params.toString()}`;
+}
+
+export function readRowLevel(row) {
+  if (!row) return null;
+  if (row.isTitle) return 0;
+  if (row.getAttribute) {
+    const levelAttr = row.getAttribute('level');
+    if (levelAttr) {
+      const parsed = Number(levelAttr);
+      if (!Number.isNaN(parsed)) return parsed;
+    }
+  }
+  if (typeof row.level === 'number') {
+    return row.level;
+  }
+  if (row.level) {
+    const parsed = Number(row.level);
+    if (!Number.isNaN(parsed)) return parsed;
+  }
+  const tree = row.querySelector ? row.querySelector('.creative-tree') : null;
+  if (tree && tree.dataset?.level) {
+    const parsed = Number(tree.dataset.level);
+    if (!Number.isNaN(parsed)) return parsed;
+  }
+  return 1;
+}
+
+export function editorPaddingForLevel(level) {
+  if (typeof level !== 'number' || Number.isNaN(level) || level <= 1) {
+    return '0px';
+  }
+  if (level <= BULLET_STARTING_LEVEL) {
+    const emValue = (level - 1) * HEADING_INDENT_STEP_EM;
+    return emValue ? `${emValue}em` : '0px';
+  }
+  const pxValue = (level - BULLET_STARTING_LEVEL) * BULLET_INDENT_STEP_PX;
+  return `${pxValue}px`;
+}

data/app/javascript/modules/creative_save_queue.js

@@ -0,0 +1,95 @@
+// The autosave request lifecycle extracted from creative_row_editor.js.
+//
+// The inline editor persists edits on a debounce and also saves directly on
+// structural changes (reorder, indent, progress toggle). Two invariants kept
+// getting re-broken across dozens of fix commits ("Prevent double saves...",
+// "Skip in-flight request during queue deduplication"):
+//
+//   1. Debounce: rapid edits collapse into a single trailing save; re-arming
+//      the timer must cancel the previous one.
+//   2. Single-flight: at most one save request is in flight at a time. A save
+//      requested while one is running must NOT start a second request — it
+//      returns the in-flight promise. (Dirty-tracking in the editor re-arms and
+//      a later schedule/flush persists the newer buffer.)
+//
+// This class owns exactly those two concerns — the debounce timer and the
+// single-flight guard around the request promise. It deliberately does NOT own
+// the editor's dirty flags (isDirty / pendingSave), which track *what* changed;
+// this owns *when the request runs*. Behavior is identical to the original
+// inline `saveTimer` / `saving` / `savePromise` logic; the timer functions are
+// injectable so the state machine is testable without real timers.
+export class CreativeSaveQueue {
+  constructor({ debounceMs = 5000, setTimer, clearTimer } = {}) {
+    this._debounceMs = debounceMs;
+    // Wrap the timer functions so they are invoked as free functions. Passing
+    // `setTimeout`/`clearTimeout` directly and calling them as `this._setTimer(...)`
+    // would invoke them with `this === queue`, which throws "Illegal invocation"
+    // in real browsers (jsdom does not, which is why unit tests can't catch it).
+    // Tests inject their own timer fns; production uses these window-bound wrappers.
+    this._setTimer = setTimer || ((fn, ms) => setTimeout(fn, ms));
+    this._clearTimer = clearTimer || ((id) => clearTimeout(id));
+    this._timer = null;
+    this._saving = false;
+    this._promise = Promise.resolve();
+  }
+
+  /** True while a save request is in flight. */
+  get saving() {
+    return this._saving;
+  }
+
+  /** The most recent (possibly in-flight) save promise. */
+  get promise() {
+    return this._promise;
+  }
+
+  /**
+   * Arm the debounce timer to invoke `flush` after `debounceMs`. Re-arming
+   * cancels any previously scheduled flush, so only the latest edit's timer
+   * fires (trailing debounce).
+   * @param {() => void} flush
+   */
+  schedule(flush) {
+    this.cancelTimer();
+    this._timer = this._setTimer(() => {
+      this._timer = null;
+      flush();
+    }, this._debounceMs);
+  }
+
+  /** Cancel a pending debounce timer, if any. Idempotent. */
+  cancelTimer() {
+    if (this._timer !== null) {
+      this._clearTimer(this._timer);
+      this._timer = null;
+    }
+  }
+
+  /**
+   * Run `execute` under the single-flight guard.
+   *
+   * - If a save is already in flight, returns the in-flight promise WITHOUT
+   *   invoking `execute` (the coalescing invariant).
+   * - Otherwise cancels any pending debounce, then invokes `execute`. `execute`
+   *   returns the save request promise, or a nullish value to signal "nothing
+   *   to persist" (e.g. empty content) — in which case no in-flight state is
+   *   entered and a resolved promise is returned. Invoking `execute` before
+   *   committing `saving` preserves the original ordering, where an empty-save
+   *   short-circuit never flips the in-flight flag.
+   *
+   * `saving` is cleared when the returned promise settles (success or failure).
+   * @param {() => (Promise|null|undefined)} execute
+   * @returns {Promise}
+   */
+  runExclusive(execute) {
+    if (this._saving) return this._promise;
+    this.cancelTimer();
+    const request = execute();
+    if (request == null) return Promise.resolve();
+    this._saving = true;
+    this._promise = Promise.resolve(request).finally(() => {
+      this._saving = false;
+    });
+    return this._promise;
+  }
+}

data/app/javascript/modules/creative_tree_dom.js

@@ -0,0 +1,260 @@
+// Tree-DOM navigation & geometry helpers extracted from creative_row_editor.js.
+//
+// This is slice 2 of the creative_row_editor god-file decomposition (slice 1 was
+// the save-queue single-flight/debounce cluster, already in creative_save_queue.js).
+//
+// Every function here operates purely on the DOM nodes passed as arguments (plus
+// `document` for id/selector lookups) — none captures the editor closure's shared
+// state (currentTree, form, parentInput, isDirty, pendingSave, uploadsPending, …).
+// That is exactly why this cluster is a clean seam: it can be lifted out and unit
+// tested against a jsdom fixture without standing up the whole inline editor.
+//
+// The cluster underpins the structural-move paths (levelUp / levelDown / addNew /
+// move) that compute a node's parent, its before/after siblings, and its indent
+// level — the inputs to the recurring "parentId loss / wrong ordering" bug class.
+// Pinning them with characterization tests raises the floor under those moves.
+//
+// NOTE ON BINDING HAZARDS: none of these functions use setTimeout / setInterval /
+// requestAnimationFrame / queueMicrotask, and none rely on `this`. They are plain
+// functions invoked by name, so the "Illegal invocation" class of real-browser
+// regression (a prior timer-extraction bug that jsdom could not catch) does not
+// apply here. The only DOM writes are element mutations (insertBefore, appendChild,
+// setAttribute, dataset, style, requestUpdate) invoked on the passed nodes.
+import { treeRowElement, readRowLevel, buildChildrenLoadUrl } from './creative_row_editor_helpers';
+
+export function creativeTreeElement(node) {
+  if (!node) return null;
+  if (node.classList && node.classList.contains('creative-tree')) return node;
+  if (node.querySelector) {
+    const inner = node.querySelector('.creative-tree');
+    if (inner) return inner;
+  }
+  return null;
+}
+
+export function creativeIdFrom(node) {
+  const treeEl = creativeTreeElement(node);
+  if (treeEl && treeEl.dataset) {
+    return treeEl.dataset.id || '';
+  }
+  if (node?.getAttribute) {
+    return node.getAttribute('creative-id') || node.getAttribute('data-id') || '';
+  }
+  return '';
+}
+
+export function siblingTreeRow(row, direction) {
+  if (!row) return null;
+  const step = direction === 'previous' ? 'previousSibling' : 'nextSibling';
+  let node = row[step];
+  while (node) {
+    if (node.nodeType === Node.TEXT_NODE) {
+      node = node[step];
+      continue;
+    }
+    if (node.matches?.('creative-tree-row')) return node;
+    if (node.classList?.contains?.('creative-children')) {
+      node = node[step];
+      continue;
+    }
+    node = node[step];
+  }
+  return null;
+}
+
+export function siblingOrderingForRow(row) {
+  const beforeRow = siblingTreeRow(row, 'next');
+  const afterRow = siblingTreeRow(row, 'previous');
+  return {
+    beforeId: beforeRow ? creativeIdFrom(beforeRow) : '',
+    afterId: afterRow ? creativeIdFrom(afterRow) : ''
+  };
+}
+
+export function treeContainerElement(tree) {
+  if (!tree) return null;
+  const row = treeRowElement(tree);
+  if (row && row.parentNode) return row.parentNode;
+  return tree.parentNode;
+}
+
+export function nodeAfterTreeBlock(tree) {
+  if (!tree) return null;
+  const row = treeRowElement(tree);
+  if (!row) return tree.nextSibling;
+  let node = row.nextSibling;
+  while (node && node.nodeType === Node.TEXT_NODE) node = node.nextSibling;
+  const treeId = tree.dataset?.id;
+  if (treeId) {
+    const childrenContainer = document.getElementById(`creative-children-${treeId}`);
+    if (childrenContainer && childrenContainer.parentNode === row.parentNode && node === childrenContainer) {
+      node = childrenContainer.nextSibling;
+      while (node && node.nodeType === Node.TEXT_NODE) node = node.nextSibling;
+    }
+  }
+  return node;
+}
+
+export function normalizeRowNode(node) {
+  if (!node) return null;
+  if (node.matches && node.matches('creative-tree-row')) return node;
+  if (node.classList && node.classList.contains('creative-tree')) {
+    const row = treeRowElement(node);
+    return row || node;
+  }
+  return node;
+}
+
+export function childrenContainerForTree(tree) {
+  if (!tree) return null;
+  const treeId = tree.dataset?.id;
+  if (treeId) {
+    const byId = document.getElementById(`creative-children-${treeId}`);
+    if (byId) return byId;
+  }
+  if (tree.children && tree.children.length > 0) {
+    for (const child of tree.children) {
+      if (child && child.classList && child.classList.contains('creative-children')) {
+        return child;
+      }
+    }
+  }
+  const row = treeRowElement(tree);
+  if (row) {
+    let sibling = row.nextElementSibling;
+    while (sibling) {
+      if (sibling.matches?.('creative-tree-row')) break;
+      if (sibling.classList?.contains('creative-children')) return sibling;
+      sibling = sibling.nextElementSibling;
+    }
+  }
+  return null;
+}
+
+export function ensureChildrenContainer(tree) {
+  if (!tree) return null;
+  let container = childrenContainerForTree(tree);
+  if (container) return container;
+  const parentId = tree.dataset?.id;
+  if (!parentId) return null;
+  container = document.createElement('div');
+  container.className = 'creative-children';
+  container.id = `creative-children-${parentId}`;
+  const parentRow = treeRowElement(tree);
+  const parentLevel = readRowLevel(parentRow) || 1;
+  const childLevel = parentLevel + 1;
+  const selectModeActive = parentRow?.hasAttribute?.('select-mode') ? 1 : 0;
+  container.dataset.loadUrl = buildChildrenLoadUrl(parentId, childLevel, selectModeActive);
+  container.dataset.expanded = 'true';
+  if (container.dataset.loaded) delete container.dataset.loaded;
+  const row = treeRowElement(tree);
+  const parentContainer = row?.parentNode || tree.parentNode;
+  if (parentContainer) {
+    const afterRow = row?.nextSibling;
+    if (afterRow) {
+      parentContainer.insertBefore(container, afterRow);
+    } else {
+      parentContainer.appendChild(container);
+    }
+  } else {
+    tree.appendChild(container);
+  }
+  return container;
+}
+
+export function expandChildrenContainer(container) {
+  if (!container) return;
+  container.style.display = '';
+  if (container.dataset) {
+    container.dataset.expanded = 'true';
+  }
+}
+
+export function moveTreeBlock(tree, targetContainer, referenceNode = null) {
+  if (!tree || !targetContainer) return;
+  const row = treeRowElement(tree);
+  if (!row) return;
+  const nodesToMove = [row];
+  const childContainer = childrenContainerForTree(tree);
+  if (childContainer) nodesToMove.push(childContainer);
+  nodesToMove.forEach((node) => {
+    if (!node) return;
+    if (referenceNode) {
+      targetContainer.insertBefore(node, referenceNode);
+    } else {
+      targetContainer.appendChild(node);
+    }
+  });
+}
+
+export function listAllTreeNodes() {
+  const root = document.getElementById('creatives');
+  if (root) return Array.from(root.querySelectorAll('.creative-tree'));
+  return Array.from(document.querySelectorAll('.creative-tree'));
+}
+
+export function findPreviousTree(tree) {
+  if (!tree) return null;
+  const nodes = listAllTreeNodes();
+  const index = nodes.indexOf(tree);
+  if (index <= 0) return null;
+  const currentLevel = getTreeLevel(tree);
+  for (let i = index - 1; i >= 0; i--) {
+    const candidate = nodes[i];
+    if (!candidate) continue;
+    const candidateLevel = getTreeLevel(candidate);
+    if (candidateLevel === currentLevel) return candidate;
+    if (candidateLevel < currentLevel) return null;
+  }
+  return null;
+}
+
+export function getTreeLevel(tree) {
+  if (!tree) return 1;
+  const levelValue = Number(tree.dataset?.level);
+  if (!Number.isNaN(levelValue) && levelValue > 0) {
+    return levelValue;
+  }
+  const row = treeRowElement(tree);
+  return readRowLevel(row) || 1;
+}
+
+export function updateTreeLevels(tree, delta) {
+  if (!tree || !delta) return;
+  const currentLevel = Number(tree.dataset?.level) || 1;
+  const nextLevel = Math.max(1, currentLevel + delta);
+  tree.dataset.level = String(nextLevel);
+  const row = treeRowElement(tree);
+  if (row) {
+    row.setAttribute('level', nextLevel);
+    row.level = nextLevel;
+    row.requestUpdate?.();
+  }
+  const container = childrenContainerForTree(tree);
+  if (!container) return;
+  Array.from(container.children || []).forEach((childRow) => {
+    if (!childRow.matches?.('creative-tree-row')) return;
+    const childTree = childRow.querySelector('.creative-tree');
+    if (childTree) {
+      updateTreeLevels(childTree, delta);
+    }
+  });
+}
+
+export function setTreeLevel(tree, targetLevel) {
+  if (!tree || typeof targetLevel !== 'number') return;
+  const currentLevel = Number(tree.dataset?.level) || 1;
+  const delta = targetLevel - currentLevel;
+  if (delta === 0) return;
+  updateTreeLevels(tree, delta);
+}
+
+export function removeTreeElement(tree) {
+  if (!tree) return;
+  const row = treeRowElement(tree);
+  if (row) {
+    row.remove();
+  } else if (tree.remove) {
+    tree.remove();
+  }
+}

data/app/jobs/collavre/permission_cache_job.rb

@@ -19,7 +19,7 @@ class PermissionCacheJob < ApplicationJob
     when :rebuild_for_creative
       rebuild_for_creative(args[:creative_id])
     when :propagate_share
-      propagate_share(args[:creative_share_id])
+      propagate_share(args[:creative_share_id], purge_stale: args.fetch(:purge_stale, false))
     when :remove_share
       remove_share(args[:creative_share_id], args[:creative_id], args[:user_id])
     when :rebuild_user_cache_for_subtree
@@ -49,7 +49,18 @@ class PermissionCacheJob < ApplicationJob
     Creatives::PermissionCacheBuilder.rebuild_for_creative(creative)
   end
 
-  def propagate_share(creative_share_id)
+  def propagate_share(creative_share_id, purge_stale: false)
+    # A relocated/reassigned share leaves stale cache rows keyed to it at the old
+    # location. When asked, delete them here — in this same job, immediately
+    # before re-propagating — never as a separate job. Both the purge and the
+    # propagate key on source_share_id, and the authz queue runs two threads, so
+    # a standalone purge could execute AFTER propagate and delete the rows it
+    # just wrote, leaving the share with no cache until an unrelated rebuild.
+    # Folding the purge in guarantees purge-before-propagate ordering while
+    # keeping the work off the commit path (the async, prolonged-grant window the
+    # CTO accepted is preserved). Purge runs before the find_by so it still fires
+    # even if the share was destroyed after enqueue.
+    purge_share_cache(creative_share_id) if purge_stale
     share = CreativeShare.find_by(id: creative_share_id)
     return unless share
     Creatives::PermissionCacheBuilder.propagate_share(share)
@@ -62,6 +73,13 @@ class PermissionCacheJob < ApplicationJob
     Creatives::PermissionCacheBuilder.rebuild_from_ancestors_for_user(creative, user_id)
   end
 
+  # Purge the stale cache rows a relocated/reassigned share left behind. Only
+  # ever called from propagate_share (never enqueued standalone) so the delete
+  # cannot race the re-propagation on a separate authz-queue thread.
+  def purge_share_cache(creative_share_id)
+    CreativeSharesCache.where(source_share_id: creative_share_id).delete_all
+  end
+
   def rebuild_user_cache_for_subtree(creative_id, user_id)
     creative = Creative.find_by(id: creative_id)
     return unless creative

data/app/jobs/collavre/trigger_loop_check_job.rb

@@ -86,17 +86,34 @@ module Collavre
     # These are NOT valid task results — the agent never actually worked.
     MAX_INFRA_RETRIES = 3
 
-    INFRASTRUCTURE_ERROR_PATTERNS = [
-      /OpenClaw Error/i,
+    # Generic, vendor-neutral infrastructure-error signatures. Vendor engines
+    # register their own provider-specific signatures (e.g. an OpenClaw gateway
+    # error banner) via register_infrastructure_error_pattern, so core names no
+    # vendor here.
+    BUILTIN_INFRASTRUCTURE_ERROR_PATTERNS = [
       /(?:request|connection|server)\s+timed?\s*out/i,
       /connection\s*(refused|reset|closed)/i,
       /internal\s*server\s*error/i,
       /\b50[234]\b.*(?:error|gateway|unavailable)/i
     ].freeze
 
+    class << self
+      def registered_infrastructure_error_patterns
+        @registered_infrastructure_error_patterns ||= []
+      end
+
+      def register_infrastructure_error_pattern(pattern)
+        registered_infrastructure_error_patterns << pattern unless registered_infrastructure_error_patterns.include?(pattern)
+      end
+
+      def infrastructure_error_patterns
+        BUILTIN_INFRASTRUCTURE_ERROR_PATTERNS + registered_infrastructure_error_patterns
+      end
+    end
+
     def infrastructure_error?(comment)
       content = comment.content.to_s
-      INFRASTRUCTURE_ERROR_PATTERNS.any? { |pattern| content.match?(pattern) }
+      self.class.infrastructure_error_patterns.any? { |pattern| content.match?(pattern) }
     end
 
     # Retry without consuming an iteration — the agent never actually worked.

data/app/jobs/collavre/update_mcp_tools_job.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Collavre
+  # Re-derives a creative's MCP tool definitions from its description HTML.
+  # Runs off the request/save path (enqueued from Creative after_commit) so the
+  # Nokogiri parsing and tool upserts never block a synchronous save.
+  class UpdateMcpToolsJob < ApplicationJob
+    queue_as :default
+
+    def perform(creative_id)
+      creative = Creative.find_by(id: creative_id)
+      return unless creative
+
+      McpService.new.update_from_creative(creative)
+    end
+  end
+end

data/app/models/collavre/channel.rb

@@ -5,6 +5,22 @@ module Collavre
 
     self.table_name = "channels"
 
+    include Collavre::IndexedJsonColumns
+
+    # Denormalized columns that mirror same-named keys in `config`. They exist
+    # so the channels UNIQUE indexes are plain-column indexes (which dump
+    # identically to schema.rb on SQLite and PostgreSQL) instead of JSON
+    # expression indexes (json_extract vs config->>), which serialize
+    # per-adapter and crash `db:schema:load` on PostgreSQL. `config` stays the
+    # source of truth; these columns are re-derived on every save. Declared
+    # here beside the table whose unique indexes are defined in this engine's
+    # migration, so subtype engines need not know about the denormalization.
+    indexed_json_columns json: :config, columns: {
+      repo_full_name: "repo_full_name",
+      pr_number: "pr_number",
+      worktree_id: "worktree_id"
+    }
+
     belongs_to :topic, class_name: "Collavre::Topic"
 
     enum :state, { active: 0, detached: 1 }, default: :active

data/app/models/collavre/comment/approvable.rb

@@ -3,6 +3,22 @@ module Collavre
     module Approvable
       extend ActiveSupport::Concern
 
+      # A message that renders an approval button (pending) or an
+      # approved/denied status label (decided) in the chat list — i.e. it
+      # carries an `action` JSON payload. Both the `has_pending_action`
+      # button (action.present? && action_executed_at.blank?) and the
+      # ✅ approved / 🚫 denied label (action_executed_at.present?, which implies
+      # action.present?) roll up to this single condition.
+      #
+      # Such a message is a HUMAN decision surface and must never be dispatched
+      # to an AI agent — regardless of who authored it or whether it has already
+      # been decided. This is the single source of truth for that invariant,
+      # enforced at every dispatch seam (Comment#dispatch_to_orchestration and
+      # AiAgent::A2aDispatcher#dispatch).
+      def approval_action?
+        action.present?
+      end
+
       def can_be_approved_by?(user)
         approval_status(user) == :ok
       end

data/app/models/collavre/comment/notifiable.rb

@@ -172,7 +172,7 @@ module Collavre
       end
 
       def notify_approver
-        return unless approver.present? && action.present?
+        return unless approver.present? && approval_action?
         return if approver == user
         return if creative&.inbox? # Don't notify about inbox comments
 

data/app/models/collavre/comment.rb

@@ -51,7 +51,7 @@ module Collavre
         end
     end
 
-    belongs_to :creative, class_name: "Collavre::Creative"
+    belongs_to :creative, class_name: "Collavre::Creative", counter_cache: true
     belongs_to :user, class_name: Collavre.configuration.user_class_name, optional: true
     belongs_to :approver, class_name: Collavre.configuration.user_class_name, optional: true
     belongs_to :action_executed_by, class_name: Collavre.configuration.user_class_name, optional: true
@@ -61,6 +61,11 @@ module Collavre
 
     scope :public_only, -> { where(private: false) }
 
+    # SQL inverse of Comment#approval_action? (action.present?). Approval-surface
+    # messages must never reach an AI agent — not only at the dispatch seams but
+    # also as chat-history/trigger context — so agent-context queries exclude them.
+    scope :without_approval_action, -> { where("action IS NULL OR action = ''") }
+
     scope :visible_to, ->(user) {
       where(
         "comments.private = ? OR comments.user_id = ? OR comments.approver_id = ?",
@@ -213,6 +218,7 @@ module Collavre
       return if private?
       return if skip_default_user  # system notices should not trigger AI
       return if skip_dispatch      # explicit opt-out (e.g., command processor responses)
+      return if approval_action?   # approval button / approved message: human decision surface, never dispatch to an agent
       return unless user_id        # nil user = system message
       return if user&.ai_user?     # AI replies use A2aDispatcher, not this callback
       return unless creative
@@ -273,6 +279,7 @@ module Collavre
     def resume_trigger_loop_if_awaiting
       return unless user_id                # must have a user (not system)
       return if user&.ai_user?             # must be a human, not an AI agent
+      return if approval_action?           # approval surface is not a user-resume signal; the resumed @agent turn would otherwise carry it into history
       return unless creative
 
       # Use pessimistic lock to prevent duplicate resume from concurrent comments

data/app/models/collavre/comment_version.rb

@@ -4,7 +4,7 @@ module Collavre
   class CommentVersion < ApplicationRecord
     self.table_name = "comment_versions"
 
-    belongs_to :comment, class_name: "Collavre::Comment"
+    belongs_to :comment, class_name: "Collavre::Comment", counter_cache: true
     belongs_to :review_comment, class_name: "Collavre::Comment", optional: true
 
     validates :content, presence: true