@lightcone-ai/daemon 0.15.2 → 0.15.3

package/mcp-servers/publisher/adapters/douyin.js

@@ -8,7 +8,6 @@ function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 function randomInt(min, max) { return Math.floor(min + Math.random() * (max - min + 1)); }
 
 const PACE_SCALE = Math.max(0.2, Number(process.env.PUBLISHER_PACE_SCALE ?? '1') || 1);
-const DRY_RUN = process.env.DOUYIN_PUBLISH_DRY_RUN !== '0';
 
 async function humanPause(minMs, maxMs, label = '') {
   const ms = Math.round(randomInt(minMs, maxMs) * PACE_SCALE);
@@ -22,14 +21,14 @@ const REQUIREMENTS = {
     max_images: 35,
     image_formats: ['jpg', 'jpeg', 'png', 'webp'],
     required_fields: ['text', 'images'],
-    notes: '图文模式最多 35 张图；正文最多 2200 字；默认停在最终发布前，需设置 DOUYIN_PUBLISH_DRY_RUN=0 才会点击发布',
+    notes: '图文模式最多 35 张图；正文最多 2200 字；自动化会填写后点击暂存，不会直接发布',
   },
   short_video: {
     max_text_length: 2200,
     video_max_duration: 900,
     video_formats: ['mp4', 'mov', 'webm'],
     required_fields: ['text', 'video'],
-    notes: '视频最长 15 分钟；建议 9:16 竖版；默认停在最终发布前，需设置 DOUYIN_PUBLISH_DRY_RUN=0 才会点击发布',
+    notes: '视频最长 15 分钟；建议 9:16 竖版；自动化会填写后点击暂存，不会直接发布',
   },
 };
 
@@ -70,6 +69,14 @@ const CONTENT_SELECTOR = [
   '.ProseMirror[contenteditable="true"]',
   '[contenteditable="true"]',
 ].join(', ');
+const CONTENT_EDITOR_SELECTOR = [
+  'textarea[placeholder*="描述"]',
+  'textarea[placeholder*="作品描述"]',
+  '[placeholder*="添加作品描述"]',
+  '[contenteditable="true"][data-placeholder*="描述"]',
+  '[contenteditable="true"][aria-label*="描述"]',
+  '.ProseMirror[contenteditable="true"]',
+].join(', ');
 
 const ERROR_SELECTORS = [
   '[class*="error"]',
@@ -125,18 +132,9 @@ export class DouyinAdapter {
 
     await humanPause(4500, 9000, 'before-publish-check');
     await this._assertNoBlockingErrors();
-    await this._assertPublishButtonReady();
-
-    if (DRY_RUN) {
-      console.error('[DouyinAdapter] DOUYIN_PUBLISH_DRY_RUN enabled; skipping final publish click.');
-      return { success: true, dry_run: true, post_url: null };
-    }
-
-    await humanPause(1200, 3000, 'before-publish-click');
-    const clicked = await this._clickByText('发布');
-    if (!clicked) throw new Error('PUBLISH_FAILED: 找不到发布按钮，页面结构可能已变化');
-    const result = await this._waitForPublishResult(120_000);
-    return { success: true, post_url: result.postUrl || result.url };
+    await this._assertDraftButtonReady();
+    const draftResult = await this._saveAsDraft();
+    return { success: true, draft_saved: true, draft_url: draftResult.url, post_url: null };
   }
 
   async publishShortVideo({ title, text, tags = [], video, cover }) {
@@ -163,18 +161,9 @@ export class DouyinAdapter {
 
     await humanPause(4500, 9000, 'before-publish-check');
     await this._assertNoBlockingErrors();
-    await this._assertPublishButtonReady();
-
-    if (DRY_RUN) {
-      console.error('[DouyinAdapter] DOUYIN_PUBLISH_DRY_RUN enabled; skipping final publish click.');
-      return { success: true, dry_run: true, post_url: null };
-    }
-
-    await humanPause(1200, 3000, 'before-publish-click');
-    const clicked = await this._clickByText('发布');
-    if (!clicked) throw new Error('PUBLISH_FAILED: 找不到发布按钮，页面结构可能已变化');
-    const result = await this._waitForPublishResult(120_000);
-    return { success: true, post_url: result.postUrl || result.url };
+    await this._assertDraftButtonReady();
+    const draftResult = await this._saveAsDraft();
+    return { success: true, draft_saved: true, draft_url: draftResult.url, post_url: null };
   }
 
   async _openPublishComposer(kind) {
@@ -325,7 +314,7 @@ export class DouyinAdapter {
             hasLoginHint: /登录|扫码|验证码|手机号/.test(text) && !/发布|作品管理|创作服务平台/.test(text),
             isCreatorLoggedIn: /创作服务平台|创作者中心|发布作品|作品管理|内容管理/.test(text),
             hasUploader: !!document.querySelector(${JSON.stringify(FILE_INPUT_SELECTOR)}),
-            hasPublishEditor: !!document.querySelector(${JSON.stringify(`${TITLE_SELECTOR}, ${CONTENT_SELECTOR}`)}) && /发布|作品描述|标题/.test(text),
+            hasPublishEditor: !!document.querySelector(${JSON.stringify(`${TITLE_SELECTOR}, ${CONTENT_EDITOR_SELECTOR}`)}) && /发布|作品描述|标题|暂存/.test(text),
             postUrl: document.querySelector('a[href*="/video/"]')?.href || document.querySelector('a[href*="/note/"]')?.href || '',
           };
         })()
@@ -366,34 +355,82 @@ export class DouyinAdapter {
     if (blocking) throw new Error(`PUBLISH_BLOCKED: ${blocking}`);
   }
 
-  async _assertPublishButtonReady() {
+  async _assertDraftButtonReady() {
     const state = await this._inspectPage();
-    const button = (state.buttons ?? []).find(b => b.text === '发布' || b.text?.includes('发布'));
-    if (!button) throw new Error('PUBLISH_FAILED: 找不到发布按钮，页面结构可能已变化');
+    const button = (state.buttons ?? []).find(b =>
+      b.text === '暂存'
+      || b.text?.includes('暂存')
+      || b.text?.includes('保存草稿')
+    );
+    if (!button) throw new Error('PUBLISH_FAILED: 找不到暂存按钮，页面结构可能已变化');
     if (button.disabled) {
-      const errors = (state.errors ?? []).join('；') || '发布按钮不可点击，可能仍在上传、必填项缺失或账号状态受限';
+      const errors = (state.errors ?? []).join('；') || '暂存按钮不可点击，可能仍在上传、必填项缺失或账号状态受限';
       throw new Error(`PUBLISH_BLOCKED: ${errors}`);
     }
   }
 
+  async _saveAsDraft() {
+    await humanPause(1200, 3000, 'before-save-draft-click');
+    const labels = ['暂存', '暂存离开', '保存草稿'];
+    for (const label of labels) {
+      const clicked = await this._clickByText(label);
+      if (!clicked) continue;
+      return this._waitForDraftSaved(60_000);
+    }
+    throw new Error('PUBLISH_FAILED: 找不到暂存按钮，页面结构可能已变化');
+  }
+
   async _waitForUploadSettled(expectedCount, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
+    const startedAt = Date.now();
+    let sawProgress = expectedCount === 0;
+    let stableReadyRounds = 0;
+    let pollCount = 0;
+    let lastHint = 'no_state';
+
     while (Date.now() < deadline) {
       await sleep(1000);
-      await this._assertNoBlockingErrors();
+      pollCount += 1;
+
       const state = await this._inspectPage();
+      const failureHint = this._extractUploadFailureHint(state);
+      if (failureHint) throw new Error(`UPLOAD_FAILED: ${failureHint}`);
+
       const text = state.text ?? '';
-      if (/上传失败|上传出错|格式不支持|文件过大/.test(text)) {
-        throw new Error(`UPLOAD_FAILED: ${(state.errors ?? []).join('；') || '页面提示上传失败'}`);
+      const processing = /上传中|处理中|转码中|正在上传|解析中|合成中|压缩中|扫描中|校验中/.test(text);
+      if (processing) sawProgress = true;
+
+      const composer = await this._probeComposerEditability();
+      const editorReady = composer.contentReady;
+      const draftReady = composer.draftButtonExists && composer.draftButtonDisabled !== true;
+      const uploadedHint = /上传成功|重新上传|更换|替换|已上传|继续编辑|移除/.test(text);
+      const completionSignal = sawProgress || uploadedHint || composer.mediaActionVisible;
+
+      lastHint = this._formatUploadWaitHint(state, composer, {
+        processing,
+        sawProgress,
+        completionSignal,
+        stableReadyRounds,
+      });
+
+      if (!processing && editorReady && draftReady && completionSignal) {
+        stableReadyRounds += 1;
+        if (stableReadyRounds >= 2) return;
+      } else if (!processing && editorReady && draftReady && (Date.now() - startedAt) >= 25_000) {
+        stableReadyRounds += 1;
+        if (stableReadyRounds >= 4) return;
+      } else {
+        stableReadyRounds = 0;
+      }
+
+      if (pollCount % 10 === 0) {
+        console.error(`[DouyinAdapter] wait-upload poll=${pollCount} ${lastHint}`);
       }
-      if (/上传中|处理中|转码中|正在上传|解析中|合成中/.test(text)) continue;
-      if (state.hasPublishEditor || /上传成功|重新上传|更换|已上传|封面|发布作品/.test(text)) return;
-      if (expectedCount === 0) return;
     }
-    throw new Error('UPLOAD_TIMEOUT: 等待抖音上传完成超时');
+    throw new Error(`UPLOAD_TIMEOUT: 等待抖音上传完成超时；${lastHint}`);
   }
 
-  async _waitForPublishResult(timeoutMs) {
+  async _waitForDraftSaved(timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     let lastState = null;
     while (Date.now() < deadline) {
@@ -401,15 +438,99 @@ export class DouyinAdapter {
       const state = await this._inspectPage();
       lastState = state;
       const text = state.text ?? '';
-      if (state.postUrl) return { url: state.url, postUrl: state.postUrl };
-      if (/发布成功|提交成功|审核中|已发布/.test(text)) {
-        return { url: state.url, postUrl: state.postUrl || state.url };
+      if (!state.url.includes('/creator-micro/content/upload') && !state.hasLoginHint) {
+        return { url: state.url };
       }
-      const blocking = (state.errors ?? []).find(t => /失败|错误|异常|不可|不能|未通过|风控|审核|违规|实名|认证|权限/.test(t));
+
+      if (/暂存成功|草稿已保存|保存成功|已保存草稿/.test(text)) {
+        return { url: state.url };
+      }
+      const blocking = (state.errors ?? []).find(t => /暂存失败|保存失败|提交失败|发布失败|系统异常|网络错误/.test(t));
       if (blocking) throw new Error(`PUBLISH_FAILED: ${blocking}`);
     }
-    const hint = (lastState?.errors ?? []).join('；') || '没有检测到成功跳转或成功提示';
-    throw new Error(`PUBLISH_TIMEOUT: ${hint}`);
+    const hint = this._formatPageHint(lastState ?? { url: await this._getUrl(), text: '', buttons: [], links: [], uploadish: [] });
+    throw new Error(`DRAFT_TIMEOUT: 点击暂存后未检测到成功提示；${hint}`);
+  }
+
+  async _probeComposerEditability() {
+    const result = await this._cdp.send('Runtime.evaluate', {
+      expression: `
+        (function() {
+          const visible = (el) => {
+            if (!el) return false;
+            const r = el.getBoundingClientRect();
+            const s = getComputedStyle(el);
+            return r.width > 0 && r.height > 0 && r.left > -1000 && s.display !== 'none' && s.visibility !== 'hidden';
+          };
+          const editable = (el) => visible(el)
+            && !el.disabled
+            && el.getAttribute('aria-disabled') !== 'true'
+            && el.getAttribute('readonly') !== 'true';
+          const textOf = (el) => (el.innerText || el.textContent || el.getAttribute('aria-label') || el.getAttribute('title') || '').trim();
+
+          const titleNodes = [...document.querySelectorAll(${JSON.stringify(TITLE_SELECTOR)})].filter(editable);
+          const strictContentNodes = [...document.querySelectorAll(${JSON.stringify(CONTENT_EDITOR_SELECTOR)})].filter(editable);
+          const genericContentNodes = [...document.querySelectorAll(${JSON.stringify(CONTENT_SELECTOR)})].filter(editable);
+
+          const buttonNodes = [...document.querySelectorAll('button, [role="button"], a, div, span')]
+            .filter(visible)
+            .map(el => ({
+              text: textOf(el),
+              disabled: !!el.disabled || el.getAttribute('aria-disabled') === 'true' || (el.className?.toString?.() || '').includes('disabled'),
+            }))
+            .filter(item => item.text);
+          const draftButton = buttonNodes.find(item => /暂存|暂存离开|保存草稿/.test(item.text));
+          const publishButton = buttonNodes.find(item => /发布/.test(item.text));
+          const mediaActionVisible = buttonNodes.some(item => /重新上传|更换|替换|移除|删除/.test(item.text));
+
+          return {
+            titleReady: titleNodes.length > 0,
+            contentReady: strictContentNodes.length > 0 || genericContentNodes.length > 0,
+            draftButtonExists: !!draftButton,
+            draftButtonDisabled: draftButton ? draftButton.disabled : null,
+            publishButtonExists: !!publishButton,
+            publishButtonDisabled: publishButton ? publishButton.disabled : null,
+            mediaActionVisible,
+          };
+        })()
+      `,
+      returnByValue: true,
+    });
+    return result.result?.value ?? {
+      titleReady: false,
+      contentReady: false,
+      draftButtonExists: false,
+      draftButtonDisabled: null,
+      publishButtonExists: false,
+      publishButtonDisabled: null,
+      mediaActionVisible: false,
+    };
+  }
+
+  _extractUploadFailureHint(state) {
+    const texts = [
+      ...(state.errors ?? []),
+      state.text ?? '',
+    ];
+    const fatal = texts.find(item => /上传失败|上传出错|转码失败|格式不支持|文件过大|上传异常|上传中断|网络异常/.test(item));
+    if (!fatal) return null;
+    return String(fatal).replace(/\s+/g, ' ').trim().slice(0, 180);
+  }
+
+  _formatUploadWaitHint(state, composer, flags = {}) {
+    const errors = (state.errors ?? []).join('；') || 'none';
+    return [
+      `url=${state.url}`,
+      `processing=${flags.processing === true}`,
+      `sawProgress=${flags.sawProgress === true}`,
+      `completionSignal=${flags.completionSignal === true}`,
+      `titleReady=${composer.titleReady === true}`,
+      `contentReady=${composer.contentReady === true}`,
+      `draftButton=${composer.draftButtonExists === true}`,
+      `draftDisabled=${composer.draftButtonDisabled === true}`,
+      `stableReadyRounds=${flags.stableReadyRounds ?? 0}`,
+      `errors=${errors.slice(0, 180)}`,
+    ].join('; ');
   }
 
   async _fillField(selector, value, kind = 'content') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.15.2",
+  "version": "0.15.3",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/agent-manager.js

@@ -124,6 +124,24 @@ function normalizeObject(value) {
   return isPlainObject(value) ? value : {};
 }
 
+function normalizePublishStage(value, fallback = 'unknown') {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (!normalized) return fallback;
+  return normalized.replace(/[^a-z0-9:_-]/g, '_');
+}
+
+function buildPublishJobFailureResult(error, fallbackStage = 'unknown') {
+  const stage = normalizePublishStage(error?.publish_stage, fallbackStage);
+  const message = String(error?.publish_error ?? error?.message ?? error ?? 'unknown_error');
+  const context = isPlainObject(error?.publish_context) ? error.publish_context : {};
+  return {
+    ok: false,
+    stage,
+    error: message,
+    context,
+  };
+}
+
 function replacePlaceholders(text, replacements) {
   if (typeof text !== 'string') return text;
   let next = text;
@@ -330,6 +348,79 @@ export class AgentManager {
     return 'system';
   }
 
+  _normalizeToolName(name) {
+    return String(name ?? '').trim().toLowerCase();
+  }
+
+  _isSendMessageToolName(name) {
+    const normalized = this._normalizeToolName(name);
+    return normalized === 'send_message'
+      || normalized.endsWith('__send_message')
+      || normalized.endsWith('.send_message');
+  }
+
+  _trackVisibleAssistantText(agent, text) {
+    if (!agent) return;
+    const snippet = String(text ?? '').trim();
+    if (!snippet) return;
+    agent.visibleTextSeen = true;
+    const previous = typeof agent.visibleTextBuffer === 'string' ? agent.visibleTextBuffer : '';
+    const next = previous ? `${previous}\n${snippet}` : snippet;
+    // Keep a bounded buffer for fallback delivery.
+    agent.visibleTextBuffer = next.length > 6000 ? next.slice(-6000) : next;
+  }
+
+  _markSendMessageToolUsed(agent) {
+    if (!agent) return;
+    agent.sendMessageUsed = true;
+  }
+
+  _resetVisibleReplyTracking(agent) {
+    if (!agent) return;
+    agent.visibleTextSeen = false;
+    agent.sendMessageUsed = false;
+    agent.visibleTextBuffer = '';
+  }
+
+  _rememberInboundMessage(agent, message) {
+    if (!agent || !message || typeof message !== 'object') return;
+    agent.lastInboundMessage = message;
+  }
+
+  async _recoverVisibleTextAsMessage({ agentId, workspaceId, message, content }) {
+    const text = String(content ?? '').trim();
+    if (!text || !message) return false;
+    const target = this._formatDeliveryTarget(message);
+    if (!target || target.includes('unknown')) return false;
+    const url = `${this.serverUrl}/internal/${encodeURIComponent(agentId)}/send`;
+    try {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.machineApiKey}`,
+        },
+        body: JSON.stringify({ target, content: text }),
+      });
+      if (!res.ok) {
+        const detail = (await res.text()).slice(0, 300);
+        console.warn(
+          `[AgentManager][${agentId}][claude] fallback_send_message failed workspace=${workspaceId ?? 'none'} status=${res.status} detail=${detail}`
+        );
+        return false;
+      }
+      console.warn(
+        `[AgentManager][${agentId}][claude] fallback_send_message sent workspace=${workspaceId ?? 'none'} target=${target}`
+      );
+      return true;
+    } catch (err) {
+      console.warn(
+        `[AgentManager][${agentId}][claude] fallback_send_message error workspace=${workspaceId ?? 'none'} err=${err?.message ?? 'unknown'}`
+      );
+      return false;
+    }
+  }
+
   _formatDeliveryHeaderValue(value) {
     const normalized = String(value ?? '').trim();
     if (!normalized) return 'unknown';
@@ -1123,6 +1214,10 @@ export class AgentManager {
         directive,
         requiredCredentials,
         lastStartupMessage: startupMsg?.message ?? null,
+        lastInboundMessage: startupMsg?.message ?? null,
+        visibleTextSeen: false,
+        sendMessageUsed: false,
+        visibleTextBuffer: '',
         stopCause: null,
       });
       this.starting.delete(key);
@@ -1172,9 +1267,13 @@ export class AgentManager {
         runtime: 'codex',
         codexVisibleTextSeen: false,
         codexSendMessageUsed: false,
+        visibleTextSeen: false,
+        sendMessageUsed: false,
+        visibleTextBuffer: '',
         directive,
         requiredCredentials,
         lastStartupMessage: startupMsg?.message ?? null,
+        lastInboundMessage: startupMsg?.message ?? null,
         stopCause: null,
       });
       this.starting.delete(key);
@@ -1197,9 +1296,13 @@ export class AgentManager {
         sessionId: config.sessionId ?? null,
         proc,
         runtime: 'claude',
+        visibleTextSeen: false,
+        sendMessageUsed: false,
+        visibleTextBuffer: '',
         directive,
         requiredCredentials,
         lastStartupMessage: startupMsg?.message ?? null,
+        lastInboundMessage: startupMsg?.message ?? null,
         stopCause: null,
       });
       this.starting.delete(key);
@@ -1500,6 +1603,12 @@ export class AgentManager {
           }
           if (stage === 'precheck_error') {
             console.error(`${logPrefix} precheck-error error=${payload.error ?? 'unknown_error'}`);
+            return;
+          }
+          if (stage === 'publish_action_error') {
+            console.error(
+              `${logPrefix} publish-action-error stage=${payload.stage ?? 'unknown'} error=${payload.error ?? 'unknown_error'}`
+            );
           }
         },
       });
@@ -1523,13 +1632,14 @@ export class AgentManager {
       });
     } catch (err) {
       const errorMessage = err?.message ?? String(err);
-      console.error(`${logPrefix} failed error=${errorMessage}`);
+      const failureResult = buildPublishJobFailureResult(err, 'publish_job');
+      console.error(`${logPrefix} failed stage=${failureResult.stage} error=${errorMessage}`);
       try {
         console.log(`${logPrefix} completion-post ok=false`);
         await this._postInternalPublishJobComplete({
           jobId,
           ok: false,
-          result: null,
+          result: failureResult,
           error: errorMessage,
         });
         console.log(`${logPrefix} completion-post posted ok=false`);
@@ -1546,6 +1656,7 @@ export class AgentManager {
         status: 'failed',
         completed_at: new Date().toISOString(),
         error: errorMessage,
+        result: failureResult,
       });
     }
   }
@@ -1591,6 +1702,7 @@ export class AgentManager {
       console.log(`[AgentManager] Queued seq=${seq} for codex next turn pending=${queueSize}`);
       return;
     }
+    this._rememberInboundMessage(agent, message);
     this._write(key, text);
   }
 
@@ -1612,6 +1724,7 @@ export class AgentManager {
       const text = this._formatDeliveryText(message);
       const agent = this.agents.get(key);
       console.log(`[AgentManager] Flushing queued seq=${seq} to agent ${agent?.config?.displayName ?? agentId.slice(0,8)} workspace=${message.workspace_name ?? workspaceId}`);
+      this._rememberInboundMessage(agent, message);
       this._write(key, text);
     }
   }
@@ -1671,11 +1784,13 @@ export class AgentManager {
           break;
         case 'text':
           agent.codexVisibleTextSeen = true;
+          this._trackVisibleAssistantText(agent, evt.text);
           console.log(`[AgentManager][${agent.config?.displayName ?? agentId.slice(0, 8)}][codex] <text> ${String(evt.text ?? '').slice(0, 500)}`);
           break;
         case 'tool_call':
-          if (evt.name === 'send_message') {
+          if (this._isSendMessageToolName(evt.name)) {
             agent.codexSendMessageUsed = true;
+            this._markSendMessageToolUsed(agent);
             this._recordSuccessfulOutboundMessage({
               key,
               agent,
@@ -1698,6 +1813,7 @@ export class AgentManager {
           break;
         case 'turn_end':
           agent.kimiIdle = true;
+          this._resetVisibleReplyTracking(agent);
           this._emitLifecycle(connection, {
             agentId,
             workspaceId,
@@ -1747,13 +1863,15 @@ export class AgentManager {
           break;
         case 'text':
           agent.codexVisibleTextSeen = true;
+          this._trackVisibleAssistantText(agent, evt.text);
           console.log(
             `[AgentManager][${agent.config?.displayName ?? agentId.slice(0, 8)}][codex][text] ${String(evt.text ?? '').slice(0, 1200)}`
           );
           break;
         case 'tool_call':
-          if (evt.name === 'send_message') {
+          if (this._isSendMessageToolName(evt.name)) {
             agent.codexSendMessageUsed = true;
+            this._markSendMessageToolUsed(agent);
             this._recordSuccessfulOutboundMessage({
               key,
               agent,
@@ -1787,6 +1905,7 @@ export class AgentManager {
           }
           agent.codexVisibleTextSeen = false;
           agent.codexSendMessageUsed = false;
+          this._resetVisibleReplyTracking(agent);
           this._emitLifecycle(connection, {
             agentId,
             workspaceId,
@@ -1813,10 +1932,10 @@ export class AgentManager {
     let event;
     try { event = JSON.parse(line); }
     catch { return; }
+    const agent = this.agents.get(key);
 
     // Capture and sync session ID
     if (event.session_id) {
-      const agent = this.agents.get(key);
       if (agent && agent.sessionId !== event.session_id) {
         agent.sessionId = event.session_id;
         connection.send({ type: 'agent:session', agentId, workspaceId, sessionId: event.session_id });
@@ -1824,27 +1943,26 @@ export class AgentManager {
     }
 
     // Activity state machine
-    const displayName = this.agents.get(key)?.config?.displayName ?? agentId.slice(0, 8);
+    const displayName = agent?.config?.displayName ?? agentId.slice(0, 8);
     if (event.type === 'assistant') {
       const content = event.message?.content ?? [];
       for (const block of content) {
         if (block.type === 'thinking') {
           console.log(`[AgentManager][${displayName}] <thinking> ${block.thinking?.slice(0, 500)}`);
         } else if (block.type === 'text') {
+          this._trackVisibleAssistantText(agent, block.text);
           console.log(`[AgentManager][${displayName}] <text> ${block.text?.slice(0, 500)}`);
         } else if (block.type === 'tool_use') {
           console.log(`[AgentManager][${displayName}] <tool_use> ${block.name} params=${JSON.stringify(block.input ?? {}).slice(0, 500)}`);
-          if (block.name === 'send_message') {
-            const agent = this.agents.get(key);
-            if (agent) {
-              this._recordSuccessfulOutboundMessage({
-                key,
-                agent,
-                agentId,
-                workspaceId,
-                connection,
-              });
-            }
+          if (this._isSendMessageToolName(block.name) && agent) {
+            this._markSendMessageToolUsed(agent);
+            this._recordSuccessfulOutboundMessage({
+              key,
+              agent,
+              agentId,
+              workspaceId,
+              connection,
+            });
           }
           this._emitLifecycle(connection, {
             agentId,
@@ -1854,7 +1972,7 @@ export class AgentManager {
             availability: 'busy',
             runtimeState: 'running',
             reason: `tool:${block.name ?? 'unknown_tool'}`,
-            sessionId: this.agents.get(key)?.sessionId ?? null,
+            sessionId: agent?.sessionId ?? null,
           });
           connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'working', detail: block.name, entries: [] });
         }
@@ -1868,7 +1986,7 @@ export class AgentManager {
           availability: 'busy',
           runtimeState: 'running',
           reason: 'thinking',
-          sessionId: this.agents.get(key)?.sessionId ?? null,
+          sessionId: agent?.sessionId ?? null,
         });
         connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'thinking', detail: '', entries: [] });
       }
@@ -1888,6 +2006,23 @@ export class AgentManager {
         console.log(`[AgentManager][${displayName}] <tool_result> id=${tr.tool_use_id ?? '?'} → ${resultStr}`);
       }
     } else if (event.type === 'result') {
+      const inboundSenderType = this._normalizeDeliverySenderType(agent?.lastInboundMessage?.sender_type);
+      if (inboundSenderType === 'user' && agent?.visibleTextSeen && !agent?.sendMessageUsed) {
+        agent.stopCause = 'contract_violation';
+        console.warn(
+          `[AgentManager][${displayName}][claude] contract_violation: visible text emitted without send_message workspace=${workspaceId ?? 'none'}`
+        );
+        const fallbackText = String(agent.visibleTextBuffer ?? '').trim();
+        if (fallbackText) {
+          void this._recoverVisibleTextAsMessage({
+            agentId,
+            workspaceId,
+            message: agent.lastInboundMessage,
+            content: fallbackText,
+          });
+        }
+      }
+      this._resetVisibleReplyTracking(agent);
       console.log(`[AgentManager][${displayName}] turn done (stop_reason=${event.stop_reason ?? '?'})`);
       this._emitLifecycle(connection, {
         agentId,
@@ -1897,7 +2032,7 @@ export class AgentManager {
         availability: 'available',
         runtimeState: 'running',
         reason: 'turn_end',
-        sessionId: this.agents.get(key)?.sessionId ?? null,
+        sessionId: agent?.sessionId ?? null,
       });
       connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'online', detail: '', entries: [] });
     }

package/src/drivers/claude.js

@@ -46,7 +46,7 @@ CRITICAL RULES:
 
 ## Startup sequence
 
-1. If this turn already includes a concrete incoming message with \`from=user\`, first decide whether it needs a visible acknowledgment, blocker question, or ownership signal. If it does, send it early with ${t("send_message")} before deep context gathering.
+1. If this turn already includes a concrete incoming message with \`from=user\`, your first user-visible action MUST be through ${t("send_message")} (or \`${t("create_tasks")}\` immediately followed by ${t("send_message")} for primary-agent execution dispatch).
 2. Read MEMORY.md (via ${t("read_memory")}) and then only the additional memory/notes files you need to handle the current turn well.
 3. If there is no concrete incoming message to handle, stop and wait. New messages will be delivered to you automatically via stdin.
 4. When you receive a message, first apply the audience-aware rules below before deciding whether to call ${t("send_message")}. Do not treat plain narrative output as a substitute for a visible reply.
@@ -73,7 +73,7 @@ Header fields:
 
 Each incoming message has a \`from=\` tag and should be handled as follows:
 
-- **from=user**: this is a real user request. You MUST acknowledge with ${t("send_message")} before deep context-gathering, even if the acknowledgment is short.
+- **from=user**: this is a real user request. Your first user-visible output MUST go through ${t("send_message")} (for execution dispatch as primary agent: \`${t("create_tasks")}\` first, then immediate ${t("send_message")} acknowledgment).
 - **from=peer-agent**: default is **no reply**. Reply only when at least one condition holds:
   1. You were explicitly @mentioned.
   2. You have materially new information that changes execution decisions.
@@ -136,10 +136,11 @@ Only top-level workspace / DM messages can become tasks. Messages inside threads
 5. After approval (e.g. "looks good", "merge it"), set status to \`done\`
 
 **Primary-agent dispatch hard rule (fail-closed):**
-- If your role is the workspace primary agent/owner and a user sends an execution request, you MUST call \`${t("create_tasks")}\` first and include an explicit \`scenario_type\` before routing work via \`${t("send_message")}\`.
+- If your role is the workspace primary agent/owner and a user sends an execution request, you MUST call \`${t("create_tasks")}\` first and include an explicit \`scenario_type\`, then immediately send a visible acknowledgment/update via \`${t("send_message")}\`.
 - Execution requests include requests like content writing, short-video scripting, research, design/asset production, implementation, or any request that requires downstream execution instead of a simple answer.
 - Use \`scenario_type\` values declared by your scenario manifest/dispatch protocol (for example: \`trend_scan\`, \`topic_research\`, \`research\`, \`graphic_writing\`, \`short_video_scripting\`, \`publish\`).
 - Do not route execution work with only \`${t("send_message")}\`: skipping \`${t("create_tasks")}\` can cause downstream \`${t("claim_tasks")}\` failures and deadlock the workflow.
+- If the request is a direct Q&A (no downstream execution dispatch needed), reply directly with \`${t("send_message")}\` and do not force \`${t("create_tasks")}\`.
 
 **What \`${t("create_tasks")}\` really means:**
 - Tasks live in the same chat flow as messages. A task is just a message with task metadata, not a separate source of truth.
@@ -186,6 +187,9 @@ Keep the user informed. They cannot see your internal reasoning, so:
 
 - **Respect ongoing conversations.** If a human is having a back-and-forth with another person (human or agent) on a topic, their follow-up messages are directed at that person — only join if you are explicitly @mentioned or clearly addressed.
 - **Only respond when relevant.** If a message does not @mention you and is not clearly directed at you or your expertise, do NOT respond. Let the appropriate agent handle it.
+- **No "cannot execute" noise.** Do not send standalone refusal/deflection messages like "I can't execute this", "this is not my job", or "ask another agent". These add noise.
+- **Out-of-scope without @mention = full silence.** If a message is outside your role scope and you were not directly @mentioned, produce no visible output.
+- **Direct @mention exception.** If you are directly @mentioned on out-of-scope work, send one short reroute message and include an @mention of the correct agent.
 - **Only the person doing the work should report on it.** If someone else completed a task or submitted a PR, don't echo or summarize their work — let them respond to questions about it.
 - **Claim before you start.** Always call \`${t("claim_tasks")}\` before doing any work on a task. If the claim fails, stop immediately and pick a different task.
 - **Before stopping, check for concrete blockers you own.** If you still owe a specific handoff, review, decision, or reply that is currently blocking a specific person, send one minimal actionable message to that person or workspace before stopping.

package/src/publish-job-runner.js

@@ -512,6 +512,30 @@ function emitPublishJobProgress(onProgress, stage, payload = {}) {
   }
 }
 
+function errorMessageOf(error) {
+  if (error?.message) return String(error.message);
+  return String(error);
+}
+
+function attachPublishStage(error, stage, context = {}) {
+  const err = error instanceof Error ? error : new Error(errorMessageOf(error));
+  const normalizedStage = String(stage ?? '').trim() || 'unknown';
+  const existingContext = err.publish_context && typeof err.publish_context === 'object'
+    ? err.publish_context
+    : {};
+
+  try { err.publish_stage = err.publish_stage || normalizedStage; } catch {}
+  try { err.publish_error = err.publish_error || errorMessageOf(error); } catch {}
+  try {
+    err.publish_context = {
+      ...existingContext,
+      ...context,
+      stage: normalizedStage,
+    };
+  } catch {}
+  return err;
+}
+
 export async function runPublishJob({ serverUrl, machineApiKey, agentId, workspaceDir, job, onProgress }) {
   if (!serverUrl || !machineApiKey || !agentId) {
     throw new Error('runPublishJob requires serverUrl, machineApiKey, and agentId');
@@ -530,81 +554,107 @@ export async function runPublishJob({ serverUrl, machineApiKey, agentId, workspa
     cover,
   } = buildJobInput(job);
   const ownerId = normalizeText(job?.owner_id ?? job?.ownerId);
+  const jobId = normalizeText(job?.id);
+  const stageContext = {
+    platform: platform || null,
+    contentType: contentType || null,
+    jobId: jobId ?? null,
+    ownerId: ownerId ?? null,
+  };
 
-  if (!platform) throw new Error('publish job missing platform');
-  if (!contentType) throw new Error('publish job missing content_type');
-  if (typeof text !== 'string' || !text.trim()) throw new Error('publish job missing text');
+  if (!platform) throw attachPublishStage(new Error('publish job missing platform'), 'input_validation', stageContext);
+  if (!contentType) throw attachPublishStage(new Error('publish job missing content_type'), 'input_validation', stageContext);
+  if (typeof text !== 'string' || !text.trim()) {
+    throw attachPublishStage(new Error('publish job missing text'), 'input_validation', stageContext);
+  }
 
   const resolvedWorkspaceDir = workspaceDir ?? process.cwd();
   const workspaceRootDir = path.dirname(resolvedWorkspaceDir);
+  stageContext.platform = platform;
+  stageContext.contentType = contentType;
 
+  let currentStage = 'precheck';
   let precheck = null;
   try {
-    precheck = await runPublishPrecheck({
+    currentStage = 'precheck';
+    try {
+      precheck = await runPublishPrecheck({
+        platform,
+        title,
+        text,
+        tags,
+        payload,
+        callTool: callOfficialTool,
+      });
+    } catch (error) {
+      emitPublishJobProgress(onProgress, 'precheck_error', {
+        platform,
+        error: errorMessageOf(error),
+      });
+      throw attachPublishStage(error, currentStage, stageContext);
+    }
+    emitPublishJobProgress(onProgress, 'precheck_done', {
       platform,
-      title,
-      text,
-      tags,
-      payload,
-      callTool: callOfficialTool,
+      ok: precheck.ok,
+      blockerCount: precheck.blockers.length,
+      warningCount: precheck.warnings.length,
     });
-  } catch (error) {
-    emitPublishJobProgress(onProgress, 'precheck_error', {
-      platform,
-      error: error.message ?? String(error),
+    if (!precheck.ok) {
+      currentStage = 'precheck_validate';
+      const blockerSummary = precheck.blockers.map(item => `${item.code}: ${item.message}`).join(' | ');
+      throw attachPublishStage(new Error(`PUBLISH_PRECHECK_BLOCKED:${blockerSummary || 'precheck failed'}`), currentStage, stageContext);
+    }
+
+    currentStage = 'materialize_media';
+    const localMedia = await materializeMedia({
+      images,
+      video,
+      cover,
+      workspaceId,
+      workspaceRootDir,
+      serverUrl,
+      machineApiKey,
+      jobId: job?.id,
     });
-    throw error;
-  }
-  emitPublishJobProgress(onProgress, 'precheck_done', {
-    platform,
-    ok: precheck.ok,
-    blockerCount: precheck.blockers.length,
-    warningCount: precheck.warnings.length,
-  });
-  if (!precheck.ok) {
-    const blockerSummary = precheck.blockers.map(item => `${item.code}: ${item.message}`).join(' | ');
-    throw new Error(`PUBLISH_PRECHECK_BLOCKED:${blockerSummary || 'precheck failed'}`);
-  }
 
-  const localMedia = await materializeMedia({
-    images,
-    video,
-    cover,
-    workspaceId,
-    workspaceRootDir,
-    serverUrl,
-    machineApiKey,
-    jobId: job?.id,
-  });
-  const staticAdapter = createStaticAdapter(platform);
-  const req = staticAdapter.getRequirements(contentType);
-  if (!req) throw new Error(`INPUT_UNSUPPORTED_CONTENT_TYPE: ${platform} does not support ${contentType}`);
-  emitPublishJobProgress(onProgress, 'publish_action_start', { platform, contentType });
+    currentStage = 'resolve_requirements';
+    const staticAdapter = createStaticAdapter(platform);
+    const req = staticAdapter.getRequirements(contentType);
+    if (!req) throw new Error(`INPUT_UNSUPPORTED_CONTENT_TYPE: ${platform} does not support ${contentType}`);
+    emitPublishJobProgress(onProgress, 'publish_action_start', { platform, contentType });
 
-  const media = validateMedia({
-    platform,
-    contentType,
-    ...localMedia,
-    workspaceDir: resolvedWorkspaceDir,
-    workspaceRootDir,
-  });
+    currentStage = 'validate_media';
+    const media = validateMedia({
+      platform,
+      contentType,
+      ...localMedia,
+      workspaceDir: resolvedWorkspaceDir,
+      workspaceRootDir,
+    });
 
-  try {
+    currentStage = 'publish_profile';
     const { publishResult, healthCheck } = await withPublisherProfile(platform, { ownerId }, async () => {
+      currentStage = 'adapter_session';
       const adapter = await getAdapter(platform, { ownerId });
+
+      currentStage = 'pre_publish_login';
       const prePublishLogin = await adapter.checkLoginStatus();
       if (prePublishLogin?.loggedIn === false) {
         throw new Error(`LOGIN_EXPIRED:${platform}`);
       }
+
       let publishResult = null;
       if (contentType === 'image_text') {
+        currentStage = 'adapter_publish_image_text';
         publishResult = await adapter.publishImageText({ title, text, tags, images: media.images });
       } else {
+        currentStage = 'adapter_publish_short_video';
         publishResult = await adapter.publishShortVideo({ title, text, tags, video: media.video, cover: media.cover });
       }
 
       let healthCheck = null;
       try {
+        currentStage = 'post_publish_health';
         healthCheck = await adapter.checkLoginStatus();
       } catch (error) {
         healthCheck = {
@@ -631,10 +681,18 @@ export async function runPublishJob({ serverUrl, machineApiKey, agentId, workspa
       precheck,
       healthCheck,
     };
-  } catch (err) {
-    if (err.message?.startsWith('LOGIN_EXPIRED')) {
+  } catch (error) {
+    const stagedError = attachPublishStage(error, currentStage, stageContext);
+    const errorMessage = errorMessageOf(stagedError);
+    if (errorMessage.startsWith('LOGIN_EXPIRED')) {
       closeSession(platform);
     }
-    throw err;
+    emitPublishJobProgress(onProgress, 'publish_action_error', {
+      platform,
+      contentType,
+      stage: stagedError.publish_stage ?? currentStage,
+      error: stagedError.publish_error ?? errorMessage,
+    });
+    throw stagedError;
   }
 }