collavre 0.20.2 → 0.21.0

data/app/javascript/modules/command_args_form.js

@@ -20,13 +20,16 @@ export default class CommandArgsForm {
    * @param {Element}  opts.container - if set, the modal is scoped inside this element
    *                                    (overlay covers only the container, content is blurred)
    * @param {Function} opts.creativeIdFn - returns current creative ID for mention search
+   * @param {Function} opts.contextValuesFn - returns { creative_id, topic_id } used to
+   *                                          pre-fill params whose name matches
    */
-  constructor({ onSubmit, onCancel, labels, container, creativeIdFn } = {}) {
+  constructor({ onSubmit, onCancel, labels, container, creativeIdFn, contextValuesFn } = {}) {
     this.onSubmit = onSubmit || (() => {})
     this.onCancel = onCancel || (() => {})
     this.labels = labels || { submit: 'OK', cancel: 'Cancel' }
     this.container = container || null
     this._creativeIdFn = creativeIdFn || (() => null)
+    this._contextValuesFn = contextValuesFn || (() => ({}))
     this.command = null
     this.overlay = null
     this.dialog = null
@@ -173,6 +176,18 @@ export default class CommandArgsForm {
     host.appendChild(this.dialog)
   }
 
+  _contextDefaultFor(paramName) {
+    if (paramName !== 'creative_id' && paramName !== 'topic_id') return null
+    let ctx
+    try {
+      ctx = this._contextValuesFn() || {}
+    } catch (_e) {
+      return null
+    }
+    const value = ctx[paramName]
+    return value == null || value === '' ? null : value
+  }
+
   _buildField(param, index) {
     const wrapper = document.createElement('div')
     wrapper.className = 'modal-dialog-field'
@@ -241,9 +256,12 @@ export default class CommandArgsForm {
     input.dataset.paramRequired = param.required ? 'true' : 'false'
     if (param.description) input.placeholder = param.description
 
-    // Pre-fill with default value from creative tool defaults
-    if (param.default_value != null) {
-      input.value = String(param.default_value)
+    // Pre-fill priority: explicit default_value (from creative tool config) wins,
+    // otherwise auto-fill creative_id / topic_id from the current chat context.
+    const contextFill = this._contextDefaultFor(param.name)
+    const prefill = param.default_value != null ? param.default_value : contextFill
+    if (prefill != null && prefill !== '') {
+      input.value = String(prefill)
       if (input.tagName === 'TEXTAREA') {
         requestAnimationFrame(() => this._autoResize(input))
       }

data/app/javascript/modules/command_menu.js

@@ -19,6 +19,14 @@ if (!commandMenuInitialized) {
     const argsForm = new CommandArgsForm({
       container: popup,
       creativeIdFn: () => popup.dataset.creativeId,
+      contextValuesFn: () => ({
+        // Prefer the effective origin id (what comments/topics controllers
+        // operate on). For linked creatives, popup.dataset.creativeId is the
+        // wrapper row id, but the server resolves through effective_origin —
+        // MCP tools expect the same effective id.
+        creative_id: popup.dataset.effectiveCreativeId || popup.dataset.creativeId || null,
+        topic_id: currentTopicIdFromController(popup) || null
+      }),
       labels: {
         submit: menu.dataset.formSubmit || 'OK',
         cancel: menu.dataset.formCancel || 'Cancel'
@@ -79,6 +87,25 @@ if (!commandMenuInitialized) {
       }
     })
 
+    function currentTopicIdFromController(popupEl) {
+      // Prefer the form controller's locally-cached topic id — the same value
+      // used when submitting a comment. It is set from the
+      // `comments--topics:change` event, so it reflects the user's actual
+      // selection after restoreSelection rather than a stale URL deep-link.
+      const formCtrl = window.Stimulus?.getControllerForElementAndIdentifier(popupEl, 'comments--form')
+      if (formCtrl) {
+        const id = formCtrl.currentTopicId || formCtrl._mainTopicId
+        if (id) return String(id)
+      }
+      // Topics may not have loaded yet (form hasn't received any change event).
+      // Fall back to mainTopicId only — never topicsCtrl.currentTopicId, whose
+      // getter prioritizes window.location.search?topic_id= even when that
+      // topic does not belong to the current creative.
+      const topicsCtrl = window.Stimulus?.getControllerForElementAndIdentifier(popupEl, 'comments--topics')
+      if (!topicsCtrl) return ''
+      return topicsCtrl.mainTopicId ? String(topicsCtrl.mainTopicId) : ''
+    }
+
     function clearCommandText() {
       const pos = textarea.selectionStart
       const after = textarea.value.slice(pos)

data/app/javascript/modules/creative_row_editor.js

@@ -4,6 +4,9 @@ import { $getCharacterOffsets, $getSelection, $isRangeSelection, $isTextNode, $i
 import { createInlineEditor } from './lexical_inline_editor'
 import { renderCreativeTree, dispatchCreativeTreeUpdated } from '../creatives/tree_renderer'
 import { isProgressComplete, progressBaselineValueFrom, progressValueChangedFrom } from './creative_progress'
+import { renderMarkdown } from '../lib/utils/markdown'
+import { reconcileMarkdownSource } from './markdown_source_reconcile'
+import { isHtmlEmpty } from './html_content_empty'
 import yaml from 'js-yaml'
 // Import Stimulus application from the global window (set by host app)
 const application = window.Stimulus
@@ -107,6 +110,16 @@ export function initializeCreativeRowEditor() {
     const metadataSaveBtn = document.getElementById('metadata-save-btn');
     const metadataCloseBtn = document.getElementById('metadata-popup-close');
 
+    // Markdown editor elements
+    const contentTypeInput = document.getElementById('inline-content-type');
+    const markdownSourceInput = document.getElementById('inline-markdown-source');
+    const markdownWrapper = document.getElementById('markdown-editor-wrapper');
+    const markdownTextarea = document.getElementById('markdown-editor-textarea');
+    const markdownPreview = document.getElementById('markdown-preview');
+    const toggleMarkdownBtn = document.getElementById('inline-toggle-markdown');
+    let markdownMode = false;
+    let markdownPreviewTimer = null;
+
     let lexicalEditor = null;
     if (editorContainer) {
       try {
@@ -239,6 +252,12 @@ export function initializeCreativeRowEditor() {
       if (Object.prototype.hasOwnProperty.call(data, 'origin_id')) {
         setRowDatasetValue(row, 'originId', data.origin_id ?? '');
       }
+      if (Object.prototype.hasOwnProperty.call(data, 'content_type')) {
+        setRowDatasetValue(row, 'contentType', data.content_type ?? '');
+      }
+      if (Object.prototype.hasOwnProperty.call(data, 'markdown_source')) {
+        setRowDatasetValue(row, 'markdownSource', data.markdown_source ?? '');
+      }
       if (Object.prototype.hasOwnProperty.call(data, 'has_children')) {
         if (data.has_children) {
           row.setAttribute('has-children', '');
@@ -277,16 +296,47 @@ export function initializeCreativeRowEditor() {
         description_raw_html: rawHtml,
         origin_id: row.dataset?.originId || '',
         parent_id: parentId,
-        progress: Number.isNaN(progressValue) ? 0 : progressValue
+        progress: Number.isNaN(progressValue) ? 0 : progressValue,
+        content_type: row.dataset?.contentType || null,
+        markdown_source: row.dataset?.markdownSource || null
       };
     }
 
-    function isHtmlEmpty(html) {
-      if (!html) return true;
-      const temp = document.createElement('div');
-      temp.innerHTML = html;
-      if (temp.querySelector('img')) return false;
-      return (temp.textContent || '').trim().length === 0;
+    function isMarkdownEmpty(md) {
+      return !md || md.trim().length === 0;
+    }
+
+    function activateMarkdownMode(source) {
+      markdownMode = true;
+      if (contentTypeInput) contentTypeInput.value = 'markdown';
+      if (markdownTextarea) markdownTextarea.value = source || '';
+      if (markdownWrapper) markdownWrapper.style.display = '';
+      if (editorContainer) editorContainer.style.display = 'none';
+      if (markdownPreview) markdownPreview.innerHTML = source ? renderMarkdown(source) : '';
+      if (toggleMarkdownBtn) {
+        toggleMarkdownBtn.textContent = toggleMarkdownBtn.dataset.labelRichtext || 'Rich Text';
+        toggleMarkdownBtn.classList.add('active');
+      }
+      if (markdownTextarea) markdownTextarea.focus();
+    }
+
+    function deactivateMarkdownMode() {
+      markdownMode = false;
+      if (contentTypeInput) contentTypeInput.value = 'html';
+      if (markdownSourceInput) markdownSourceInput.value = '';
+      if (markdownWrapper) markdownWrapper.style.display = 'none';
+      if (editorContainer) editorContainer.style.display = '';
+      if (toggleMarkdownBtn) {
+        toggleMarkdownBtn.textContent = toggleMarkdownBtn.dataset.labelMarkdown || 'MD';
+        toggleMarkdownBtn.classList.remove('active');
+      }
+    }
+
+    function syncMarkdownToForm() {
+      if (!markdownMode) return;
+      const md = markdownTextarea ? markdownTextarea.value : '';
+      if (markdownSourceInput) markdownSourceInput.value = md;
+      if (descriptionInput) descriptionInput.value = renderMarkdown(md);
     }
 
     function applyCreativeData(data, tree) {
@@ -298,10 +348,21 @@ export function initializeCreativeRowEditor() {
       form.dataset.creativeId = creativeId;
       const content = data.description_raw_html || data.description || '';
       descriptionInput.value = content;
-      lexicalEditor.load(content, `creative-${creativeId}-${Date.now()}`);
+
+      // Handle markdown vs rich text mode
+      const isMarkdown = data.content_type === 'markdown';
+      if (isMarkdown) {
+        activateMarkdownMode(data.markdown_source || '');
+        // Also load Lexical with HTML for fallback/switching
+        lexicalEditor.load(content, `creative-${creativeId}-${Date.now()}`);
+      } else {
+        deactivateMarkdownMode();
+        lexicalEditor.load(content, `creative-${creativeId}-${Date.now()}`);
+      }
+
       pendingSave = false;
       // Track original content for dirty state detection
-      originalContent = content;
+      originalContent = isMarkdown ? (data.markdown_source || '') : content;
       isDirty = false;
       const progressNumber = Number(data.progress ?? 0);
       const normalizedProgress = Number.isNaN(progressNumber) ? 0 : progressNumber;
@@ -323,7 +384,9 @@ export function initializeCreativeRowEditor() {
       const effectiveParent = parentInput.value;
       if (unconvertBtn) unconvertBtn.style.display = effectiveParent ? '' : 'none';
       originalProgress = normalizedProgress;
-      lexicalEditor.focus();
+      if (!isMarkdown) {
+        lexicalEditor.focus();
+      }
       updateActionButtonStates();
       // Reload metadata if the popup is open
       if (isMetadataPopupVisible()) {
@@ -973,7 +1036,13 @@ export function initializeCreativeRowEditor() {
         if (saving) return savePromise;
         clearTimeout(saveTimer);
 
-        if (isHtmlEmpty(descriptionInput.value)) {
+        // Sync markdown form fields before saving
+        if (markdownMode) syncMarkdownToForm();
+
+        const isEmpty = markdownMode
+          ? isMarkdownEmpty(markdownTextarea?.value)
+          : isHtmlEmpty(descriptionInput.value);
+        if (isEmpty) {
           pendingSave = false;
           return Promise.resolve();
         }
@@ -984,7 +1053,9 @@ export function initializeCreativeRowEditor() {
         saving = true;
 
         // Capture values being saved to update dirty state on success
-        const savedContent = descriptionInput.value;
+        // NOTE: `let` (not `const`) — when the server rewrites markdown_source
+        // (e.g. data: URI → blob path) we reassign below.
+        let savedContent = markdownMode ? (markdownTextarea?.value || '') : descriptionInput.value;
         const shouldPersistProgress = progressValueChanged();
         const savedProgress = shouldPersistProgress ? readProgressValue() : progressBaselineValueFrom(originalProgress);
         const savedOriginId = originIdInput ? originIdInput.value : '';
@@ -1002,6 +1073,25 @@ export function initializeCreativeRowEditor() {
           return r.text().then(function (text) {
             try { return text ? JSON.parse(text) : {}; } catch (e) { return {}; }
           }).then(function (data) {
+            // Sync rewritten markdown source back into the textarea/hidden input.
+            // Server rewrites inline data: URIs in markdown_source to blob paths so
+            // re-saves don't re-import the same image. If the user typed during the
+            // request, merge the substitutions into the live textarea so the next
+            // save still carries blob paths instead of re-importing the data URI.
+            if (markdownMode && data && typeof data.markdown_source === 'string'
+                && data.markdown_source !== savedContent && markdownTextarea) {
+              const reconciled = reconcileMarkdownSource(
+                savedContent, data.markdown_source, markdownTextarea.value
+              );
+              if (reconciled !== null && reconciled !== markdownTextarea.value) {
+                markdownTextarea.value = reconciled;
+                syncMarkdownToForm();
+              }
+              if (reconciled !== null) {
+                savedContent = data.markdown_source;
+              }
+            }
+
             // Update dirty state to reflect successful save
             originalContent = savedContent;
             if (shouldPersistProgress) {
@@ -1010,7 +1100,8 @@ export function initializeCreativeRowEditor() {
             originalOriginId = savedOriginId;
 
             // If current values match what was just saved, clear dirty flag
-            if (descriptionInput.value === savedContent &&
+            const currentContent = markdownMode ? (markdownTextarea?.value || '') : descriptionInput.value;
+            if (currentContent === savedContent &&
               readProgressValue() === savedProgress &&
               originIdInput.value === savedOriginId) {
               isDirty = false;
@@ -1197,6 +1288,8 @@ export function initializeCreativeRowEditor() {
 
       // CRITICAL: Capture ALL values BEFORE awaiting, because the editor may switch
       // to a different creative while we're waiting for uploads
+      const isMarkdownSave = markdownMode;
+      if (isMarkdownSave) syncMarkdownToForm();
       let currentContent = descriptionInput.value;
       let currentProgress = readProgressValue();
       let shouldPersistProgress = progressValueChanged();
@@ -1204,10 +1297,15 @@ export function initializeCreativeRowEditor() {
       const currentBeforeId = tree.previousElementSibling ? creativeIdFrom(tree.previousElementSibling) : '';
       const currentAfterId = tree.nextElementSibling ? creativeIdFrom(tree.nextElementSibling) : '';
       const startCreativeId = creativeId;
+      let capturedMarkdownSource = isMarkdownSave ? (markdownTextarea?.value || '') : '';
+      const capturedContentType = isMarkdownSave ? 'markdown' : 'html';
 
       // Prevent saving empty content, matching saveForm behavior
       // This avoids overwriting existing descriptions with empty strings during quick navigation
-      if (isHtmlEmpty(currentContent)) {
+      const isEmpty = isMarkdownSave
+        ? isMarkdownEmpty(capturedMarkdownSource)
+        : isHtmlEmpty(currentContent);
+      if (isEmpty) {
         pendingSave = false;
         return;
       }
@@ -1217,8 +1315,15 @@ export function initializeCreativeRowEditor() {
       await waitForUploads();
 
       // If we are still on the same creative (e.g. move awaited us), refresh the content
-      // This ensures we capture the final HTML with signed IDs instead of blob URLs
+      // This ensures we capture the final HTML with signed IDs instead of blob URLs.
+      // Markdown saves regenerate description from creative[markdown_source] server-side,
+      // so we must re-sync and re-capture the latest textarea value too — otherwise edits
+      // made during the upload wait get overwritten by the stale pre-wait source.
       if (form.dataset.creativeId === startCreativeId) {
+        if (isMarkdownSave) {
+          syncMarkdownToForm();
+          capturedMarkdownSource = markdownTextarea?.value || '';
+        }
         currentContent = descriptionInput.value;
         currentProgress = readProgressValue();
         shouldPersistProgress = progressValueChanged();
@@ -1228,8 +1333,12 @@ export function initializeCreativeRowEditor() {
       // Note: before_id and after_id must be top-level params, not nested under creative[]
       // because CreativesController reads params[:before_id] and params[:after_id] for positioning
       const body = {
-        'creative[description]': currentContent
+        'creative[description]': currentContent,
+        'creative[content_type_input]': capturedContentType
       };
+      if (isMarkdownSave) {
+        body['creative[markdown_source]'] = capturedMarkdownSource;
+      }
 
       if (shouldPersistProgress) {
         body['creative[progress]'] = currentProgress;
@@ -1257,6 +1366,8 @@ export function initializeCreativeRowEditor() {
           if (shouldPersistProgress) {
             row.dataset.progressValue = String(currentProgress);
           }
+          row.dataset.contentType = capturedContentType;
+          row.dataset.markdownSource = isMarkdownSave ? capturedMarkdownSource : '';
           if (currentParentId) {
             tree.dataset.parentId = currentParentId;
             row.parentId = currentParentId;
@@ -1279,12 +1390,49 @@ export function initializeCreativeRowEditor() {
 
       // Queue the save request
       // Store deletedAttachmentIds as data, not as callback, so it can be serialized
+      // Capture per-enqueue values for the onSuccess closure so concurrent edits
+      // on a different creative don't get clobbered when the response comes back.
+      const onSuccessCreativeId = startCreativeId;
+      const onSuccessSavedMarkdown = isMarkdownSave ? capturedMarkdownSource : null;
+      const onSuccessTree = tree;
       apiQueue.enqueue({
         path: `/creatives/${creativeId}`,
         method: 'PATCH',
         body: body,
         dedupeKey: `creative_${creativeId}`,
-        deletedAttachmentIds: deletedAttachmentIds  // Store as data for serialization
+        deletedAttachmentIds: deletedAttachmentIds,  // Store as data for serialization
+        onSuccess: function (data) {
+          if (!isMarkdownSave || !data || typeof data.markdown_source !== 'string') return;
+          if (data.markdown_source === onSuccessSavedMarkdown) return;
+
+          // Update the row dataset cache regardless of which creative is active now,
+          // so a later loadCreative() for this row picks up the rewritten source.
+          if (onSuccessTree) {
+            const row = treeRowElement(onSuccessTree);
+            if (row && row.dataset.markdownSource === onSuccessSavedMarkdown) {
+              row.dataset.markdownSource = data.markdown_source;
+              row.requestUpdate?.();
+            }
+          }
+
+          // Merge the data: URI -> blob path substitutions into the live textarea,
+          // even if the user typed during the queued save. We still require the
+          // same creative to be open (race-safe across editor switches).
+          if (form.dataset.creativeId === onSuccessCreativeId
+              && markdownMode
+              && markdownTextarea) {
+            const reconciled = reconcileMarkdownSource(
+              onSuccessSavedMarkdown, data.markdown_source, markdownTextarea.value
+            );
+            if (reconciled !== null && reconciled !== markdownTextarea.value) {
+              markdownTextarea.value = reconciled;
+              syncMarkdownToForm();
+            }
+            if (reconciled !== null) {
+              originalContent = data.markdown_source;
+            }
+          }
+        }
       });
       // console.warn('apiQueue.enqueue disabled for debugging');
 
@@ -1739,6 +1887,7 @@ export function initializeCreativeRowEditor() {
           afterInput.value = afterId || '';
           if (childInput) childInput.value = childId || '';
           resetOriginTracking();
+          deactivateMarkdownMode();
           descriptionInput.value = '';
           lexicalEditor.reset(`new-${Date.now()}`);
           setProgressState(0);
@@ -1781,12 +1930,25 @@ export function initializeCreativeRowEditor() {
     }
 
     function onLexicalChange(html) {
+      if (markdownMode) return; // Ignore Lexical changes in markdown mode
       descriptionInput.value = html;
       // Mark as dirty if content changed from original
       isDirty = (html !== originalContent);
       scheduleSave();
     }
 
+    function onMarkdownTextareaInput() {
+      const md = markdownTextarea.value;
+      syncMarkdownToForm();
+      isDirty = (md !== originalContent);
+      scheduleSave();
+      // Debounced live preview
+      clearTimeout(markdownPreviewTimer);
+      markdownPreviewTimer = setTimeout(() => {
+        if (markdownPreview) markdownPreview.innerHTML = renderMarkdown(md);
+      }, 300);
+    }
+
     // Intercepts Shift+Enter via capture-phase keydown on Lexical's root element.
     // Returning true triggers preventDefault + stopImmediatePropagation.
     // Shift+Enter → addNew (save & add next)
@@ -2174,5 +2336,53 @@ export function initializeCreativeRowEditor() {
         });
       }
     }
+
+    // Markdown toggle button
+    if (toggleMarkdownBtn) {
+      toggleMarkdownBtn.addEventListener('click', function () {
+        if (markdownMode) {
+          // Switching from Markdown → Rich Text
+          const confirmMsg = toggleMarkdownBtn.dataset.confirmToRichtext;
+          if (confirmMsg && !confirm(confirmMsg)) return;
+          const md = markdownTextarea?.value || '';
+          const html = md ? renderMarkdown(md) : '';
+          deactivateMarkdownMode();
+          descriptionInput.value = html;
+          lexicalEditor.load(html, `creative-switch-${Date.now()}`);
+          lexicalEditor.focus();
+          isDirty = true;
+          scheduleSave();
+        } else {
+          // Switching from Rich Text → Markdown
+          const currentHtml = descriptionInput.value || '';
+          if (!isHtmlEmpty(currentHtml)) {
+            const confirmMsg = toggleMarkdownBtn.dataset.confirmToMarkdown;
+            if (confirmMsg && !confirm(confirmMsg)) return;
+          }
+          activateMarkdownMode('');
+          isDirty = true;
+          scheduleSave();
+        }
+      });
+    }
+
+    // Markdown textarea input handler
+    if (markdownTextarea) {
+      markdownTextarea.addEventListener('input', onMarkdownTextareaInput);
+
+      // Support keyboard shortcuts in markdown textarea
+      markdownTextarea.addEventListener('keydown', function (event) {
+        if (event.key === 'Escape') {
+          event.preventDefault();
+          hideCurrent();
+          return;
+        }
+        // Shift+Enter → add new sibling (same as Lexical)
+        if (event.key === 'Enter' && event.shiftKey) {
+          event.preventDefault();
+          addNew();
+        }
+      });
+    }
   });
 }

data/app/javascript/modules/html_content_empty.js

@@ -0,0 +1,12 @@
+// True when an HTML fragment has no user-visible content. Treats inline
+// images and attachments (action-text-attachment / figure.attachment /
+// data-trix-attachment) as content so image-only or attachment-only bodies
+// don't get discarded silently when switching editor modes.
+export function isHtmlEmpty(html, doc = typeof document !== 'undefined' ? document : null) {
+  if (!html) return true;
+  if (!doc) return html.replace(/<[^>]*>/g, '').trim().length === 0;
+  const temp = doc.createElement('div');
+  temp.innerHTML = html;
+  if (temp.querySelector('img, action-text-attachment, figure.attachment, [data-trix-attachment]')) return false;
+  return (temp.textContent || '').trim().length === 0;
+}

data/app/javascript/modules/markdown_source_reconcile.js

@@ -0,0 +1,53 @@
+// Reconcile a server-rewritten markdown source with the current textarea value
+// when the user typed during the save. The server's rewrite is a pure
+// data: URI -> blob path substitution on what we sent (`savedContent`).
+// If every data: URI we sent is still present in `currentValue`, apply the
+// same substitutions there and return the merged value; otherwise return null.
+export function reconcileMarkdownSource(savedContent, rewritten, currentValue) {
+  if (typeof savedContent !== 'string' || typeof rewritten !== 'string'
+      || typeof currentValue !== 'string') return null;
+  if (rewritten === savedContent) return null;
+  if (currentValue === savedContent) return rewritten;
+
+  const dataUriRegex = /data:image\/[^\s)>"'`\]]+/g;
+  const matches = [];
+  let m;
+  while ((m = dataUriRegex.exec(savedContent)) !== null) {
+    matches.push({ uri: m[0], start: m.index, end: m.index + m[0].length });
+  }
+  if (matches.length === 0) return null;
+
+  const pairs = [];
+  let savedPos = 0;
+  let rewrittenPos = 0;
+  for (let i = 0; i < matches.length; i++) {
+    const match = matches[i];
+    const textLen = match.start - savedPos;
+    if (rewritten.slice(rewrittenPos, rewrittenPos + textLen)
+        !== savedContent.slice(savedPos, match.start)) return null;
+    rewrittenPos += textLen;
+    savedPos = match.end;
+
+    const nextStart = (i + 1 < matches.length) ? matches[i + 1].start : savedContent.length;
+    const tail = savedContent.slice(savedPos, nextStart);
+    let blobEnd;
+    if (tail.length === 0) {
+      blobEnd = rewritten.length;
+    } else {
+      blobEnd = rewritten.indexOf(tail, rewrittenPos);
+      if (blobEnd === -1) return null;
+    }
+    pairs.push({ from: match.uri, to: rewritten.slice(rewrittenPos, blobEnd) });
+    rewrittenPos = blobEnd;
+  }
+  if (rewritten.slice(rewrittenPos) !== savedContent.slice(savedPos)) return null;
+
+  let result = currentValue;
+  for (const pair of pairs) {
+    if (pair.from === pair.to) continue;
+    const idx = result.indexOf(pair.from);
+    if (idx === -1) return null;
+    result = result.slice(0, idx) + pair.to + result.slice(idx + pair.from.length);
+  }
+  return result;
+}

data/app/jobs/collavre/drop_trigger_job.rb

@@ -8,6 +8,8 @@ module Collavre
     # This triggers retry_on instead of silently succeeding.
     class DispatchFailedError < StandardError; end
 
+    DROP_TRIGGER_TOPIC_NAME = "Drop Trigger"
+
     retry_on DispatchFailedError, wait: 5.seconds, attempts: 3
 
     # End-to-end idempotent: safe to retry at any point.
@@ -57,9 +59,8 @@ module Collavre
     private
 
     def post_trigger_failure_notice(child, parent)
-      topic = child.topics.find_or_create_by!(name: "Drop Trigger") do |t|
-        t.user = child.user
-      end
+      topic = child.topics.find_by(name: DROP_TRIGGER_TOPIC_NAME) ||
+              create_drop_trigger_topic(child)
       post_system_notice(child, topic, I18n.t(
         "collavre.drop_trigger.no_agent",
         parent_description: parent.creative_snippet
@@ -82,17 +83,45 @@ module Collavre
     end
 
     def find_or_create_trigger_topic(creative, agent)
-      topic = creative.topics.find_by(name: "Drop Trigger")
+      topic = creative.topics.find_by(name: DROP_TRIGGER_TOPIC_NAME)
       return topic if topic
 
-      topic = creative.topics.create!(
-        name: "Drop Trigger",
-        user: creative.user
-      )
+      topic = create_drop_trigger_topic(creative)
       topic.set_primary_agent!(agent)
       topic
     end
 
+    # Creates the Drop Trigger topic, branching from the creative's Main topic
+    # when Main has messages. Equivalent to the user manually selecting every
+    # Main message and pressing "branch" — only the resulting topic name is
+    # fixed to "Drop Trigger".
+    def create_drop_trigger_topic(creative)
+      main = creative.main_topic(fallback_user: creative.user)
+      # Mirror the manual "select all → branch" flow: only comments the owner
+      # can see are copied. enforce_limit: false bypasses the UI's 100-comment
+      # selection cap so full Main history transfers regardless of length.
+      main_comment_ids = main.comments
+                             .visible_to(creative.user)
+                             .order(:created_at)
+                             .pluck(:id)
+
+      if main_comment_ids.any?
+        # auto_select: false prevents the broadcast from hijacking the owner's
+        # current topic selection while this background job runs.
+        TopicBranchService.new(
+          creative: creative,
+          user: creative.user,
+          source_topic: main,
+          name: DROP_TRIGGER_TOPIC_NAME
+        ).call(comment_ids: main_comment_ids, enforce_limit: false, auto_select: false)
+      else
+        creative.topics.create!(
+          name: DROP_TRIGGER_TOPIC_NAME,
+          user: creative.user
+        )
+      end
+    end
+
     def trigger_content_key(child, parent)
       I18n.t(
         "collavre.drop_trigger.child_entered",

data/app/mailers/collavre/application_mailer.rb

@@ -1,6 +1,6 @@
 module Collavre
   class ApplicationMailer < ActionMailer::Base
-    default from: ENV.fetch("DEFAULT_MAILER_FROM", "no-reply@example.com")
+    default from: -> { Collavre::IntegrationSettings.fetch(:default_mailer_from, default: "no-reply@example.com") }
     layout "mailer"
 
     private

data/app/models/collavre/channel/injected_message.rb

@@ -0,0 +1,5 @@
+module Collavre
+  class Channel
+    InjectedMessage = Data.define(:speaker, :message, :label, :link)
+  end
+end