collavre 0.20.3 → 0.22.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/ai_agent_job.rb

@@ -9,12 +9,65 @@ module Collavre
         task = agent_id_or_task
         return if task.reload.status == "cancelled"
 
-        task.update!(status: "running")
         agent = task.agent
+
+        # Guard: same offline-session check as the agent_id branch below.
+        # Queued Claude Channel tasks resumed via Orchestration::AgentOrchestrator
+        # .dequeue_next_for_topic enter this branch as AiAgentJob.perform_later(task).
+        # If AgentChannel#unsubscribed cleared routing_expression while the
+        # task was queued (WS drop without DELETE /agent/:id, e.g. SIGKILL or
+        # network blip past the reconnect grace), and another completion later
+        # drains the queue, this task would otherwise be promoted to running →
+        # delegated and broadcast to a clientless agent:user:<id> stream —
+        # held until stuck recovery.
+        if agent.claude_channel_agent? && agent.routing_expression.blank?
+          Rails.logger.info(
+            "[AiAgentJob] Skipping resumed Claude Channel task #{task.id}: " \
+            "session offline (routing_expression blank)"
+          )
+          # Workflow subtasks created by WorkflowExecutor carry parent_task_id and
+          # no topic. If we only cancel the child and return, the parent workflow
+          # stays "running" with its current/pending creative state forever — no
+          # rescue path runs because we never raise. Mirror the StandardError
+          # rescue below: fail the child and notify the parent so the workflow
+          # transitions to "failed" with a failure_reason.
+          if task.parent_task_id.present?
+            task.update!(status: "failed")
+            Collavre::Comments::WorkflowExecutor.new(task.parent_task).fail_subtask!(
+              task,
+              error_message: "Claude Channel session offline before dispatch"
+            )
+          else
+            task.update!(status: "cancelled")
+          end
+          if task.trigger_event_payload&.key?("topic")
+            Orchestration::AgentOrchestrator.dequeue_next_for_topic(task.topic_id, task.creative_id)
+          end
+          return
+        end
+
+        task.update!(status: "running")
       else
         # Create new task
         agent = User.find(agent_id_or_task)
 
+        # Guard: skip if the Claude Channel session has unregistered (or its WS
+        # dropped) during the window between Scheduler enqueue and this job
+        # firing. AgentsController#destroy / AgentChannel#unsubscribed clear
+        # routing_expression on the per-session ai_user, so a blank value here
+        # means there is no live MCP client to receive the dispatch. Without
+        # this guard, a :delayed (busy / rate-limited) enqueue from
+        # Scheduler#evaluate would materialize a fresh Task, flip it to
+        # "delegated", and broadcast to a clientless agent:user:<id> stream
+        # — holding the topic/agent slot until stuck recovery.
+        if agent.claude_channel_agent? && agent.routing_expression.blank?
+          Rails.logger.info(
+            "[AiAgentJob] Skipping Claude Channel job for agent #{agent.id}: " \
+            "session offline (routing_expression blank, event=#{event_name})"
+          )
+          return
+        end
+
         # Guard: skip if there's already a running task for the same agent + comment
         comment_id = context&.dig("comment", "id")
         if comment_id && Task.duplicate_running_for_comment?(agent.id, comment_id)
@@ -48,15 +101,48 @@ module Collavre
 
       # Reserve resources before starting work
       tracker = Orchestration::ResourceTracker.for(agent)
-      resource_id = job_id || task.id
+      # Claude Channel tasks live past this job (MCP reply happens later), so
+      # reserve under the stable task.id — that's the key reply / cancel /
+      # stuck-recovery will use to release the slot.
+      is_claude_channel_agent = agent.claude_channel_agent?
+      resource_id = is_claude_channel_agent ? task.id : (job_id || task.id)
       tracker.reserve!(resource_id)
       should_release = true
 
       begin
+        # For Claude Channel agents, transition to "delegated" BEFORE dispatching.
+        # The MCP client can receive the broadcast and POST /reply on a different
+        # thread before AiAgentService#call returns; the reply handler only looks
+        # for status: "delegated" tasks, so a late update! would leave the
+        # already-answered task stuck in delegated until stuck recovery.
+        if is_claude_channel_agent
+          # Atomic running -> delegated transition. If AgentsController#destroy
+          # races us between reserve! above and this line and flips the task
+          # to "cancelled", the WHERE filter excludes us, rows_updated == 0,
+          # we skip dispatch, and the ensure block releases the slot. A
+          # separate reload + update! would let the cancel slip in between.
+          rows_updated = Task.where(id: task.id, status: "running").update_all(
+            status: "delegated", updated_at: Time.current
+          )
+          if rows_updated.zero?
+            task.reload
+            Rails.logger.info(
+              "[AiAgentJob] Claude Channel task #{task.id} not in running state " \
+              "(status=#{task.status}); skipping dispatch"
+            )
+            return
+          end
+          task.reload
+        end
+
         response_content = AiAgentService.new(task).call
 
+        # Claude Channel agents delegate via MCP; no immediate response expected
+        if is_claude_channel_agent
+          # Hold agent capacity until reply / cancel / stuck-recovery releases it.
+          should_release = false
         # Workflow subtasks with empty responses should retry, then fail
-        if task.parent_task_id.present? && response_content.blank?
+        elsif task.parent_task_id.present? && response_content.blank?
           max_retries = 2
           current_retry = task.retry_count || 0