metame-cli 1.4.15 → 1.4.18

package/scripts/daemon.js

@@ -49,14 +49,38 @@ try { skillEvolution = require('./skill-evolution'); } catch { /* graceful fallb
 // ---------------------------------------------------------
 // SKILL ROUTING (keyword → /skillname prefix, like metame-desktop)
 // ---------------------------------------------------------
+function isMacLocalOrchestratorIntent(prompt) {
+  const text = String(prompt || '').trim();
+  if (!text) return false;
+
+  // Explicit macOS automation keywords.
+  if (/\b(?:mac|macos|applescript|osascript|jxa|hammerspoon|aerospace|yabai|skhd|raycast|launchctl|keyboard maestro)\b/i.test(text)) {
+    return true;
+  }
+  if (/(自动化|辅助功能|系统设置|隐私|权限|锁屏|锁定屏幕|睡眠|休眠|静音|取消静音|音量)/.test(text)) {
+    return true;
+  }
+
+  // General verbs must be paired with explicit macOS targets to avoid over-routing.
+  const hasAction = /(?:打开|关闭|启动|退出|切到|唤起|锁屏|锁定屏幕|睡眠|休眠|静音|取消静音|调(?:高|低|整)?音量|open|launch|quit|activate|lock\s*screen|sleep|mute|unmute)/i.test(text);
+  const hasTarget = /(?:微信|WeChat|飞书|Feishu|Finder|Safari|Terminal|iTerm|系统设置|System Settings|电脑|System Events|mac)/i.test(text);
+  return hasAction && hasTarget;
+}
+
 const SKILL_ROUTES = [
   { name: 'macos-mail-calendar', pattern: /邮件|邮箱|收件箱|日历|日程|会议|schedule|email|mail|calendar|unread|inbox/i },
+  { name: 'macos-local-orchestrator', match: isMacLocalOrchestratorIntent },
   { name: 'heartbeat-task-manager', pattern: /提醒|remind|闹钟|定时|每[天周月]/i },
+  { name: 'skill-manager', pattern: /找技能|管理技能|更新技能|安装技能|skill manager|skill scout|(?:find|look for)\s+skills?/i },
+  { name: 'skill-evolution-manager', pattern: /\/evolve\b|复盘一下|记录一下(这个)?经验|保存到\s*skill|skill evolution/i },
 ];
 
 function routeSkill(prompt) {
   for (const r of SKILL_ROUTES) {
-    if (r.pattern.test(prompt)) return r.name;
+    const matched = typeof r.match === 'function'
+      ? r.match(prompt)
+      : (r.pattern ? r.pattern.test(prompt) : false);
+    if (matched) return r.name;
   }
   return null;
 }
@@ -79,6 +103,12 @@ function routeAgent(prompt, config) {
 
 const yaml = require('./resolve-yaml');
 const { parseInterval, formatRelativeTime, createPathMap } = require('./utils');
+const {
+  USAGE_RETENTION_DAYS_DEFAULT,
+  normalizeUsageCategory,
+} = require('./usage-classifier');
+const { createTaskBoard } = require('./task-board');
+const taskEnvelope = require('./daemon-task-envelope');
 const { createAdminCommandHandler } = require('./daemon-admin-commands');
 const { createExecCommandHandler } = require('./daemon-exec-commands');
 const { createOpsCommandHandler } = require('./daemon-ops-commands');
@@ -229,19 +259,56 @@ function restoreConfig() {
 
 let _cachedState = null;
 
+function ensureUsageShape(state) {
+  if (!state.usage || typeof state.usage !== 'object') state.usage = {};
+  if (!state.usage.categories || typeof state.usage.categories !== 'object') state.usage.categories = {};
+  if (!state.usage.daily || typeof state.usage.daily !== 'object') state.usage.daily = {};
+  const keepDays = Number(state.usage.retention_days);
+  state.usage.retention_days = Number.isFinite(keepDays) && keepDays >= 7
+    ? Math.floor(keepDays)
+    : USAGE_RETENTION_DAYS_DEFAULT;
+}
+
+function ensureStateShape(state) {
+  if (!state || typeof state !== 'object') return {
+    pid: null,
+    budget: { date: null, tokens_used: 0 },
+    tasks: {},
+    sessions: {},
+    started_at: null,
+    usage: { retention_days: USAGE_RETENTION_DAYS_DEFAULT, categories: {}, daily: {} },
+  };
+  if (!state.budget || typeof state.budget !== 'object') state.budget = { date: null, tokens_used: 0 };
+  if (typeof state.budget.tokens_used !== 'number') state.budget.tokens_used = Number(state.budget.tokens_used) || 0;
+  if (!Object.prototype.hasOwnProperty.call(state.budget, 'date')) state.budget.date = null;
+  if (!state.tasks || typeof state.tasks !== 'object') state.tasks = {};
+  if (!state.sessions || typeof state.sessions !== 'object') state.sessions = {};
+  ensureUsageShape(state);
+  return state;
+}
+
+function pruneDailyUsage(usage, todayIso) {
+  const keepDays = usage.retention_days || USAGE_RETENTION_DAYS_DEFAULT;
+  const cutoff = new Date(`${todayIso}T00:00:00.000Z`);
+  cutoff.setUTCDate(cutoff.getUTCDate() - (keepDays - 1));
+  const cutoffIso = cutoff.toISOString().slice(0, 10);
+  for (const day of Object.keys(usage.daily || {})) {
+    if (day < cutoffIso) delete usage.daily[day];
+  }
+}
+
 function _readStateFromDisk() {
   try {
     const s = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
-    if (!s.sessions) s.sessions = {};
-    return s;
+    return ensureStateShape(s);
   } catch {
-    return {
+    return ensureStateShape({
       pid: null,
       budget: { date: null, tokens_used: 0 },
       tasks: {},
       sessions: {},
       started_at: null,
-    };
+    });
   }
 }
 
@@ -251,9 +318,65 @@ function loadState() {
 }
 
 function saveState(state) {
-  _cachedState = state;
+  const next = ensureStateShape(state);
+  if (_cachedState && _cachedState !== next) {
+    const current = ensureStateShape(_cachedState);
+
+    const currentBudgetDate = String(current.budget.date || '');
+    const nextBudgetDate = String(next.budget.date || '');
+    const currentBudgetTokens = Math.max(0, Math.floor(Number(current.budget.tokens_used) || 0));
+    const nextBudgetTokens = Math.max(0, Math.floor(Number(next.budget.tokens_used) || 0));
+    if (currentBudgetDate && (!nextBudgetDate || currentBudgetDate > nextBudgetDate)) {
+      next.budget.date = currentBudgetDate;
+      next.budget.tokens_used = currentBudgetTokens;
+    } else if (currentBudgetDate && currentBudgetDate === nextBudgetDate) {
+      next.budget.tokens_used = Math.max(currentBudgetTokens, nextBudgetTokens);
+    }
+
+    const currentKeepDays = Number(current.usage.retention_days) || USAGE_RETENTION_DAYS_DEFAULT;
+    const nextKeepDays = Number(next.usage.retention_days) || USAGE_RETENTION_DAYS_DEFAULT;
+    next.usage.retention_days = Math.max(currentKeepDays, nextKeepDays);
+
+    for (const [category, curMeta] of Object.entries(current.usage.categories || {})) {
+      if (!next.usage.categories[category] || typeof next.usage.categories[category] !== 'object') {
+        next.usage.categories[category] = {};
+      }
+      const curTotal = Math.max(0, Math.floor(Number(curMeta && curMeta.total) || 0));
+      const nextTotal = Math.max(0, Math.floor(Number(next.usage.categories[category].total) || 0));
+      if (curTotal > nextTotal) next.usage.categories[category].total = curTotal;
+
+      const curUpdated = String(curMeta && curMeta.updated_at || '');
+      const nextUpdated = String(next.usage.categories[category].updated_at || '');
+      if (curUpdated && curUpdated > nextUpdated) next.usage.categories[category].updated_at = curUpdated;
+    }
+
+    for (const [day, curDayUsageRaw] of Object.entries(current.usage.daily || {})) {
+      const curDayUsage = (curDayUsageRaw && typeof curDayUsageRaw === 'object') ? curDayUsageRaw : {};
+      if (!next.usage.daily[day] || typeof next.usage.daily[day] !== 'object') {
+        next.usage.daily[day] = {};
+      }
+      const nextDayUsage = next.usage.daily[day];
+      for (const [key, curValue] of Object.entries(curDayUsage)) {
+        const curNum = Math.max(0, Math.floor(Number(curValue) || 0));
+        const nextNum = Math.max(0, Math.floor(Number(nextDayUsage[key]) || 0));
+        if (curNum > nextNum) nextDayUsage[key] = curNum;
+      }
+      const categorySum = Object.entries(nextDayUsage)
+        .filter(([key]) => key !== 'total')
+        .reduce((sum, [, value]) => sum + Math.max(0, Math.floor(Number(value) || 0)), 0);
+      nextDayUsage.total = Math.max(Math.max(0, Math.floor(Number(nextDayUsage.total) || 0)), categorySum);
+    }
+
+    const currentUsageUpdated = String(current.usage.updated_at || '');
+    const nextUsageUpdated = String(next.usage.updated_at || '');
+    if (currentUsageUpdated && currentUsageUpdated > nextUsageUpdated) {
+      next.usage.updated_at = currentUsageUpdated;
+    }
+  }
+
+  _cachedState = next;
   try {
-    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), 'utf8');
+    fs.writeFileSync(STATE_FILE, JSON.stringify(next, null, 2), 'utf8');
   } catch (e) {
     log('ERROR', `Failed to save state: ${e.message}`);
   }
@@ -287,6 +410,7 @@ function buildProfilePreamble() {
 // BUDGET TRACKING
 // ---------------------------------------------------------
 function checkBudget(config, state) {
+  state = ensureStateShape(state);
   const today = new Date().toISOString().slice(0, 10);
   if (state.budget.date !== today) {
     state.budget.date = today;
@@ -297,14 +421,44 @@ function checkBudget(config, state) {
   return state.budget.tokens_used < limit;
 }
 
-function recordTokens(state, tokens) {
+function recordTokens(state, tokens, meta = null) {
+  const amount = Math.max(0, Math.floor(Number(tokens) || 0));
+  if (!amount) return;
+
+  const liveState = ensureStateShape(loadState());
   const today = new Date().toISOString().slice(0, 10);
-  if (state.budget.date !== today) {
-    state.budget.date = today;
-    state.budget.tokens_used = 0;
+  if (liveState.budget.date !== today) {
+    liveState.budget.date = today;
+    liveState.budget.tokens_used = 0;
   }
-  state.budget.tokens_used += tokens;
-  saveState(state);
+  liveState.budget.tokens_used += amount;
+
+  const category = normalizeUsageCategory(meta && meta.category, {
+    logger: (msg) => log('WARN', `[USAGE] ${msg}`),
+  });
+  ensureUsageShape(liveState);
+
+  if (!liveState.usage.categories[category] || typeof liveState.usage.categories[category] !== 'object') {
+    liveState.usage.categories[category] = { total: 0 };
+  }
+  liveState.usage.categories[category].total = (Number(liveState.usage.categories[category].total) || 0) + amount;
+  liveState.usage.categories[category].updated_at = new Date().toISOString();
+
+  if (!liveState.usage.daily[today] || typeof liveState.usage.daily[today] !== 'object') {
+    liveState.usage.daily[today] = { total: 0 };
+  }
+  const dayUsage = liveState.usage.daily[today];
+  dayUsage.total = (Number(dayUsage.total) || 0) + amount;
+  dayUsage[category] = (Number(dayUsage[category]) || 0) + amount;
+  liveState.usage.updated_at = new Date().toISOString();
+  pruneDailyUsage(liveState.usage, today);
+
+  if (state && typeof state === 'object' && state !== liveState) {
+    state.budget = liveState.budget;
+    state.usage = liveState.usage;
+  }
+
+  saveState(liveState);
 }
 
 
@@ -317,6 +471,10 @@ function getBudgetWarning(config, state) {
   return 'ok';
 }
 
+const taskBoard = createTaskBoard({
+  logger: (msg) => log('WARN', msg),
+});
+
 // ---------------------------------------------------------
 // AGENT DISPATCH — virtual chatId inter-agent communication
 // ---------------------------------------------------------
@@ -349,25 +507,29 @@ function createNullBot(onOutput) {
  * Forward bot: routes all calls to a real bot with a fixed chatId.
  * Used for dispatch tasks so Claude's streaming output appears in the target's Feishu channel.
  */
-function createStreamForwardBot(realBot, chatId) {
+function createStreamForwardBot(realBot, chatId, onOutput = null) {
   // Track edit-broken state independently so dispatch failures don't poison realBot's flag
   let _editBroken = false;
   return {
     sendMessage: async (_, text) => {
       log('INFO', `[StreamBot→${chatId.slice(-8)}] msg: ${String(text).slice(0, 80)}`);
+      if (onOutput) onOutput(text);
       return realBot.sendMessage(chatId, text);
     },
     sendMarkdown: async (_, text) => {
       log('INFO', `[StreamBot→${chatId.slice(-8)}] md: ${String(text).slice(0, 80)}`);
+      if (onOutput) onOutput(text);
       return realBot.sendMarkdown(chatId, text);
     },
     sendCard: async (_, card) => {
       const title = typeof card === 'object' ? (card.title || card.body || '').slice(0, 60) : String(card).slice(0, 60);
       log('INFO', `[StreamBot→${chatId.slice(-8)}] card: ${title}`);
+      if (onOutput) onOutput(typeof card === 'object' ? (card.body || card.title || JSON.stringify(card)) : card);
       return realBot.sendCard(chatId, card);
     },
     sendRawCard: async (_, header, elements) => {
       log('INFO', `[StreamBot→${chatId.slice(-8)}] rawcard: ${String(header).slice(0, 60)}`);
+      if (onOutput) onOutput(header);
       return realBot.sendRawCard(chatId, header, elements);
     },
     sendButtons: async (_, text, buttons) => realBot.sendButtons(chatId, text, buttons),
@@ -391,6 +553,76 @@ function createStreamForwardBot(realBot, chatId) {
   };
 }
 
+function extractArtifactPaths(text) {
+  const out = new Set();
+  const src = String(text || '');
+  const re = /\[\[FILE:([^\]]+)\]\]/g;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    const v = String(m[1] || '').trim();
+    if (v) out.add(v.slice(0, 500));
+  }
+  return [...out];
+}
+
+function inferTaskStatusFromOutput(text) {
+  const s = String(text || '');
+  if (/(^|\b)(blocked|卡住|阻塞|waiting for|等待)(\b|$)/i.test(s)) return 'blocked';
+  if (/(^|\b)(failed|失败|error|异常|报错)(\b|$)/i.test(s)) return 'failed';
+  return 'done';
+}
+
+function summarizeTaskInputs(inputs) {
+  if (!inputs || typeof inputs !== 'object') return '(none)';
+  const lines = [];
+  for (const [k, v] of Object.entries(inputs)) {
+    if (typeof v === 'string') lines.push(`- ${k}: ${v}`);
+    else lines.push(`- ${k}: ${JSON.stringify(v)}`);
+    if (lines.length >= 8) break;
+  }
+  return lines.length > 0 ? lines.join('\n') : '(none)';
+}
+
+function buildDispatchChatId(targetProject, scopeId) {
+  const target = String(targetProject || '').trim();
+  if (!target) return '_agent_unknown';
+  const safeScope = taskEnvelope && taskEnvelope.normalizeScopeId
+    ? taskEnvelope.normalizeScopeId(scopeId, '')
+    : '';
+  if (safeScope) return `_scope_${safeScope}__${target}`;
+  return `_agent_${target}`;
+}
+
+function buildPromptFromTaskEnvelope(envelope, fallbackPrompt) {
+  const goal = envelope.goal || fallbackPrompt || 'No goal provided';
+  const dod = Array.isArray(envelope.definition_of_done) && envelope.definition_of_done.length > 0
+    ? envelope.definition_of_done.map((x, i) => `${i + 1}. ${x}`).join('\n')
+    : '1. 给出可执行的结果与关键结论\n2. 给出相关产物路径（如有）';
+  const inputs = summarizeTaskInputs(envelope.inputs || {});
+  const taskId = envelope.task_id || 'unknown';
+  const scopeId = envelope.scope_id || taskId;
+  const participants = Array.isArray(envelope.participants) && envelope.participants.length > 0
+    ? envelope.participants.join(', ')
+    : `${envelope.from_agent || 'unknown'}, ${envelope.to_agent || 'unknown'}`;
+  return [
+    `任务ID: ${taskId}`,
+    `协作Scope: ${scopeId}`,
+    `参与Agent: ${participants}`,
+    `任务目标: ${goal}`,
+    '',
+    '完成标准 (DoD):',
+    dod,
+    '',
+    '输入上下文:',
+    inputs,
+    '',
+    '执行要求:',
+    '1. 先用1-2句“计划：...”说明方案',
+    '2. 再执行任务',
+    '3. 结尾给出“结果摘要：...”和“产物：...”',
+  ].join('\n');
+}
+
 /**
  * Dispatch a task/message to another agent via virtual chatId.
  * @param {string} targetProject - project key (e.g. 'digital_me', 'desktop')
@@ -400,17 +632,56 @@ function createStreamForwardBot(realBot, chatId) {
  */
 function dispatchTask(targetProject, message, config, replyFn, streamOptions = null) {
   const LIMITS = { max_per_hour_per_target: 20, max_total_per_hour: 60, max_depth: 2 };
+  const payload = (message && message.payload && typeof message.payload === 'object')
+    ? message.payload
+    : {};
+
+  let envelope = null;
+  if (payload.task_envelope) {
+    try {
+      envelope = taskEnvelope.normalizeTaskEnvelope(payload.task_envelope, {
+        from_agent: message.from || 'unknown',
+        to_agent: targetProject,
+        task_kind: payload.task_envelope && payload.task_envelope.task_kind ? payload.task_envelope.task_kind : 'team',
+      });
+      const checked = taskEnvelope.validateTaskEnvelope(envelope);
+      if (!checked.ok) {
+        log('WARN', `Dispatch blocked: invalid task_envelope (${checked.error})`);
+        return { success: false, error: `invalid_task_envelope:${checked.error}` };
+      }
+    } catch (e) {
+      log('WARN', `Dispatch blocked: task_envelope parse failed (${e.message})`);
+      return { success: false, error: 'invalid_task_envelope' };
+    }
+  }
+
+  const markTaskBlocked = (reason) => {
+    if (!envelope || !taskBoard) return;
+    const nowIso = new Date().toISOString();
+    taskBoard.upsertTask({
+      ...envelope,
+      status: 'blocked',
+      last_error: reason,
+      updated_at: nowIso,
+    });
+    taskBoard.appendTaskEvent(envelope.task_id, 'dispatch_blocked', message.from || 'system', {
+      reason,
+      target: targetProject,
+    });
+  };
 
   // Anti-storm: check chain depth
   const chain = message.chain || [];
   if (chain.length >= LIMITS.max_depth) {
     log('WARN', `Dispatch blocked: max depth ${LIMITS.max_depth} reached (chain: ${chain.join('→')})`);
+    markTaskBlocked('max_depth_exceeded');
     return { success: false, error: 'max_depth_exceeded' };
   }
 
   // Anti-storm: check for cycles
   if (chain.includes(targetProject)) {
     log('WARN', `Dispatch blocked: cycle detected (${chain.join('→')}→${targetProject})`);
+    markTaskBlocked('cycle_detected');
     return { success: false, error: 'cycle_detected' };
   }
 
@@ -425,10 +696,12 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
       const toTarget = recent.filter(e => e.to === targetProject).length;
       if (toTarget >= LIMITS.max_per_hour_per_target) {
         log('WARN', `Dispatch blocked: rate limit to ${targetProject} (${toTarget}/${LIMITS.max_per_hour_per_target} per hour)`);
+        markTaskBlocked('rate_limit_target');
         return { success: false, error: 'rate_limit_target' };
       }
       if (recent.length >= LIMITS.max_total_per_hour) {
         log('WARN', `Dispatch blocked: total rate limit (${recent.length}/${LIMITS.max_total_per_hour} per hour)`);
+        markTaskBlocked('rate_limit_total');
         return { success: false, error: 'rate_limit_total' };
       }
     }
@@ -438,6 +711,7 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
 
   if (!_handleCommand) {
     log('WARN', 'Dispatch: handleCommand not yet bound, dropping task');
+    markTaskBlocked('handler_not_ready');
     return { success: false, error: 'handler_not_ready' };
   }
 
@@ -447,18 +721,52 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
     to: targetProject,
     type: message.type || 'task',
     priority: message.priority || 'normal',
-    payload: message.payload || {},
+    payload,
     callback: message.callback || false,
     new_session: !!message.new_session,
     chain: [...chain, message.from || 'unknown'],
+    task_id: envelope ? envelope.task_id : null,
+    scope_id: envelope ? envelope.scope_id : null,
     created_at: new Date().toISOString(),
   };
 
+  if (envelope && taskBoard) {
+    const nowIso = new Date().toISOString();
+    taskBoard.upsertTask({
+      ...envelope,
+      status: 'queued',
+      updated_at: nowIso,
+    });
+    taskBoard.appendTaskEvent(envelope.task_id, 'dispatch_enqueued', fullMsg.from || 'system', {
+      dispatch_id: fullMsg.id,
+      target: targetProject,
+      priority: fullMsg.priority,
+      scope_id: envelope.scope_id,
+    });
+    taskBoard.recordHandoff({
+      handoff_id: taskEnvelope.newHandoffId(),
+      task_id: envelope.task_id,
+      from_agent: envelope.from_agent || fullMsg.from || 'unknown',
+      to_agent: targetProject,
+      payload: {
+        dispatch_id: fullMsg.id,
+        scope_id: envelope.scope_id,
+        title: payload.title || '',
+        prompt: payload.prompt || '',
+      },
+      status: 'sent',
+      created_at: nowIso,
+      updated_at: nowIso,
+    });
+  }
+
   // Write to dispatch log for audit / rate-limiting
   if (!fs.existsSync(DISPATCH_DIR)) fs.mkdirSync(DISPATCH_DIR, { recursive: true });
   fs.appendFileSync(DISPATCH_LOG, JSON.stringify({ ...fullMsg, dispatched_at: new Date().toISOString() }) + '\n', 'utf8');
 
-  const rawPrompt = fullMsg.payload.prompt || fullMsg.payload.title || 'No prompt provided';
+  const rawPrompt = envelope
+    ? buildPromptFromTaskEnvelope(envelope, fullMsg.payload.prompt || fullMsg.payload.title || '')
+    : (fullMsg.payload.prompt || fullMsg.payload.title || 'No prompt provided');
 
   // Inject sender identity when dispatched by another agent (not directly from user)
   const userSources = new Set(['unknown', 'claude_session', '_claude_session', 'user']);
@@ -476,18 +784,35 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
   // Daemon sends the ack autonomously; Claude should just state its plan in the reply text.
   prompt = `[行为要求：回复开头用1-2句「计划：xxx」说明执行方案，再开始执行。不要调用 dispatch_to，daemon 会自动转发你的回复。]\n\n${prompt}`;
 
-  // Prefer target's real Feishu chatId so dispatch reuses the existing session
-  // (--resume, no CLAUDE.md re-read, no token waste). Fall back to _agent_* virtual
-  // All dispatches use _agent_* virtual chatId to ensure a clean session with
-  // the correct project context. Real Feishu chatIds are only for direct user messages.
+  // team task with scope_id uses scoped virtual chatId:
+  //   _scope_<scope_id>__<agent>
+  // which allows N-agent collaboration under the same task scope while
+  // keeping per-agent execution sessions isolated.
   const forceNew = !!fullMsg.new_session;
-  const dispatchChatId = `_agent_${targetProject}`;
+  const dispatchChatId = buildDispatchChatId(targetProject, envelope && envelope.scope_id);
   const sessionMode = forceNew ? 'fresh session (forced)' : 'existing virtual session';
   log('INFO', `Dispatching ${fullMsg.type} to ${targetProject} via ${sessionMode}: ${rawPrompt.slice(0, 80)}`);
 
+  let _taskFinalized = false;
   const outputHandler = (output) => {
     const outStr = typeof output === 'object' ? (output.body || JSON.stringify(output)) : String(output);
     log('INFO', `Dispatch output from ${targetProject}: ${outStr.slice(0, 200)}`);
+    if (envelope && taskBoard && !_taskFinalized && outStr.trim().length > 2) {
+      const status = inferTaskStatusFromOutput(outStr);
+      const artifacts = extractArtifactPaths(outStr);
+      const update = {
+        summary: outStr.slice(0, 1200),
+        artifacts,
+      };
+      if (status === 'failed') update.last_error = outStr.slice(0, 400);
+      taskBoard.markTaskStatus(envelope.task_id, status, update);
+      taskBoard.appendTaskEvent(envelope.task_id, 'task_result', targetProject, {
+        status,
+        preview: outStr.slice(0, 240),
+        artifact_count: artifacts.length,
+      });
+      _taskFinalized = true;
+    }
     if (replyFn && outStr.trim().length > 2) {
       replyFn(outStr);
     } else if (!replyFn && fullMsg.callback && fullMsg.from && config) {
@@ -507,7 +832,7 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
   // If streamOptions provided, use real bot so output appears in target's Feishu channel.
   // Otherwise fall back to nullBot which captures output for replyFn.
   const nullBot = streamOptions?.bot && streamOptions?.chatId
-    ? createStreamForwardBot(streamOptions.bot, streamOptions.chatId)
+    ? createStreamForwardBot(streamOptions.bot, streamOptions.chatId, outputHandler)
     : createNullBot(outputHandler);
   // Permission inheritance: if daemon runs with dangerously_skip_permissions, dispatched agents
   // inherit the same level — they need Write access for implementation tasks.
@@ -522,11 +847,19 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
     }
   }
   const dispatchReadOnly = !(config.daemon && config.daemon.dangerously_skip_permissions);
+  if (envelope && taskBoard) {
+    taskBoard.markTaskStatus(envelope.task_id, 'running', { summary: `dispatched via ${sessionMode}` });
+    taskBoard.appendTaskEvent(envelope.task_id, 'task_started', targetProject, { session_mode: sessionMode });
+  }
   _handleCommand(nullBot, dispatchChatId, prompt, config, null, null, dispatchReadOnly).catch(e => {
     log('ERROR', `Dispatch handleCommand failed for ${targetProject}: ${e.message}`);
+    if (envelope && taskBoard) {
+      taskBoard.markTaskStatus(envelope.task_id, 'failed', { last_error: e.message, summary: 'dispatch execution failed' });
+      taskBoard.appendTaskEvent(envelope.task_id, 'task_failed', targetProject, { error: e.message.slice(0, 200) });
+    }
   });
 
-  return { success: true, id: fullMsg.id };
+  return { success: true, id: fullMsg.id, task_id: envelope ? envelope.task_id : null };
 }
 
 /**
@@ -755,8 +1088,8 @@ const {
  */
 function attachOrCreateSession(chatId, projCwd, name) {
   const state = loadState();
-  // Virtual agent chatIds (_agent_*) always get a fresh one-shot session.
-  // They must not resume real sessions, to avoid concurrency conflicts.
+  // Virtual chatIds (_agent_* / _scope_*) are isolated from real user chats.
+  // This avoids cross-context session collisions between user chat and dispatch flows.
   const newSess = createSession(chatId, projCwd, name || '');
   state.sessions[chatId] = { id: newSess.id, cwd: projCwd, started: false };
   saveState(state);
@@ -1031,6 +1364,9 @@ const { handleAdminCommand } = createAdminCommandHandler({
   getAllTasks,
   dispatchTask,
   log,
+  skillEvolution,
+  taskBoard,
+  taskEnvelope,
 });
 
 const { handleSessionCommand } = createSessionCommandHandler({
@@ -1286,7 +1622,19 @@ async function main() {
 
   // Config validation: warn on unknown/suspect fields
   const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'heartbeat', 'budget', 'projects'];
-  const KNOWN_DAEMON = ['model', 'log_max_size', 'heartbeat_check_interval', 'session_allowed_tools', 'dangerously_skip_permissions', 'cooldown_seconds', 'agent_flow_ttl_ms', 'agent_bind_ttl_ms'];
+  const KNOWN_DAEMON = [
+    'model',
+    'log_max_size',
+    'heartbeat_check_interval',
+    'session_allowed_tools',
+    'dangerously_skip_permissions',
+    'cooldown_seconds',
+    'agent_flow_ttl_ms',
+    'agent_bind_ttl_ms',
+    'mac_control_mode',
+    'enable_nl_mac_control',
+    'enable_nl_mac_fallback',
+  ];
   const VALID_MODELS = ['sonnet', 'opus', 'haiku'];
   for (const key of Object.keys(config)) {
     if (!KNOWN_SECTIONS.includes(key)) log('WARN', `Config: unknown section "${key}" (typo?)`);